code
stringlengths 31
1.05M
| apis
list | extract_api
stringlengths 97
1.91M
|
|---|---|---|
# Copyright (c) Microsoft Corporation.
# Licensed under the MIT license.
import numpy as np
from maro.rl import AbstractStateShaper
class ECRStateShaper(AbstractStateShaper):
def __init__(self, *, look_back, max_ports_downstream, port_attributes, vessel_attributes):
super().__init__()
self._look_back = look_back
self._max_ports_downstream = max_ports_downstream
self._port_attributes = port_attributes
self._vessel_attributes = vessel_attributes
self._dim = (look_back + 1) * (max_ports_downstream + 1) * len(port_attributes) + len(vessel_attributes)
def __call__(self, decision_event, snapshot_list):
tick, port_idx, vessel_idx = decision_event.tick, decision_event.port_idx, decision_event.vessel_idx
ticks = [tick - rt for rt in range(self._look_back-1)]
future_port_idx_list = snapshot_list["vessels"][tick: vessel_idx: 'future_stop_list'].astype('int')
port_features = snapshot_list["ports"][ticks: [port_idx] + list(future_port_idx_list): self._port_attributes]
vessel_features = snapshot_list["vessels"][tick: vessel_idx: self._vessel_attributes]
state = np.concatenate((port_features, vessel_features))
return str(port_idx), state
@property
def dim(self):
return self._dim
|
[
"numpy.concatenate"
] |
[((1172, 1220), 'numpy.concatenate', 'np.concatenate', (['(port_features, vessel_features)'], {}), '((port_features, vessel_features))\n', (1186, 1220), True, 'import numpy as np\n')]
|
from __future__ import division
import numpy as np
__all__ = ['subtract_CAR',
'subtract_common_median_reference']
def subtract_CAR(X, b_size=16):
"""
Compute and subtract common average reference in 16 channel blocks.
"""
channels, time_points = X.shape
s = channels // b_size
r = channels % b_size
X_1 = X[:channels-r].copy()
X_1 = X_1.reshape((s, b_size, time_points))
X_1 -= np.nanmean(X_1, axis=1, keepdims=True)
if r > 0:
X_2 = X[channels-r:].copy()
X_2 -= np.nanmean(X_2, axis=0, keepdims=True)
X = np.vstack([X_1.reshape((s*b_size, time_points)), X_2])
return X
else:
return X_1.reshape((s*b_size, time_points))
def subtract_common_median_reference(X, channel_axis=-2):
"""
Compute and subtract common median reference
for the entire grid.
Parameters
----------
X : ndarray (..., n_channels, n_time)
Data to common median reference.
Returns
-------
Xp : ndarray (..., n_channels, n_time)
Common median referenced data.
"""
median = np.nanmedian(X, axis=channel_axis, keepdims=True)
Xp = X - median
return Xp
|
[
"numpy.nanmean",
"numpy.nanmedian"
] |
[((431, 469), 'numpy.nanmean', 'np.nanmean', (['X_1'], {'axis': '(1)', 'keepdims': '(True)'}), '(X_1, axis=1, keepdims=True)\n', (441, 469), True, 'import numpy as np\n'), ((1105, 1154), 'numpy.nanmedian', 'np.nanmedian', (['X'], {'axis': 'channel_axis', 'keepdims': '(True)'}), '(X, axis=channel_axis, keepdims=True)\n', (1117, 1154), True, 'import numpy as np\n'), ((535, 573), 'numpy.nanmean', 'np.nanmean', (['X_2'], {'axis': '(0)', 'keepdims': '(True)'}), '(X_2, axis=0, keepdims=True)\n', (545, 573), True, 'import numpy as np\n')]
|
from __future__ import division
from __future__ import print_function
from __future__ import absolute_import
from __future__ import unicode_literals
import json
import numpy as np
import scipy.sparse as sparse
import defenses
import upper_bounds
class NumpyEncoder(json.JSONEncoder):
def default(self, obj):
if isinstance(obj, np.ndarray):
assert len(np.shape(obj)) == 1 # Can only handle 1D ndarrays
return obj.tolist()
elif isinstance(obj, np.floating):
return float(obj)
elif isinstance(obj, np.int16):
return str(obj)
else:
return super(NumpyEncoder, self).default(obj)
def get_class_map():
return {-1: 0, 1: 1}
def get_centroids(X, Y, class_map):
num_classes = len(set(Y))
num_features = X.shape[1]
centroids = np.zeros((num_classes, num_features))
for y in set(Y):
centroids[class_map[y], :] = np.mean(X[Y == y, :], axis=0)
return centroids
def get_centroid_vec(centroids):
assert centroids.shape[0] == 2
centroid_vec = centroids[0, :] - centroids[1, :]
centroid_vec /= np.linalg.norm(centroid_vec)
centroid_vec = np.reshape(centroid_vec, (1, -1))
return centroid_vec
# Can speed this up if necessary
def get_sqrt_inv_cov(X, Y, class_map):
num_classes = len(set(Y))
num_features = X.shape[1]
sqrt_inv_covs = np.zeros((num_classes, num_features, num_features))
for y in set(Y):
cov = np.cov(X[Y == y, :], rowvar=False)
U_cov, S_cov, _ = np.linalg.svd(cov + 1e-6 * np.eye(num_features))
print(' min eigenvalue of cov after 1e-6 reg is %s' % np.min(S_cov))
sqrt_inv_covs[class_map[y], ...] = U_cov.dot(np.diag(1 / np.sqrt(S_cov)).dot(U_cov.T))
return sqrt_inv_covs
# Can speed this up if necessary
def get_data_params(X, Y, percentile):
num_classes = len(set(Y))
num_features = X.shape[1]
centroids = np.zeros((num_classes, num_features))
class_map = get_class_map()
centroids = get_centroids(X, Y, class_map)
# Get radii for sphere
sphere_radii = np.zeros(2)
dists = defenses.compute_dists_under_Q(
X, Y,
Q=None,
centroids=centroids,
class_map=class_map,
norm=2)
for y in set(Y):
sphere_radii[class_map[y]] = np.percentile(dists[Y == y], percentile)
# Get vector between centroids
centroid_vec = get_centroid_vec(centroids)
# Get radii for slab
slab_radii = np.zeros(2)
for y in set(Y):
dists = np.abs(
(X[Y == y, :].dot(centroid_vec.T) - centroids[class_map[y], :].dot(centroid_vec.T)))
slab_radii[class_map[y]] = np.percentile(dists, percentile)
return class_map, centroids, centroid_vec, sphere_radii, slab_radii
def vstack(A, B):
if (sparse.issparse(A) or sparse.issparse(B)):
return sparse.vstack((A, B), format='csr')
else:
return np.concatenate((A, B), axis=0)
def add_points(x, y, X, Y, num_copies=1):
if num_copies == 0:
return X, Y
x = np.array(x).reshape(-1)
if sparse.issparse(X):
X_modified = sparse.vstack((
X,
sparse.csr_matrix(
np.tile(x, num_copies).reshape(-1, len(x)))))
else:
X_modified = np.append(
X,
np.tile(x, num_copies).reshape(-1, len(x)),
axis=0)
Y_modified = np.append(Y, np.tile(y, num_copies))
return X_modified, Y_modified
def copy_random_points(X, Y, mask_to_choose_from=None, target_class=1, num_copies=1,
random_seed=18, replace=False):
# Only copy from points where mask_to_choose_from == True
np.random.seed(random_seed)
combined_mask = (np.array(Y, dtype=int) == target_class)
if mask_to_choose_from is not None:
combined_mask = combined_mask & mask_to_choose_from
idx_to_copy = np.random.choice(
np.where(combined_mask)[0],
size=num_copies,
replace=replace)
if sparse.issparse(X):
X_modified = sparse.vstack((X, X[idx_to_copy, :]))
else:
X_modified = np.append(X, X[idx_to_copy, :], axis=0)
Y_modified = np.append(Y, Y[idx_to_copy])
return X_modified, Y_modified
def threshold(X):
return np.clip(X, 0, np.max(X))
def rround(X, random_seed=3, return_sparse=True):
if sparse.issparse(X):
X = X.toarray()
X_frac, X_int = np.modf(X)
X_round = X_int + (np.random.random_sample(X.shape) < X_frac)
if return_sparse:
return sparse.csr_matrix(X_round)
else:
return X_round
def rround_with_repeats(X, Y, repeat_points, random_seed=3, return_sparse=True):
X_round = rround(X, random_seed=random_seed, return_sparse=return_sparse)
assert Y.shape[0] == X.shape[0]
if repeat_points > 1:
pos_idx = 0
neg_idx = 0
for i in range(X_round.shape[0]):
if Y[i] == 1:
if pos_idx % repeat_points == 0:
last_pos_x = X_round[i, :]
else:
X_round[i, :] = last_pos_x
pos_idx += 1
else:
if neg_idx % repeat_points == 0:
last_neg_x = X_round[i, :]
else:
X_round[i, :] = last_neg_x
neg_idx += 1
return X_round
def project_onto_sphere(X, Y, radii, centroids, class_map):
for y in set(Y):
idx = class_map[y]
radius = radii[idx]
centroid = centroids[idx, :]
shifts_from_center = X[Y == y, :] - centroid
dists_from_center = np.linalg.norm(shifts_from_center, axis=1)
shifts_from_center[dists_from_center > radius, :] *= radius / np.reshape(dists_from_center[dists_from_center > radius], (-1, 1))
X[Y == y, :] = shifts_from_center + centroid
print("Number of (%s) points projected onto sphere: %s" % (y, np.sum(dists_from_center > radius)))
return X
def project_onto_slab(X, Y, v, radii, centroids, class_map):
"""
v^T x needs to be within radius of v^T centroid.
v is 1 x d and normalized.
"""
v = np.reshape(v / np.linalg.norm(v), (1, -1))
for y in set(Y):
idx = class_map[y]
radius = radii[idx]
centroid = centroids[idx, :]
# If v^T x is too large, then dists_along_v is positive
# If it's too small, then dists_along_v is negative
dists_along_v = (X[Y == y, :] - centroid).dot(v.T)
shifts_along_v = np.reshape(
dists_along_v - np.clip(dists_along_v, -radius, radius),
(1, -1))
X[Y == y, :] -= shifts_along_v.T.dot(v)
print("Number of (%s) points projected onto slab: %s" % (y, np.sum(np.abs(dists_along_v) > radius)))
return X
def get_projection_fn(
X_clean,
Y_clean,
sphere=True,
slab=True,
non_negative=False,
less_than_one=False,
use_lp_rounding=False,
percentile=90):
print(X_clean)
goal = 'find_nearest_point'
class_map, centroids, centroid_vec, sphere_radii, slab_radii = get_data_params(X_clean, Y_clean, percentile)
if use_lp_rounding or non_negative or less_than_one or (sphere and slab):
if use_lp_rounding:
projector = upper_bounds.Minimizer(
d=X_clean.shape[1],
use_sphere=sphere,
use_slab=slab,
non_negative=non_negative,
less_than_one=less_than_one,
constrain_max_loss=False,
goal=goal,
X=X_clean
)
projector = upper_bounds.Minimizer(
d=X_clean.shape[1],
use_sphere=sphere,
use_slab=slab,
non_negative=non_negative,
less_than_one=less_than_one,
constrain_max_loss=False,
goal=goal,
X=X_clean
)
else:
projector = upper_bounds.Minimizer(
d=X_clean.shape[1],
use_sphere=sphere,
use_slab=slab,
non_negative=non_negative,
less_than_one=less_than_one,
constrain_max_loss=False,
goal=goal
)
# Add back low-rank projection if we move back to just sphere+slab
def project_onto_feasible_set(
X, Y,
theta=None,
bias=None,
):
num_examples = X.shape[0]
proj_X = np.zeros_like(X)
for idx in range(num_examples):
x = X[idx, :]
y = Y[idx]
class_idx = class_map[y]
centroid = centroids[class_idx, :]
sphere_radius = sphere_radii[class_idx]
slab_radius = slab_radii[class_idx]
proj_X[idx, :] = projector.minimize_over_feasible_set(
None,
x,
centroid,
centroid_vec,
sphere_radius,
slab_radius)
num_projected = np.sum(np.max(X - proj_X, axis=1) > 1e-6)
print('Projected %s examples.' % num_projected)
return proj_X
else:
def project_onto_feasible_set(X, Y, theta=None, bias=None):
if sphere:
X = project_onto_sphere(X, Y, sphere_radii, centroids, class_map)
elif slab:
X = project_onto_slab(X, Y, centroid_vec, slab_radii, centroids, class_map)
return X
return project_onto_feasible_set
def filter_points_outside_feasible_set(X, Y,
centroids, centroid_vec,
sphere_radii, slab_radii,
class_map):
sphere_dists = defenses.compute_dists_under_Q(
X,
Y,
Q=None,
centroids=centroids,
class_map=class_map)
slab_dists = defenses.compute_dists_under_Q(
X,
Y,
Q=centroid_vec,
centroids=centroids,
class_map=class_map)
idx_to_keep = np.array([True] * X.shape[0])
for y in set(Y):
idx_to_keep[np.where(Y == y)[0][sphere_dists[Y == y] > sphere_radii[class_map[y]]]] = False
idx_to_keep[np.where(Y == y)[0][slab_dists[Y == y] > slab_radii[class_map[y]]]] = False
print(np.sum(idx_to_keep))
return X[idx_to_keep, :], Y[idx_to_keep]
|
[
"numpy.clip",
"numpy.sqrt",
"numpy.array",
"numpy.linalg.norm",
"numpy.cov",
"defenses.compute_dists_under_Q",
"numpy.mean",
"numpy.reshape",
"numpy.where",
"numpy.max",
"numpy.random.seed",
"numpy.concatenate",
"numpy.min",
"scipy.sparse.csr_matrix",
"numpy.tile",
"numpy.eye",
"numpy.abs",
"numpy.random.random_sample",
"scipy.sparse.issparse",
"numpy.shape",
"numpy.modf",
"upper_bounds.Minimizer",
"numpy.append",
"numpy.sum",
"numpy.zeros",
"numpy.percentile",
"scipy.sparse.vstack",
"numpy.zeros_like"
] |
[((833, 870), 'numpy.zeros', 'np.zeros', (['(num_classes, num_features)'], {}), '((num_classes, num_features))\n', (841, 870), True, 'import numpy as np\n'), ((1122, 1150), 'numpy.linalg.norm', 'np.linalg.norm', (['centroid_vec'], {}), '(centroid_vec)\n', (1136, 1150), True, 'import numpy as np\n'), ((1170, 1203), 'numpy.reshape', 'np.reshape', (['centroid_vec', '(1, -1)'], {}), '(centroid_vec, (1, -1))\n', (1180, 1203), True, 'import numpy as np\n'), ((1381, 1432), 'numpy.zeros', 'np.zeros', (['(num_classes, num_features, num_features)'], {}), '((num_classes, num_features, num_features))\n', (1389, 1432), True, 'import numpy as np\n'), ((1929, 1966), 'numpy.zeros', 'np.zeros', (['(num_classes, num_features)'], {}), '((num_classes, num_features))\n', (1937, 1966), True, 'import numpy as np\n'), ((2093, 2104), 'numpy.zeros', 'np.zeros', (['(2)'], {}), '(2)\n', (2101, 2104), True, 'import numpy as np\n'), ((2117, 2216), 'defenses.compute_dists_under_Q', 'defenses.compute_dists_under_Q', (['X', 'Y'], {'Q': 'None', 'centroids': 'centroids', 'class_map': 'class_map', 'norm': '(2)'}), '(X, Y, Q=None, centroids=centroids, class_map\n =class_map, norm=2)\n', (2147, 2216), False, 'import defenses\n'), ((2478, 2489), 'numpy.zeros', 'np.zeros', (['(2)'], {}), '(2)\n', (2486, 2489), True, 'import numpy as np\n'), ((3079, 3097), 'scipy.sparse.issparse', 'sparse.issparse', (['X'], {}), '(X)\n', (3094, 3097), True, 'import scipy.sparse as sparse\n'), ((3674, 3701), 'numpy.random.seed', 'np.random.seed', (['random_seed'], {}), '(random_seed)\n', (3688, 3701), True, 'import numpy as np\n'), ((3994, 4012), 'scipy.sparse.issparse', 'sparse.issparse', (['X'], {}), '(X)\n', (4009, 4012), True, 'import scipy.sparse as sparse\n'), ((4161, 4189), 'numpy.append', 'np.append', (['Y', 'Y[idx_to_copy]'], {}), '(Y, Y[idx_to_copy])\n', (4170, 4189), True, 'import numpy as np\n'), ((4339, 4357), 'scipy.sparse.issparse', 'sparse.issparse', (['X'], {}), '(X)\n', (4354, 4357), True, 'import scipy.sparse as sparse\n'), ((4404, 4414), 'numpy.modf', 'np.modf', (['X'], {}), '(X)\n', (4411, 4414), True, 'import numpy as np\n'), ((9839, 9930), 'defenses.compute_dists_under_Q', 'defenses.compute_dists_under_Q', (['X', 'Y'], {'Q': 'None', 'centroids': 'centroids', 'class_map': 'class_map'}), '(X, Y, Q=None, centroids=centroids, class_map\n =class_map)\n', (9869, 9930), False, 'import defenses\n'), ((9984, 10082), 'defenses.compute_dists_under_Q', 'defenses.compute_dists_under_Q', (['X', 'Y'], {'Q': 'centroid_vec', 'centroids': 'centroids', 'class_map': 'class_map'}), '(X, Y, Q=centroid_vec, centroids=centroids,\n class_map=class_map)\n', (10014, 10082), False, 'import defenses\n'), ((10139, 10168), 'numpy.array', 'np.array', (['([True] * X.shape[0])'], {}), '([True] * X.shape[0])\n', (10147, 10168), True, 'import numpy as np\n'), ((929, 958), 'numpy.mean', 'np.mean', (['X[Y == y, :]'], {'axis': '(0)'}), '(X[Y == y, :], axis=0)\n', (936, 958), True, 'import numpy as np\n'), ((1469, 1503), 'numpy.cov', 'np.cov', (['X[Y == y, :]'], {'rowvar': '(False)'}), '(X[Y == y, :], rowvar=False)\n', (1475, 1503), True, 'import numpy as np\n'), ((2311, 2351), 'numpy.percentile', 'np.percentile', (['dists[Y == y]', 'percentile'], {}), '(dists[Y == y], percentile)\n', (2324, 2351), True, 'import numpy as np\n'), ((2667, 2699), 'numpy.percentile', 'np.percentile', (['dists', 'percentile'], {}), '(dists, percentile)\n', (2680, 2699), True, 'import numpy as np\n'), ((2801, 2819), 'scipy.sparse.issparse', 'sparse.issparse', (['A'], {}), '(A)\n', (2816, 2819), True, 'import scipy.sparse as sparse\n'), ((2823, 2841), 'scipy.sparse.issparse', 'sparse.issparse', (['B'], {}), '(B)\n', (2838, 2841), True, 'import scipy.sparse as sparse\n'), ((2859, 2894), 'scipy.sparse.vstack', 'sparse.vstack', (['(A, B)'], {'format': '"""csr"""'}), "((A, B), format='csr')\n", (2872, 2894), True, 'import scipy.sparse as sparse\n'), ((2920, 2950), 'numpy.concatenate', 'np.concatenate', (['(A, B)'], {'axis': '(0)'}), '((A, B), axis=0)\n', (2934, 2950), True, 'import numpy as np\n'), ((3407, 3429), 'numpy.tile', 'np.tile', (['y', 'num_copies'], {}), '(y, num_copies)\n', (3414, 3429), True, 'import numpy as np\n'), ((3723, 3745), 'numpy.array', 'np.array', (['Y'], {'dtype': 'int'}), '(Y, dtype=int)\n', (3731, 3745), True, 'import numpy as np\n'), ((4035, 4072), 'scipy.sparse.vstack', 'sparse.vstack', (['(X, X[idx_to_copy, :])'], {}), '((X, X[idx_to_copy, :]))\n', (4048, 4072), True, 'import scipy.sparse as sparse\n'), ((4104, 4143), 'numpy.append', 'np.append', (['X', 'X[idx_to_copy, :]'], {'axis': '(0)'}), '(X, X[idx_to_copy, :], axis=0)\n', (4113, 4143), True, 'import numpy as np\n'), ((4269, 4278), 'numpy.max', 'np.max', (['X'], {}), '(X)\n', (4275, 4278), True, 'import numpy as np\n'), ((4518, 4544), 'scipy.sparse.csr_matrix', 'sparse.csr_matrix', (['X_round'], {}), '(X_round)\n', (4535, 4544), True, 'import scipy.sparse as sparse\n'), ((5596, 5638), 'numpy.linalg.norm', 'np.linalg.norm', (['shifts_from_center'], {'axis': '(1)'}), '(shifts_from_center, axis=1)\n', (5610, 5638), True, 'import numpy as np\n'), ((10397, 10416), 'numpy.sum', 'np.sum', (['idx_to_keep'], {}), '(idx_to_keep)\n', (10403, 10416), True, 'import numpy as np\n'), ((3047, 3058), 'numpy.array', 'np.array', (['x'], {}), '(x)\n', (3055, 3058), True, 'import numpy as np\n'), ((3908, 3931), 'numpy.where', 'np.where', (['combined_mask'], {}), '(combined_mask)\n', (3916, 3931), True, 'import numpy as np\n'), ((4438, 4470), 'numpy.random.random_sample', 'np.random.random_sample', (['X.shape'], {}), '(X.shape)\n', (4461, 4470), True, 'import numpy as np\n'), ((5710, 5776), 'numpy.reshape', 'np.reshape', (['dists_from_center[dists_from_center > radius]', '(-1, 1)'], {}), '(dists_from_center[dists_from_center > radius], (-1, 1))\n', (5720, 5776), True, 'import numpy as np\n'), ((6138, 6155), 'numpy.linalg.norm', 'np.linalg.norm', (['v'], {}), '(v)\n', (6152, 6155), True, 'import numpy as np\n'), ((7235, 7423), 'upper_bounds.Minimizer', 'upper_bounds.Minimizer', ([], {'d': 'X_clean.shape[1]', 'use_sphere': 'sphere', 'use_slab': 'slab', 'non_negative': 'non_negative', 'less_than_one': 'less_than_one', 'constrain_max_loss': '(False)', 'goal': 'goal', 'X': 'X_clean'}), '(d=X_clean.shape[1], use_sphere=sphere, use_slab=slab,\n non_negative=non_negative, less_than_one=less_than_one,\n constrain_max_loss=False, goal=goal, X=X_clean)\n', (7257, 7423), False, 'import upper_bounds\n'), ((7586, 7774), 'upper_bounds.Minimizer', 'upper_bounds.Minimizer', ([], {'d': 'X_clean.shape[1]', 'use_sphere': 'sphere', 'use_slab': 'slab', 'non_negative': 'non_negative', 'less_than_one': 'less_than_one', 'constrain_max_loss': '(False)', 'goal': 'goal', 'X': 'X_clean'}), '(d=X_clean.shape[1], use_sphere=sphere, use_slab=slab,\n non_negative=non_negative, less_than_one=less_than_one,\n constrain_max_loss=False, goal=goal, X=X_clean)\n', (7608, 7774), False, 'import upper_bounds\n'), ((7951, 8128), 'upper_bounds.Minimizer', 'upper_bounds.Minimizer', ([], {'d': 'X_clean.shape[1]', 'use_sphere': 'sphere', 'use_slab': 'slab', 'non_negative': 'non_negative', 'less_than_one': 'less_than_one', 'constrain_max_loss': '(False)', 'goal': 'goal'}), '(d=X_clean.shape[1], use_sphere=sphere, use_slab=slab,\n non_negative=non_negative, less_than_one=less_than_one,\n constrain_max_loss=False, goal=goal)\n', (7973, 8128), False, 'import upper_bounds\n'), ((8505, 8521), 'numpy.zeros_like', 'np.zeros_like', (['X'], {}), '(X)\n', (8518, 8521), True, 'import numpy as np\n'), ((1644, 1657), 'numpy.min', 'np.min', (['S_cov'], {}), '(S_cov)\n', (1650, 1657), True, 'import numpy as np\n'), ((6529, 6568), 'numpy.clip', 'np.clip', (['dists_along_v', '(-radius)', 'radius'], {}), '(dists_along_v, -radius, radius)\n', (6536, 6568), True, 'import numpy as np\n'), ((378, 391), 'numpy.shape', 'np.shape', (['obj'], {}), '(obj)\n', (386, 391), True, 'import numpy as np\n'), ((1557, 1577), 'numpy.eye', 'np.eye', (['num_features'], {}), '(num_features)\n', (1563, 1577), True, 'import numpy as np\n'), ((3313, 3335), 'numpy.tile', 'np.tile', (['x', 'num_copies'], {}), '(x, num_copies)\n', (3320, 3335), True, 'import numpy as np\n'), ((5901, 5935), 'numpy.sum', 'np.sum', (['(dists_from_center > radius)'], {}), '(dists_from_center > radius)\n', (5907, 5935), True, 'import numpy as np\n'), ((9113, 9139), 'numpy.max', 'np.max', (['(X - proj_X)'], {'axis': '(1)'}), '(X - proj_X, axis=1)\n', (9119, 9139), True, 'import numpy as np\n'), ((10210, 10226), 'numpy.where', 'np.where', (['(Y == y)'], {}), '(Y == y)\n', (10218, 10226), True, 'import numpy as np\n'), ((10310, 10326), 'numpy.where', 'np.where', (['(Y == y)'], {}), '(Y == y)\n', (10318, 10326), True, 'import numpy as np\n'), ((1724, 1738), 'numpy.sqrt', 'np.sqrt', (['S_cov'], {}), '(S_cov)\n', (1731, 1738), True, 'import numpy as np\n'), ((3198, 3220), 'numpy.tile', 'np.tile', (['x', 'num_copies'], {}), '(x, num_copies)\n', (3205, 3220), True, 'import numpy as np\n'), ((6715, 6736), 'numpy.abs', 'np.abs', (['dists_along_v'], {}), '(dists_along_v)\n', (6721, 6736), True, 'import numpy as np\n')]
|
#%% [markdown]
#
# We will load EEG data from the lab and attemp to build a classifier that distinguishes between learners and non-learners
#%%
import mne
import numpy as np
import os.path
import glob
import re
import pandas as pd
# try to enable cuda support to speed up filtering, make sure the MNE_USE_CUDA environment variable is set to true
mne.cuda.init_cuda()
DATA_DIR = "../../EEGdata/Fish_5Block"
event_dict = {
"cat":{
"1": 20,
"2": 21
}
}
data_path = os.path.join(DATA_DIR, "Tail/Learner/126670_EXP_FISH.bdf")
test_data = mne.io.read_raw_edf(data_path, preload=True)
# find the related behavioral data
participant_number = re.search(r"^(\d+)_EXP_FISH", os.path.basename(data_path))[1]
behav_path = [filename for filename in glob.glob(os.path.join(DATA_DIR, "EXP_fish2_Tomy/Cat_data/*.csv")) if participant_number in filename][0]
behav_df = pd.read_csv(behav_path)
learning_curve = behav_df["Resultat"].rolling(20).mean() # our in house definition of current learning performance
learning_time = (learning_curve >= 0.8).idxmax() # using a 80% correct categorization threshold
#%% [markdown]
# We now need to find the event times and give the same code to all stimulus presentation events since we don't want to differentiate among category 1 or 2
#%%
events = mne.find_events(test_data)
events = np.array(events)
events[events[:,2]==event_dict["cat"]["2"],2] = 20
events = events.tolist()
#%% [markdown]
# visualize data
#%%
#test_data.plot()
#%%
test_data.set_eeg_reference("average", projection=False)
test_data.filter(0.1, 50.0, n_jobs="cuda")
stim_epochs = mne.Epochs(test_data, events=events, event_id={"stimulus presentation":20}, tmin=-0.2, tmax=0.8, reject={"eeg":200-6})
# do basic cleaning by bandpass filtering, we will need to load the data
stim_epochs.load_data()
stim_epochs.resample(256)
#%% building the pytorch model
pass
|
[
"mne.cuda.init_cuda",
"pandas.read_csv",
"mne.find_events",
"mne.Epochs",
"numpy.array",
"mne.io.read_raw_edf"
] |
[((361, 381), 'mne.cuda.init_cuda', 'mne.cuda.init_cuda', ([], {}), '()\n', (379, 381), False, 'import mne\n'), ((591, 635), 'mne.io.read_raw_edf', 'mne.io.read_raw_edf', (['data_path'], {'preload': '(True)'}), '(data_path, preload=True)\n', (610, 635), False, 'import mne\n'), ((913, 936), 'pandas.read_csv', 'pd.read_csv', (['behav_path'], {}), '(behav_path)\n', (924, 936), True, 'import pandas as pd\n'), ((1357, 1383), 'mne.find_events', 'mne.find_events', (['test_data'], {}), '(test_data)\n', (1372, 1383), False, 'import mne\n'), ((1394, 1410), 'numpy.array', 'np.array', (['events'], {}), '(events)\n', (1402, 1410), True, 'import numpy as np\n'), ((1675, 1801), 'mne.Epochs', 'mne.Epochs', (['test_data'], {'events': 'events', 'event_id': "{'stimulus presentation': 20}", 'tmin': '(-0.2)', 'tmax': '(0.8)', 'reject': "{'eeg': 200 - 6}"}), "(test_data, events=events, event_id={'stimulus presentation': 20},\n tmin=-0.2, tmax=0.8, reject={'eeg': 200 - 6})\n", (1685, 1801), False, 'import mne\n')]
|
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy import integrate, optimize
from scipy.signal import savgol_filter
from dane import population as popu
dias_restar = 4 # Los últimos días de información que no se tienen en cuenta
dias_pred = 31 # Días sobre los cuáles se hará la predicción a corto plazo
media_movil = 4 # Días que se promediaran en las series para mitigar errores en los datos
Ciudades_dicc = {'Bog': 'Bogotá D.C.', 'Mde': 'Medellín', 'Cal': 'Cali', 'Brr': 'Barranquilla',
'Ctg': 'Cartagena de Indias'}
Ciudades = ['Bog','Mde','Cal', 'Brr', 'Ctg']
Covid_Col = pd.read_csv("https://www.datos.gov.co/api/views/gt2j-8ykr/rows.csv?accessType=DOWNLOAD", sep=',',
encoding='utf-8', low_memory=False)
def limpieza_datos():
# Covid_Col=pd.read_csv("C:\Users\danie\DS\vagrant4docker-master\laboratorios\covid-19-guaya-kilera\Casos_positivos_de_COVID-19_en_Colombia.csv", sep=',', encoding='utf-8', low_memory=False)
Covid_Col.drop(['ID de caso', 'Código DIVIPOLA', 'Departamento o Distrito ', 'País de procedencia', 'Tipo',
'Codigo departamento',
'Codigo pais', 'Tipo recuperación', 'Pertenencia etnica', 'Nombre grupo etnico', 'atención'],
axis=1, inplace=True)
Covid_Col['FIS'] = Covid_Col['FIS'].replace('Asintomático', np.nan)
Covid_Col['FIS'] = pd.to_datetime(Covid_Col['FIS'].str[:10])
Covid_Col['fecha reporte web'] = pd.to_datetime(Covid_Col['fecha reporte web'].str[:10])
Covid_Col['Fecha de notificación'] = pd.to_datetime(Covid_Col['Fecha de notificación'].str[:10])
Covid_Col['Fecha de muerte'] = pd.to_datetime(Covid_Col['Fecha de muerte'].str[:10])
Covid_Col['Fecha diagnostico'] = pd.to_datetime(Covid_Col['Fecha diagnostico'].str[:10])
Covid_Col['Fecha recuperado'] = pd.to_datetime(Covid_Col['Fecha recuperado'].str[:10])
# Covid_Col[(Covid_Col['Fecha diagnostico']<Covid_Col['Fecha de notificación']) & Covid_Col['FIS'].isnull()]
Covid_Col['Fecha contagio'] = Covid_Col['FIS']
Covid_Col.loc[Covid_Col['Fecha contagio'].isnull(), 'Fecha contagio'] = Covid_Col['Fecha de notificación']
Covid_Col.drop(['Fecha de notificación', 'FIS', 'Fecha diagnostico', 'fecha reporte web'], axis=1, inplace=True)
Covid_Col['Cantidad de personas'] = 1
Fecha_Inicio = Covid_Col['Fecha contagio'][0]
Fecha_Fin = max(Covid_Col['Fecha contagio']) - pd.to_timedelta(dias_restar, unit='d')
Fecha_Fin_pred = Fecha_Fin + pd.to_timedelta(dias_pred - 1, unit='d')
globals()['Fechas_pred_i'] = pd.date_range(start=Fecha_Inicio, end=Fecha_Fin_pred)
Fechas_evaluar_i = pd.date_range(start=Fecha_Inicio, end=Fecha_Fin)
Fechas_evaluar = pd.DataFrame(index=Fechas_evaluar_i)
for ciudad in Ciudades:
globals()["Covid_" + str(ciudad)] = Covid_Col[Covid_Col['Ciudad de ubicación'] == Ciudades_dicc[ciudad]]
globals()["nuevos_" + str(ciudad)] = globals()["Covid_" + str(ciudad)].groupby('Fecha contagio').sum()
globals()["nuevos_" + str(ciudad)].drop(['Edad'], axis=1, inplace=True)
globals()["nuevos_" + str(ciudad)] = pd.merge(Fechas_evaluar, globals()["nuevos_" + str(ciudad)], \
how='left', left_index=True, right_index=True)
globals()["nuevos_" + str(ciudad)] = globals()["nuevos_" + str(ciudad)].replace(np.nan, 0)
globals()["confirmados_" + str(ciudad)] = globals()["nuevos_" + str(ciudad)].cumsum()
globals()["nuevos_" + str(ciudad)].rename(columns={'Cantidad de personas': "Casos_nuevos_"}, inplace=True)
globals()["confirmados_" + str(ciudad)].rename(columns={'Cantidad de personas': "Casos_confirmados_"},
inplace=True)
globals()["recuperados_" + str(ciudad)] = globals()["Covid_" + str(ciudad)].groupby('Fecha recuperado').sum()
globals()["recuperados_" + str(ciudad)].drop(['Edad'], axis=1, inplace=True)
globals()["recuperados_" + str(ciudad)] = pd.merge(Fechas_evaluar, globals()["recuperados_" + str(ciudad)], \
how='left', left_index=True, right_index=True)
globals()["recuperados_" + str(ciudad)] = globals()["recuperados_" + str(ciudad)].replace(np.nan, 0)
# globals()["recuperados_" + str(ciudad)]=globals()["recuperados_" + str(ciudad)].cumsum()
globals()["recuperados_" + str(ciudad)].rename(columns={'Cantidad de personas': "Casos_recuperados_"},
inplace=True)
globals()["muertes_" + str(ciudad)] = globals()["Covid_" + str(ciudad)].groupby('Fecha de muerte').sum()
globals()["muertes_" + str(ciudad)].drop(['Edad'], axis=1, inplace=True)
globals()["muertes_" + str(ciudad)] = pd.merge(Fechas_evaluar, globals()["muertes_" + str(ciudad)], how='left', \
left_index=True, right_index=True)
globals()["muertes_" + str(ciudad)] = globals()["muertes_" + str(ciudad)].replace(np.nan, 0)
# globals()["muertes_" + str(ciudad)]=globals()["muertes_" + str(ciudad)].cumsum()
globals()["muertes_" + str(ciudad)].rename(columns={'Cantidad de personas': "muertes_"}, inplace=True)
globals()["activos_" + str(ciudad)] = pd.concat([globals()["confirmados_" + str(ciudad)], \
globals()["recuperados_" + str(ciudad)],
globals()["muertes_" + str(ciudad)],
globals()["nuevos_" + str(ciudad)]], axis=1)
globals()["activos_" + str(ciudad)]['Casos_activos_'] = globals()["activos_" + str(ciudad)][
"Casos_confirmados_"] - \
globals()["activos_" + str(ciudad)][
"Casos_recuperados_"].cumsum() - \
globals()["activos_" + str(ciudad)]["muertes_"].cumsum()
globals()["Casos_" + str(ciudad)] = globals()["activos_" + str(ciudad)].copy()
globals()["activos_" + str(ciudad)].drop(
["Casos_confirmados_", "Casos_recuperados_", "muertes_", "Casos_nuevos_"], axis=1, inplace=True)
globals()["Casos_" + str(ciudad)]["Total_recuperados_"] = globals()["Casos_" + str(ciudad)][
"Casos_recuperados_"].cumsum()
globals()["Casos_" + str(ciudad)]["Total_muertes_"] = globals()["Casos_" + str(ciudad)]["muertes_"].cumsum()
#%%
limpieza_datos()
#%%
def casos():
for ciudad in Ciudades:
globals()['N'+str(ciudad)] = popu(ciudad)
globals()['real_'+str(ciudad)] = [i for i in globals()["confirmados_" + str(ciudad)]['Casos_confirmados_']]
globals()['poly_pred_'+str(ciudad)] = savgol_filter(globals()['real_'+str(ciudad)], 51,3) # window size 51, polynomial order 1
globals()['df_pred_'+str(ciudad)] = pd.DataFrame(globals()['poly_pred_'+str(ciudad)])
globals()['df_real_'+str(ciudad)] = pd.DataFrame(globals()['real_'+str(ciudad)]) #Casos confirmados por día desde el caso 0
# return N,df_poly,df_vec_real,poly,vec_real_140,ciudad
# plt.figure(figsize=(12,6))
# plt.plot(globals()['poly_pred_'+str(ciudad)])
# plt.plot(globals()['real_'+str(ciudad)])
# plt.legend(["Predicción","Real"], loc='upper left')
# plt.title("Infecciones por COVID-19 desde el primer caso"+" "+ str(Ciudades_dicc.get(ciudad)), size=15)
# plt.xlabel("Days", size=13)
# plt.ylabel("Infecciones", size=13)
# plt.ylim(0, max(globals()['real_'+str(ciudad)])+1000)
# plt.show()
N = globals()['N'+str(ciudad)]
depart_df = pd.DataFrame()
depart_df['ConfirmedCases'] = globals()['real_'+str(ciudad)]
depart_df = depart_df[10:]
depart_df['day_count'] = list(range(1,len(depart_df)+1))
ydata = [i for i in depart_df.ConfirmedCases]
xdata = depart_df.day_count
ydata = np.array(ydata, dtype=float)
xdata = np.array(xdata, dtype=float)
inf0 = ydata[0]
sus0 = N - inf0
rec0 = 0.0
def sir_model(y, x, beta, gamma):
sus = -beta * y[0] * y[1] / N
rec = gamma * y[1]
inf = -(sus + rec)
return sus, inf, rec
def fit_odeint(x, beta, gamma):
return integrate.odeint(sir_model, (sus0, inf0, rec0), x, args=(beta, gamma))[:,1]
if ciudad == 'Bog':
popt = np.array([0.2783922953043075, 0.2165019796859231])
else:
popt, pcov = optimize.curve_fit(fit_odeint, xdata, ydata, maxfev=5000)
fitted = fit_odeint(xdata, *popt)
plt.plot(xdata, ydata, 'o')
plt.plot(xdata, fitted)
plt.title("Modelo SIR"+" "+ str(Ciudades_dicc.get(ciudad)), size=15)
plt.ylabel("Population infected")
plt.xlabel("Days")
plt.show()
print("Optimal parameters: beta =", popt[0], " and gamma = ", popt[1])
#%%
casos()
#%%
# t = np.linspace(0,400,400)
# import plotly.offline as py
#
# for ciudad in Ciudades:
# py.iplot([{
# 'x': t,
# 'y': globals()['real_' + str(ciudad)]
# }], filename='cufflinks/multiple-lines-on-same-chart')
#
# max(globals()['real_' + str(ciudad)])
#%%
valores = [(popt[0],popt[1])]
def modelo(beta,gamma):
# Initial values
I0, R0 = ydata[0], 0
###
S0 = N - I0 - R0
def deriv(y,t,N,beta, gamma):
S,I,R = y
dSdt = -beta * S * I /N
dIdt = beta * S * I /N - gamma * I
dRdt = gamma * I
return dSdt, dIdt, dRdt
#Vector de condiciones iniciales
y0 = S0, I0, R0
#Solucion Equation System
ret = integrate.odeint(deriv, y0, t, args=(N, beta, gamma))
S, I, R =ret.T
return I
import cufflinks as cf
import plotly.offline as py
py.iplot([{
'x':t,
'y': modelo(*valor),
'name': str(valor),
} for valor in valores], filename = 'cufflinks/multiple-lines-on-same-chart')
# plt.figure(figsize=(12, 8))
# #plt.plot(modelo(0.42715777117416, 0.36645292847392247)[0])
# plt.plot(modelo(0.42715777117416, 0.36645292847392247)[1])
# # plt.plot(modelo(0.42715777117416, 0.36645292847392247)[2])
# plt.ylabel('Población')
# plt.legend(['Susceptible', 'Infectados', 'Recuperados'])
# plt.xlabel('Días')
# plt.show()
|
[
"scipy.optimize.curve_fit",
"pandas.to_timedelta",
"pandas.read_csv",
"matplotlib.pyplot.ylabel",
"scipy.integrate.odeint",
"dane.population",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"numpy.array",
"pandas.date_range",
"pandas.DataFrame",
"pandas.to_datetime",
"matplotlib.pyplot.show"
] |
[((631, 774), 'pandas.read_csv', 'pd.read_csv', (['"""https://www.datos.gov.co/api/views/gt2j-8ykr/rows.csv?accessType=DOWNLOAD"""'], {'sep': '""","""', 'encoding': '"""utf-8"""', 'low_memory': '(False)'}), "(\n 'https://www.datos.gov.co/api/views/gt2j-8ykr/rows.csv?accessType=DOWNLOAD'\n , sep=',', encoding='utf-8', low_memory=False)\n", (642, 774), True, 'import pandas as pd\n'), ((1418, 1459), 'pandas.to_datetime', 'pd.to_datetime', (["Covid_Col['FIS'].str[:10]"], {}), "(Covid_Col['FIS'].str[:10])\n", (1432, 1459), True, 'import pandas as pd\n'), ((1497, 1552), 'pandas.to_datetime', 'pd.to_datetime', (["Covid_Col['fecha reporte web'].str[:10]"], {}), "(Covid_Col['fecha reporte web'].str[:10])\n", (1511, 1552), True, 'import pandas as pd\n'), ((1595, 1654), 'pandas.to_datetime', 'pd.to_datetime', (["Covid_Col['Fecha de notificación'].str[:10]"], {}), "(Covid_Col['Fecha de notificación'].str[:10])\n", (1609, 1654), True, 'import pandas as pd\n'), ((1689, 1742), 'pandas.to_datetime', 'pd.to_datetime', (["Covid_Col['Fecha de muerte'].str[:10]"], {}), "(Covid_Col['Fecha de muerte'].str[:10])\n", (1703, 1742), True, 'import pandas as pd\n'), ((1780, 1835), 'pandas.to_datetime', 'pd.to_datetime', (["Covid_Col['Fecha diagnostico'].str[:10]"], {}), "(Covid_Col['Fecha diagnostico'].str[:10])\n", (1794, 1835), True, 'import pandas as pd\n'), ((1872, 1926), 'pandas.to_datetime', 'pd.to_datetime', (["Covid_Col['Fecha recuperado'].str[:10]"], {}), "(Covid_Col['Fecha recuperado'].str[:10])\n", (1886, 1926), True, 'import pandas as pd\n'), ((2613, 2666), 'pandas.date_range', 'pd.date_range', ([], {'start': 'Fecha_Inicio', 'end': 'Fecha_Fin_pred'}), '(start=Fecha_Inicio, end=Fecha_Fin_pred)\n', (2626, 2666), True, 'import pandas as pd\n'), ((2691, 2739), 'pandas.date_range', 'pd.date_range', ([], {'start': 'Fecha_Inicio', 'end': 'Fecha_Fin'}), '(start=Fecha_Inicio, end=Fecha_Fin)\n', (2704, 2739), True, 'import pandas as pd\n'), ((2761, 2797), 'pandas.DataFrame', 'pd.DataFrame', ([], {'index': 'Fechas_evaluar_i'}), '(index=Fechas_evaluar_i)\n', (2773, 2797), True, 'import pandas as pd\n'), ((9772, 9825), 'scipy.integrate.odeint', 'integrate.odeint', (['deriv', 'y0', 't'], {'args': '(N, beta, gamma)'}), '(deriv, y0, t, args=(N, beta, gamma))\n', (9788, 9825), False, 'from scipy import integrate, optimize\n'), ((2466, 2504), 'pandas.to_timedelta', 'pd.to_timedelta', (['dias_restar'], {'unit': '"""d"""'}), "(dias_restar, unit='d')\n", (2481, 2504), True, 'import pandas as pd\n'), ((2538, 2578), 'pandas.to_timedelta', 'pd.to_timedelta', (['(dias_pred - 1)'], {'unit': '"""d"""'}), "(dias_pred - 1, unit='d')\n", (2553, 2578), True, 'import pandas as pd\n'), ((6881, 6893), 'dane.population', 'popu', (['ciudad'], {}), '(ciudad)\n', (6885, 6893), True, 'from dane import population as popu\n'), ((7915, 7929), 'pandas.DataFrame', 'pd.DataFrame', ([], {}), '()\n', (7927, 7929), True, 'import pandas as pd\n'), ((8181, 8209), 'numpy.array', 'np.array', (['ydata'], {'dtype': 'float'}), '(ydata, dtype=float)\n', (8189, 8209), True, 'import numpy as np\n'), ((8222, 8250), 'numpy.array', 'np.array', (['xdata'], {'dtype': 'float'}), '(xdata, dtype=float)\n', (8230, 8250), True, 'import numpy as np\n'), ((8818, 8845), 'matplotlib.pyplot.plot', 'plt.plot', (['xdata', 'ydata', '"""o"""'], {}), "(xdata, ydata, 'o')\n", (8826, 8845), True, 'import matplotlib.pyplot as plt\n'), ((8850, 8873), 'matplotlib.pyplot.plot', 'plt.plot', (['xdata', 'fitted'], {}), '(xdata, fitted)\n', (8858, 8873), True, 'import matplotlib.pyplot as plt\n'), ((8951, 8984), 'matplotlib.pyplot.ylabel', 'plt.ylabel', (['"""Population infected"""'], {}), "('Population infected')\n", (8961, 8984), True, 'import matplotlib.pyplot as plt\n'), ((8989, 9007), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""Days"""'], {}), "('Days')\n", (8999, 9007), True, 'import matplotlib.pyplot as plt\n'), ((9012, 9022), 'matplotlib.pyplot.show', 'plt.show', ([], {}), '()\n', (9020, 9022), True, 'import matplotlib.pyplot as plt\n'), ((8635, 8685), 'numpy.array', 'np.array', (['[0.2783922953043075, 0.2165019796859231]'], {}), '([0.2783922953043075, 0.2165019796859231])\n', (8643, 8685), True, 'import numpy as np\n'), ((8717, 8774), 'scipy.optimize.curve_fit', 'optimize.curve_fit', (['fit_odeint', 'xdata', 'ydata'], {'maxfev': '(5000)'}), '(fit_odeint, xdata, ydata, maxfev=5000)\n', (8735, 8774), False, 'from scipy import integrate, optimize\n'), ((8520, 8590), 'scipy.integrate.odeint', 'integrate.odeint', (['sir_model', '(sus0, inf0, rec0)', 'x'], {'args': '(beta, gamma)'}), '(sir_model, (sus0, inf0, rec0), x, args=(beta, gamma))\n', (8536, 8590), False, 'from scipy import integrate, optimize\n')]
|
# Copyright 2019 The Keras Tuner Authors
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Utilities for Tuner class."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import math
import numpy as np
import six
import tensorflow as tf
from tensorflow import keras
from ..abstractions import display
class TunerStats(object):
"""Track tuner statistics."""
def __init__(self):
self.num_generated_models = 0 # overall number of instances generated
self.num_invalid_models = 0 # how many models didn't work
self.num_oversized_models = 0 # num models with params> max_params
def summary(self, extended=False):
display.subsection('Tuning stats')
display.display_settings(self.get_config())
def get_config(self):
return {
'num_generated_models': self.num_generated_models,
'num_invalid_models': self.num_invalid_models,
'num_oversized_models': self.num_oversized_models
}
@classmethod
def from_config(cls, config):
stats = cls()
stats.num_generated_models = config['num_generated_models']
stats.num_invalid_models = config['num_invalid_models']
stats.num_oversized_models = config['num_oversized_models']
return stats
def get_max_epochs_and_steps(fit_args, fit_kwargs):
if fit_args:
x = tf.nest.flatten(fit_args)[0]
else:
x = tf.nest.flatten(fit_kwargs.get('x'))[0]
batch_size = fit_kwargs.get('batch_size', 32)
if hasattr(x, '__len__'):
max_steps = math.ceil(float(len(x)) / batch_size)
else:
max_steps = fit_kwargs.get('steps')
max_epochs = fit_kwargs.get('epochs', 1)
return max_epochs, max_steps
class TunerCallback(keras.callbacks.Callback):
def __init__(self, tuner, trial):
super(TunerCallback, self).__init__()
self.tuner = tuner
self.trial = trial
def on_epoch_begin(self, epoch, logs=None):
self.tuner.on_epoch_begin(
self.trial, self.model, epoch, logs=logs)
def on_batch_begin(self, batch, logs=None):
self.tuner.on_batch_begin(self.trial, self.model, batch, logs)
def on_batch_end(self, batch, logs=None):
self.tuner.on_batch_end(self.trial, self.model, batch, logs)
def on_epoch_end(self, epoch, logs=None):
self.tuner.on_epoch_end(
self.trial, self.model, epoch, logs=logs)
# TODO: Add more extensive display.
class Display(object):
def on_trial_begin(self, trial):
display.section('New model')
trial.summary()
def on_trial_end(self, trial):
display.section('Trial complete')
trial.summary()
def average_histories(histories):
"""Averages the per-epoch metrics from multiple executions."""
averaged = {}
metrics = histories[0].keys()
for metric in metrics:
values = []
for epoch_values in six.moves.zip_longest(
*[h[metric] for h in histories],
fillvalue=np.nan):
values.append(np.nanmean(epoch_values))
averaged[metric] = values
# Convert {str: [float]} to [{str: float}]
averaged = [dict(zip(metrics, vals)) for vals in zip(*averaged.values())]
return averaged
|
[
"six.moves.zip_longest",
"numpy.nanmean",
"tensorflow.nest.flatten"
] |
[((3473, 3545), 'six.moves.zip_longest', 'six.moves.zip_longest', (['*[h[metric] for h in histories]'], {'fillvalue': 'np.nan'}), '(*[h[metric] for h in histories], fillvalue=np.nan)\n', (3494, 3545), False, 'import six\n'), ((1924, 1949), 'tensorflow.nest.flatten', 'tf.nest.flatten', (['fit_args'], {}), '(fit_args)\n', (1939, 1949), True, 'import tensorflow as tf\n'), ((3606, 3630), 'numpy.nanmean', 'np.nanmean', (['epoch_values'], {}), '(epoch_values)\n', (3616, 3630), True, 'import numpy as np\n')]
|
import tkinter as tk
from tkinter import filedialog
from urllib.request import urlopen
from pathlib import Path
from tkinter import ttk
import numpy as np
import base64
import io
import re
from src.theme import theme
from src.algorithm import blosum
from src.utils import RichText
def qopen(path:str):
'''Opens and returns file content'''
with open(path, 'r') as fh:
content = fh.read()
return content
class Pysum(tk.Frame):
def __init__(self, title):
self.root = tk.Tk()
self.root.title(title)
self.root.configure(background='#ecffde')
self.root.columnconfigure(0, weight=1)
self.root.rowconfigure(1, weight=1)
self.style = ttk.Style()
self.style.theme_create('bio', settings=theme())
self.style.theme_use('bio')
self.font_1 = ('Helvetica', 10, 'bold')
self.font_2 = ('Helvetica', 10)
self.main_text = qopen('src/main_texts.txt').split('\n\n')
self.tabs = ttk.Notebook(self.root, padding=10)
self.result_frame = None
self.matrix_labels = None
self.matrix_result = None
self.add_tabs()
self.add_content_tool()
self.add_content_result()
self.add_content_about()
self.root.mainloop()
def add_tabs(self):
self.tool = ttk.Frame(self.tabs)
self.tabs.add(self.tool, text=' Tool ')
self.results = ttk.Frame(self.tabs)
self.tabs.add(self.results, text=' Results ')
self.about = ttk.Frame(self.tabs)
self.tabs.add(self.about, text=' About ')
self.tabs.grid(row=0, column=0)
def add_content_tool(self):
'''Adds all content to the tool tab'''
tool_frame = ttk.LabelFrame(self.tool, text="File Structure", padding=50, relief=tk.RIDGE)
tool_frame.grid(row=0, column=0, sticky=tk.E + tk.W + tk.N + tk.S)
tf_l1 = ttk.Label(tool_frame, text=self.main_text[0], font=self.font_1)
tf_l1.grid(row=0, column=0, pady=3, columnspan=3, sticky="w")
tf_l2 = ttk.Label(tool_frame, text=self.main_text[1], font=self.font_2)
tf_l2.grid(row=1, column=0, pady=3, columnspan=3, sticky="w")
tf_l3 = ttk.Label(tool_frame, text=self.main_text[2], font=self.font_1)
tf_l3.grid(row=2, column=0, pady=3, columnspan=3, sticky="w")
tf_l3 = ttk.Label(tool_frame, text=self.main_text[3], font=self.font_2)
tf_l3.grid(row=3, column=0, pady=3, columnspan=3, sticky="w")
# ---
in_frame = ttk.LabelFrame(self.tool, text="Input", padding=20, relief=tk.RIDGE)
in_frame.grid(row=1, column=0, sticky=tk.E + tk.W + tk.N + tk.S)
self.tf_textin = tk.Text(in_frame, height=6, width=50)
self.tf_textin.grid(row=1, column=0, columnspan=1, sticky="w")
self.tf_textin.insert(tk.END, self.main_text[4])
tf_open_text = ttk.Button(in_frame, text="Open File", command=self.tf_open_file)
tf_open_text.grid(row=1, column=1, sticky="news")
tf_clear_text = ttk.Button(in_frame, text="Clear Input", command=lambda: self.tf_textin.delete(1.0, tk.END))
tf_clear_text.grid(row=1, column=2, sticky="news")
tf_l4 = ttk.Label(in_frame, text=self.main_text[5], font=self.font_1)
tf_l4.grid(row=2, column=0, pady=5, columnspan=1, sticky="w")
self.xx_textin = tk.Text(in_frame, height=1, width=9)
self.xx_textin.grid(row=2, column=1, columnspan=1, sticky="w")
self.xx_textin.insert(tk.END, '')
tf_start_calc = ttk.Button(in_frame, text="CALCULATE!", command=self.check_input_and_pass)
tf_start_calc.grid(row=2, column=2, sticky="news")
def add_content_result(self):
'''Adds all content to the result tab, when calculate is called'''
if self.result_frame is not None:
# dynamicly resize window
self.result_frame.destroy()
self.result_frame = ttk.LabelFrame(self.results, text="Matrix Representation", padding=50, relief=tk.RIDGE)
self.result_frame.grid(row=0, column=0, sticky=tk.E + tk.W + tk.N + tk.S)
if self.matrix_result is None:
ttk.Label(self.result_frame, text="No result available.", font=self.font_2).grid(row=0, column=0, sticky="w")
return
for (row, col), value in np.ndenumerate(self.matrix_result):
if row == 0:
ttk.Label(self.result_frame, text=str(self.matrix_labels[col]), font=self.font_1).grid(row=row, column=col+1)
if col == 0:
ttk.Label(self.result_frame, width=2, text=str(self.matrix_labels[row]), font=self.font_1).grid(row=row+1, column=col)
_ = ttk.Entry(self.result_frame, width=8, font=self.font_2, justify='center')
_.insert(tk.END, str(value))
_.grid(row=row+1, column=col+1)
_.configure(state="readonly")
# ---
degree_frame = ttk.LabelFrame(self.results, text="BLOSUM Degree", padding=50, relief=tk.RIDGE)
degree_frame.grid(row=0, column=1, sticky=tk.E + tk.W + tk.N + tk.S)
ttk.Label(degree_frame, text=str(self.xx_textin.get("1.0", "end-1c").rstrip()), font=('consolas', 30, 'bold')).grid(row=0, column=0, sticky="news")
# ---
out_res_frame = ttk.LabelFrame(self.results, text="Output Settings", padding=50, relief=tk.RIDGE)
out_res_frame.grid(row=1, column=0, sticky=tk.E + tk.W + tk.N + tk.S)
out_res_printtoconsole = ttk.Button(out_res_frame, text="Print to console", command=self.print_res_console_save)
out_res_printtoconsole.grid(row=0, column=0, sticky="w")
out_res_printtoconsole = ttk.Button(out_res_frame, text="Save to file", command=lambda: self.print_res_console_save(save_file=True))
out_res_printtoconsole.grid(row=0, column=2, sticky="w")
def add_content_about(self, renderimg=False):
if renderimg and self.ab_frame is not None:
self.ab_frame.destroy()
self.render_about.destroy()
if not renderimg:
self.render_about = ttk.Button(self.about, text="RENDER IMAGES", command=lambda: self.add_content_about(True))
self.render_about.grid(row=0, column=0, sticky="e")
# This functions as README.md parser in combination witch the class RichText
self.ab_frame = ttk.LabelFrame(self.about, text='About this program', relief=tk.RIDGE)
self.ab_frame.grid(row=(0 if renderimg else 1), column=0, sticky=tk.E + tk.W + tk.N + tk.S)
self.images = [] # need to store reference because of tkinter
with open('README.md', 'r') as fh:
about = fh.readlines()
ab_text = RichText(self.ab_frame, width=73, wrap=tk.WORD)
ab_text.grid(row=0, column=0)
for line in about:
line = line.replace('\\', '')
line = line.replace('**', '')
line = line.replace('```', '')
# title of the readme
if line.startswith('##'):
ab_text.insert("end", line[3:], "h1")
elif line.startswith('#'):
ab_text.insert("end", 'PYSUM\n', "h1")
#extract the url in parentheis and insert image
elif line.startswith('!'):
if renderimg:
image_url = line.split('(')[1].split(')')[0]
image_url = image_url.replace('svg', 'gif').replace('dpi%7B300', 'dpi%7B200')
try:
image_byt = urlopen(image_url).read()
image_b64 = base64.encodestring(image_byt)
photo = tk.PhotoImage(data=image_b64)
ab_text.image_create(tk.END, image = photo)
ab_text.insert('end', '\n')
self.images.append(photo)
except:
self.warn(mode='badinternet', label_loc=self.about, row=2, col=0)
else:
ab_text.insert('end', '\n[NOT RENDERED YET, click on above button!]\n\n')
# draw bulletpoints
elif re.match(r'^[1-9]',line) or line.startswith('*'):
ab_text.insert_bullet('end', line.split(' ', 1)[1])
else:
ab_text.insert("end", line)
ab_text.configure(state='disabled')
return True
def print_res_console_save(self, save_file=False):
label_matrix = self.matrix_result.astype('str')
label2 = self.matrix_labels
label2 = np.asarray(['-'] + label2).reshape((len(label2)+1, 1))
label_matrix = np.vstack((self.matrix_labels, label_matrix))
label_matrix = np.hstack((label2, label_matrix))
header_str = f'BLOSUM{self.xx_textin.get("1.0", "end-1c").rstrip()} Matrix:'
result_str = '\n'.join([''.join(['{:8}'.format(item) for item in row]) for row in label_matrix])
if save_file:
file = filedialog.asksaveasfile(initialdir=str(Path.home()), mode='w', defaultextension=".txt")
if file is None:
return False
file.write(header_str + "\n" + result_str)
file.close()
else:
print(header_str + "\n" + result_str)
def tf_open_file(self):
tf_filename = filedialog.askopenfilename(initialdir=str(Path.home()), title="Select Text File", filetypes=
(("txt files", "*.txt"), ("all files", "*.*")))
if len(tf_filename) == 0:
return False
with open(tf_filename, 'r') as fh:
tf_text = fh.read()
self.tf_textin.delete("1.0", tk.END)
#self.tf_textin.insert(tk.END, tf_text)
self.tf_textin.insert(tk.END, f'--File sucessfully loaded: {len(tf_text.splitlines())} sequences found.--\n'+tf_text.replace(' ', ''))
def check_input_and_pass(self):
dna_sequences = []
initial_len = None
xx_number = self.xx_textin.get("1.0", "end-1c").rstrip().replace(' ', '')
# first check xx_blosum value
try:
xx_number = int(xx_number)
if not xx_number in range(1, 101):
self.warn(mode='xnumrange', label_loc=self.tool)
return False
except:
self.warn(mode='xnuminvalid', label_loc=self.tool)
return False
seq_string = self.tf_textin.get("1.0", tk.END).rstrip().replace(' ', '')
if len(seq_string.splitlines()) < 2:
self.warn(mode='empty', label_loc=self.tool)
return False
for i, line in enumerate(seq_string.upper().splitlines()):
if line.startswith('-'):
continue
if initial_len is None:
initial_len = len(line)
if initial_len != len(line):
self.warn(mode='len', line=i, label_loc=self.tool)
return False
else:
dna_sequences.append(line)
try:
matrix, lables = blosum(dna_sequences, xx_number)
if (matrix is None) and (labels is None):
return self.warn(mode='elimination', label_loc=self.tool)
else:
self.matrix_result, self.matrix_labels = matrix, lables
except:
self.warn(mode='something', line=i, label_loc=self.tool)
return False
self.add_content_result()
self.tabs.select([1])
def warn(self, mode:str, line:int=0, label_loc=None, row=2, col=0):
warn_msg = tk.StringVar()
if mode == 'len':
warn_msg.set(f'[WARNING] Sequence nr.{line+1} differs in lenght!')
elif mode == 'empty':
warn_msg.set(f'[WARNING] At least 2 Sequences must be given!')
elif mode == 'xnumrange':
warn_msg.set(f'[WARNING] BLOSUM Degree must be between 1-100!')
elif mode == 'xnuminvalid':
warn_msg.set(f'[WARNING] BLOSUM Degree must be a number!')
elif mode== 'elimination':
warn_msg.set(f'[WARNING] Only one Sequnce left after elimination!')
elif mode == 'something':
warn_msg.set(f'[WARNING] BLOSUM cant be computed with that sequences!')
elif mode== 'badinternet':
warn_msg.set(f'[WARNING] Internet connection is reqired!')
else:
warn_msg.set(f'[WARNING] This will never happen.')
warning_label = tk.Label(label_loc, textvariable=warn_msg, font=self.font_1, fg="red", bg='#ecffde')
warning_label.grid(row=row, column=col, pady=5, sticky="w")
self.root.after(4000, lambda: warn_msg.set(""))
|
[
"tkinter.ttk.Button",
"src.theme.theme",
"numpy.hstack",
"pathlib.Path.home",
"src.algorithm.blosum",
"tkinter.ttk.LabelFrame",
"base64.encodestring",
"src.utils.RichText",
"tkinter.Label",
"tkinter.ttk.Entry",
"tkinter.ttk.Frame",
"tkinter.ttk.Label",
"numpy.asarray",
"numpy.ndenumerate",
"tkinter.StringVar",
"numpy.vstack",
"urllib.request.urlopen",
"re.match",
"tkinter.ttk.Notebook",
"tkinter.PhotoImage",
"tkinter.ttk.Style",
"tkinter.Tk",
"tkinter.Text"
] |
[((500, 507), 'tkinter.Tk', 'tk.Tk', ([], {}), '()\n', (505, 507), True, 'import tkinter as tk\n'), ((702, 713), 'tkinter.ttk.Style', 'ttk.Style', ([], {}), '()\n', (711, 713), False, 'from tkinter import ttk\n'), ((984, 1019), 'tkinter.ttk.Notebook', 'ttk.Notebook', (['self.root'], {'padding': '(10)'}), '(self.root, padding=10)\n', (996, 1019), False, 'from tkinter import ttk\n'), ((1322, 1342), 'tkinter.ttk.Frame', 'ttk.Frame', (['self.tabs'], {}), '(self.tabs)\n', (1331, 1342), False, 'from tkinter import ttk\n'), ((1415, 1435), 'tkinter.ttk.Frame', 'ttk.Frame', (['self.tabs'], {}), '(self.tabs)\n', (1424, 1435), False, 'from tkinter import ttk\n'), ((1512, 1532), 'tkinter.ttk.Frame', 'ttk.Frame', (['self.tabs'], {}), '(self.tabs)\n', (1521, 1532), False, 'from tkinter import ttk\n'), ((1726, 1803), 'tkinter.ttk.LabelFrame', 'ttk.LabelFrame', (['self.tool'], {'text': '"""File Structure"""', 'padding': '(50)', 'relief': 'tk.RIDGE'}), "(self.tool, text='File Structure', padding=50, relief=tk.RIDGE)\n", (1740, 1803), False, 'from tkinter import ttk\n'), ((1897, 1960), 'tkinter.ttk.Label', 'ttk.Label', (['tool_frame'], {'text': 'self.main_text[0]', 'font': 'self.font_1'}), '(tool_frame, text=self.main_text[0], font=self.font_1)\n', (1906, 1960), False, 'from tkinter import ttk\n'), ((2048, 2111), 'tkinter.ttk.Label', 'ttk.Label', (['tool_frame'], {'text': 'self.main_text[1]', 'font': 'self.font_2'}), '(tool_frame, text=self.main_text[1], font=self.font_2)\n', (2057, 2111), False, 'from tkinter import ttk\n'), ((2199, 2262), 'tkinter.ttk.Label', 'ttk.Label', (['tool_frame'], {'text': 'self.main_text[2]', 'font': 'self.font_1'}), '(tool_frame, text=self.main_text[2], font=self.font_1)\n', (2208, 2262), False, 'from tkinter import ttk\n'), ((2350, 2413), 'tkinter.ttk.Label', 'ttk.Label', (['tool_frame'], {'text': 'self.main_text[3]', 'font': 'self.font_2'}), '(tool_frame, text=self.main_text[3], font=self.font_2)\n', (2359, 2413), False, 'from tkinter import ttk\n'), ((2518, 2586), 'tkinter.ttk.LabelFrame', 'ttk.LabelFrame', (['self.tool'], {'text': '"""Input"""', 'padding': '(20)', 'relief': 'tk.RIDGE'}), "(self.tool, text='Input', padding=20, relief=tk.RIDGE)\n", (2532, 2586), False, 'from tkinter import ttk\n'), ((2686, 2723), 'tkinter.Text', 'tk.Text', (['in_frame'], {'height': '(6)', 'width': '(50)'}), '(in_frame, height=6, width=50)\n', (2693, 2723), True, 'import tkinter as tk\n'), ((2876, 2941), 'tkinter.ttk.Button', 'ttk.Button', (['in_frame'], {'text': '"""Open File"""', 'command': 'self.tf_open_file'}), "(in_frame, text='Open File', command=self.tf_open_file)\n", (2886, 2941), False, 'from tkinter import ttk\n'), ((3194, 3255), 'tkinter.ttk.Label', 'ttk.Label', (['in_frame'], {'text': 'self.main_text[5]', 'font': 'self.font_1'}), '(in_frame, text=self.main_text[5], font=self.font_1)\n', (3203, 3255), False, 'from tkinter import ttk\n'), ((3352, 3388), 'tkinter.Text', 'tk.Text', (['in_frame'], {'height': '(1)', 'width': '(9)'}), '(in_frame, height=1, width=9)\n', (3359, 3388), True, 'import tkinter as tk\n'), ((3527, 3601), 'tkinter.ttk.Button', 'ttk.Button', (['in_frame'], {'text': '"""CALCULATE!"""', 'command': 'self.check_input_and_pass'}), "(in_frame, text='CALCULATE!', command=self.check_input_and_pass)\n", (3537, 3601), False, 'from tkinter import ttk\n'), ((3921, 4012), 'tkinter.ttk.LabelFrame', 'ttk.LabelFrame', (['self.results'], {'text': '"""Matrix Representation"""', 'padding': '(50)', 'relief': 'tk.RIDGE'}), "(self.results, text='Matrix Representation', padding=50,\n relief=tk.RIDGE)\n", (3935, 4012), False, 'from tkinter import ttk\n'), ((4306, 4340), 'numpy.ndenumerate', 'np.ndenumerate', (['self.matrix_result'], {}), '(self.matrix_result)\n', (4320, 4340), True, 'import numpy as np\n'), ((4910, 4989), 'tkinter.ttk.LabelFrame', 'ttk.LabelFrame', (['self.results'], {'text': '"""BLOSUM Degree"""', 'padding': '(50)', 'relief': 'tk.RIDGE'}), "(self.results, text='BLOSUM Degree', padding=50, relief=tk.RIDGE)\n", (4924, 4989), False, 'from tkinter import ttk\n'), ((5264, 5350), 'tkinter.ttk.LabelFrame', 'ttk.LabelFrame', (['self.results'], {'text': '"""Output Settings"""', 'padding': '(50)', 'relief': 'tk.RIDGE'}), "(self.results, text='Output Settings', padding=50, relief=tk.\n RIDGE)\n", (5278, 5350), False, 'from tkinter import ttk\n'), ((5458, 5550), 'tkinter.ttk.Button', 'ttk.Button', (['out_res_frame'], {'text': '"""Print to console"""', 'command': 'self.print_res_console_save'}), "(out_res_frame, text='Print to console', command=self.\n print_res_console_save)\n", (5468, 5550), False, 'from tkinter import ttk\n'), ((6322, 6392), 'tkinter.ttk.LabelFrame', 'ttk.LabelFrame', (['self.about'], {'text': '"""About this program"""', 'relief': 'tk.RIDGE'}), "(self.about, text='About this program', relief=tk.RIDGE)\n", (6336, 6392), False, 'from tkinter import ttk\n'), ((6661, 6708), 'src.utils.RichText', 'RichText', (['self.ab_frame'], {'width': '(73)', 'wrap': 'tk.WORD'}), '(self.ab_frame, width=73, wrap=tk.WORD)\n', (6669, 6708), False, 'from src.utils import RichText\n'), ((8577, 8622), 'numpy.vstack', 'np.vstack', (['(self.matrix_labels, label_matrix)'], {}), '((self.matrix_labels, label_matrix))\n', (8586, 8622), True, 'import numpy as np\n'), ((8646, 8679), 'numpy.hstack', 'np.hstack', (['(label2, label_matrix)'], {}), '((label2, label_matrix))\n', (8655, 8679), True, 'import numpy as np\n'), ((11467, 11481), 'tkinter.StringVar', 'tk.StringVar', ([], {}), '()\n', (11479, 11481), True, 'import tkinter as tk\n'), ((12350, 12439), 'tkinter.Label', 'tk.Label', (['label_loc'], {'textvariable': 'warn_msg', 'font': 'self.font_1', 'fg': '"""red"""', 'bg': '"""#ecffde"""'}), "(label_loc, textvariable=warn_msg, font=self.font_1, fg='red', bg=\n '#ecffde')\n", (12358, 12439), True, 'import tkinter as tk\n'), ((4671, 4744), 'tkinter.ttk.Entry', 'ttk.Entry', (['self.result_frame'], {'width': '(8)', 'font': 'self.font_2', 'justify': '"""center"""'}), "(self.result_frame, width=8, font=self.font_2, justify='center')\n", (4680, 4744), False, 'from tkinter import ttk\n'), ((10948, 10980), 'src.algorithm.blosum', 'blosum', (['dna_sequences', 'xx_number'], {}), '(dna_sequences, xx_number)\n', (10954, 10980), False, 'from src.algorithm import blosum\n'), ((762, 769), 'src.theme.theme', 'theme', ([], {}), '()\n', (767, 769), False, 'from src.theme import theme\n'), ((8498, 8524), 'numpy.asarray', 'np.asarray', (["(['-'] + label2)"], {}), "(['-'] + label2)\n", (8508, 8524), True, 'import numpy as np\n'), ((4143, 4218), 'tkinter.ttk.Label', 'ttk.Label', (['self.result_frame'], {'text': '"""No result available."""', 'font': 'self.font_2'}), "(self.result_frame, text='No result available.', font=self.font_2)\n", (4152, 4218), False, 'from tkinter import ttk\n'), ((9299, 9310), 'pathlib.Path.home', 'Path.home', ([], {}), '()\n', (9308, 9310), False, 'from pathlib import Path\n'), ((8953, 8964), 'pathlib.Path.home', 'Path.home', ([], {}), '()\n', (8962, 8964), False, 'from pathlib import Path\n'), ((8086, 8110), 're.match', 're.match', (['"""^[1-9]"""', 'line'], {}), "('^[1-9]', line)\n", (8094, 8110), False, 'import re\n'), ((7538, 7568), 'base64.encodestring', 'base64.encodestring', (['image_byt'], {}), '(image_byt)\n', (7557, 7568), False, 'import base64\n'), ((7601, 7630), 'tkinter.PhotoImage', 'tk.PhotoImage', ([], {'data': 'image_b64'}), '(data=image_b64)\n', (7614, 7630), True, 'import tkinter as tk\n'), ((7476, 7494), 'urllib.request.urlopen', 'urlopen', (['image_url'], {}), '(image_url)\n', (7483, 7494), False, 'from urllib.request import urlopen\n')]
|
import numpy as np
import re
def apply_colormaps_based_on_mask(mask, data_for_inside_mask, data_for_outside_mask,
colormap_inside_mask, colormap_outside_mask):
"""
Returns the combination of applying two colormaps to two datasets on two mutually exclusive sets of pixels
as follows. Applies <colormap_inside_mask> to <data_for_inside_mask> for pixels where <thresh_mask> is True and applies
<colormap_outside_mask> to <data_for_outside_mask> for pixels where <thresh_mask> is False.
:param mask: boolean numpy.ndarray
:param data_for_inside_mask: float numpy.ndarray, having the same shape as thresh_mask
:param data_for_outside_mask: float numpy.ndarray, having the same shape as thresh_mask
:param colormap_inside_mask: matplotlib colormap
:param colormap_outside_mask: matplotlib colormap
:return: numpy.ndarray, having the same shape as thresh_mask
"""
assert data_for_inside_mask.shape == data_for_outside_mask.shape, f"data_within_mask and data_outside_mask " \
f"must have " \
f"the same shape. Given: {data_for_inside_mask.shape} " \
f"and {data_for_outside_mask.shape}"
assert mask.shape == data_for_inside_mask.shape, f"The shape of given thresh_mask ({mask.shape}) " \
f"does not match shape of data given " \
f"({data_for_inside_mask.shape})"
data_colorized = np.empty(list(data_for_inside_mask.shape) + [4])
data_colorized[mask, :] = colormap_inside_mask(data_for_inside_mask[mask])
data_colorized[~mask, :] = colormap_outside_mask(data_for_outside_mask[~mask])
return data_colorized
#
# data_masked_inside = np.ma.MaskedArray(data_for_outside_mask, mask, fill_value=0)
# data_masked_outside = np.ma.MaskedArray(data_for_inside_mask, ~mask, fill_value=0)
#
# data_colorized_outside = colormap_outside_mask(data_masked_inside)
# data_colorized_inside = colormap_inside_mask(data_masked_outside)
#
# return data_colorized_inside + data_colorized_outside
def stack_duplicate_frames(frame, depth):
"""
Retuns a numpy.ndarray formed by stacking <frame> along the third axis
:param frame: numpy.ndarray, of 2 dimensions
:param depth: int
:return: numpy.ndarray of shape (frame.shape[0], frame.shape[1], depth)
"""
return np.stack([frame] * depth, axis=2)
def resolve_thresholdOnValue(data, mv_thresholdOnValue):
"""
Interprets <mv_thresholdOnValue> in the context of <data>, calculates the threshold and returns it
:param data: numpy.ndarray
:param mv_thresholdOnValue: str
:return: float
"""
assert re.fullmatch(r"[ra][\-\.0-9]+", mv_thresholdOnValue) is not None, f"{mv_thresholdOnValue} is not a valid" \
f"threshold indicator. Valid formats are " \
f"'rxxx' for relative threshold and 'ayyy' " \
f" for absolute threshold where 'xxx' and" \
f"'yyy' represent numbers. " \
f"E.g.: a123.123, r0.4 and r-0.12533"
threshold_value = float(mv_thresholdOnValue[1:])
if mv_thresholdOnValue.startswith("r"):
thres_pc = np.clip(threshold_value, 0, 100)
data_min, data_max = data.min(), data.max()
threshold = data_min + 0.01 * thres_pc * (data_max - data_min)
elif mv_thresholdOnValue.startswith("a"):
threshold = threshold_value
else:
# Should not come here
raise ValueError()
return threshold
|
[
"re.fullmatch",
"numpy.stack",
"numpy.clip"
] |
[((2605, 2638), 'numpy.stack', 'np.stack', (['([frame] * depth)'], {'axis': '(2)'}), '([frame] * depth, axis=2)\n', (2613, 2638), True, 'import numpy as np\n'), ((2915, 2968), 're.fullmatch', 're.fullmatch', (['"""[ra][\\\\-\\\\.0-9]+"""', 'mv_thresholdOnValue'], {}), "('[ra][\\\\-\\\\.0-9]+', mv_thresholdOnValue)\n", (2927, 2968), False, 'import re\n'), ((3717, 3749), 'numpy.clip', 'np.clip', (['threshold_value', '(0)', '(100)'], {}), '(threshold_value, 0, 100)\n', (3724, 3749), True, 'import numpy as np\n')]
|
# -*- coding: utf8
from gb.randomkit.random import RNG
from gb.samplers import BaseSampler
from gb.samplers import CollapsedGibbsSampler
from gb.stamps import Timestamps
from gb.sloppy import SloppyCounter
from numpy.testing import assert_equal
import numpy as np
def test_get_probability():
d = {}
d[0] = [1, 2, 3, 4, 5, 6, 7]
d[1] = [11, 12, 13]
stamps = Timestamps(d)
causes = stamps._get_causes(0)
causes[0] = 0
causes[1] = 0
causes[2] = 0
causes[3] = 1
causes[4] = 1
causes[5] = 1
causes[6] = 1
causes = stamps._get_causes(1)
causes[0] = 0
causes[1] = 0
causes[2] = 1
nb = np.array([5, 5], dtype='uint64')
init_state = np.array([[5, 5]], dtype='uint64')
id_ = 0
sloppy = SloppyCounter(1, 9999, nb, init_state)
sampler = CollapsedGibbsSampler(BaseSampler(stamps, sloppy, id_, 0.1,
RNG()), 2)
sampler._set_current_process(0)
assert_equal(0.5961538461538461, sampler._get_probability(0))
assert_equal(0.7884615384615383, sampler._get_probability(1))
sampler._set_current_process(1)
assert_equal(0.40384615384615385, sampler._get_probability(0))
assert_equal(0.21153846153846154, sampler._get_probability(1))
def test_inc_dec():
d = {}
d[0] = [1, 2, 3, 4, 5, 6, 7]
d[1] = [11, 12, 13]
stamps = Timestamps(d)
causes = stamps._get_causes(0)
causes[0] = 0
causes[1] = 0
causes[2] = 0
causes[3] = 1
causes[4] = 1
causes[5] = 1
causes[6] = 1
causes = stamps._get_causes(1)
causes[0] = 0
causes[1] = 0
causes[2] = 1
nb = np.array([5, 5], dtype='uint64')
init_state = np.array([[5, 5]], dtype='uint64')
id_ = 0
sloppy = SloppyCounter(1, 9999, nb, init_state)
sampler = CollapsedGibbsSampler(BaseSampler(stamps, sloppy, id_, 0.1,
RNG()), 2)
sampler._set_current_process(0)
assert_equal(0.5961538461538461, sampler._get_probability(0))
assert_equal(0.7884615384615383, sampler._get_probability(1))
sampler._inc_one(0)
assert_equal(0.6612903225806451, sampler._get_probability(0))
assert_equal(0.7884615384615383, sampler._get_probability(1))
sampler._dec_one(0)
assert_equal(0.5961538461538461, sampler._get_probability(0))
|
[
"numpy.array",
"gb.sloppy.SloppyCounter",
"gb.randomkit.random.RNG",
"gb.stamps.Timestamps"
] |
[((379, 392), 'gb.stamps.Timestamps', 'Timestamps', (['d'], {}), '(d)\n', (389, 392), False, 'from gb.stamps import Timestamps\n'), ((654, 686), 'numpy.array', 'np.array', (['[5, 5]'], {'dtype': '"""uint64"""'}), "([5, 5], dtype='uint64')\n", (662, 686), True, 'import numpy as np\n'), ((704, 738), 'numpy.array', 'np.array', (['[[5, 5]]'], {'dtype': '"""uint64"""'}), "([[5, 5]], dtype='uint64')\n", (712, 738), True, 'import numpy as np\n'), ((764, 802), 'gb.sloppy.SloppyCounter', 'SloppyCounter', (['(1)', '(9999)', 'nb', 'init_state'], {}), '(1, 9999, nb, init_state)\n', (777, 802), False, 'from gb.sloppy import SloppyCounter\n'), ((1378, 1391), 'gb.stamps.Timestamps', 'Timestamps', (['d'], {}), '(d)\n', (1388, 1391), False, 'from gb.stamps import Timestamps\n'), ((1653, 1685), 'numpy.array', 'np.array', (['[5, 5]'], {'dtype': '"""uint64"""'}), "([5, 5], dtype='uint64')\n", (1661, 1685), True, 'import numpy as np\n'), ((1703, 1737), 'numpy.array', 'np.array', (['[[5, 5]]'], {'dtype': '"""uint64"""'}), "([[5, 5]], dtype='uint64')\n", (1711, 1737), True, 'import numpy as np\n'), ((1763, 1801), 'gb.sloppy.SloppyCounter', 'SloppyCounter', (['(1)', '(9999)', 'nb', 'init_state'], {}), '(1, 9999, nb, init_state)\n', (1776, 1801), False, 'from gb.sloppy import SloppyCounter\n'), ((925, 930), 'gb.randomkit.random.RNG', 'RNG', ([], {}), '()\n', (928, 930), False, 'from gb.randomkit.random import RNG\n'), ((1924, 1929), 'gb.randomkit.random.RNG', 'RNG', ([], {}), '()\n', (1927, 1929), False, 'from gb.randomkit.random import RNG\n')]
|
# pylint: disable=invalid-name
'''
Pytests for the common utilities included in this package. Includes:
- conversions.py
- specs.py
- utils.py
To run the tests, type the following in the top level repo directory:
python -m pytest --nat-file [path/to/gribfile] --prs-file [path/to/gribfile]
'''
from inspect import getfullargspec
from string import ascii_letters, digits
import warnings
from matplotlib import cm
from matplotlib import colors as mcolors
from metpy.plots import ctables
import numpy as np
import adb_graphics.conversions as conversions
import adb_graphics.specs as specs
import adb_graphics.utils as utils
import adb_graphics.datahandler.gribdata as gribdata
def test_conversion():
''' Test that conversions return at numpy array for input of np.ndarray,
list, or int '''
a = np.ones([3, 2]) * 300
c = a[0, 0]
# Check for the right answer
assert np.array_equal(conversions.k_to_c(a), a - 273.15)
assert np.array_equal(conversions.k_to_f(a), (a - 273.15) * 9/5 + 32)
assert np.array_equal(conversions.kgm2_to_in(a), a * 0.03937)
assert np.array_equal(conversions.m_to_dm(a), a / 10)
assert np.array_equal(conversions.m_to_in(a), a * 39.3701)
assert np.array_equal(conversions.m_to_kft(a), a / 304.8)
assert np.array_equal(conversions.m_to_mi(a), a / 1609.344)
assert np.array_equal(conversions.ms_to_kt(a), a * 1.9438)
assert np.array_equal(conversions.pa_to_hpa(a), a / 100)
assert np.array_equal(conversions.percent(a), a * 100)
assert np.array_equal(conversions.to_micro(a), a * 1E6)
assert np.array_equal(conversions.vvel_scale(a), a * -10)
assert np.array_equal(conversions.vort_scale(a), a / 1E-05)
assert np.array_equal(conversions.weasd_to_1hsnw(a), a * 10)
functions = [
conversions.k_to_c,
conversions.k_to_f,
conversions.kgm2_to_in,
conversions.m_to_dm,
conversions.m_to_in,
conversions.m_to_kft,
conversions.m_to_mi,
conversions.ms_to_kt,
conversions.pa_to_hpa,
conversions.percent,
conversions.to_micro,
conversions.vvel_scale,
conversions.vort_scale,
conversions.weasd_to_1hsnw,
]
# Check that all functions return a np.ndarray given a collection, or single float
for f in functions:
for collection in [a, c]:
assert isinstance(f(collection), type(collection))
class MockSpecs(specs.VarSpec):
''' Mock class for the VarSpec abstract class '''
@property
def clevs(self):
return np.asarray(range(15))
@property
def vspec(self):
return {}
def test_specs():
''' Test VarSpec properties. '''
config = 'adb_graphics/default_specs.yml'
varspec = MockSpecs(config)
# Ensure correct return type
assert isinstance(varspec.t_colors, np.ndarray)
assert isinstance(varspec.ps_colors, np.ndarray)
assert isinstance(varspec.yml, dict)
# Ensure the appropriate number of colors is returned
assert np.shape(varspec.t_colors) == (len(varspec.clevs), 4)
assert np.shape(varspec.ps_colors) == (105, 4)
def test_utils():
''' Test that utils works appropriately. '''
assert callable(utils.get_func('conversions.k_to_c'))
class TestDefaultSpecs():
''' Test contents of default_specs.yml. '''
config = 'adb_graphics/default_specs.yml'
varspec = MockSpecs(config)
cfg = varspec.yml
@property
def allowable(self):
''' Each entry in the dict names a function that tests a key in
default_specs.yml. '''
return {
'accumulate': self.is_bool,
'annotate': self.is_bool,
'annotate_decimal': self.is_int,
'clevs': self.is_a_clev,
'cmap': self.is_a_cmap,
'colors': self.is_a_color,
'contours': self.is_a_contour_dict,
'hatches': self.is_a_contourf_dict,
'labels': self.is_a_contourf_dict,
'ncl_name': True,
'print_units': True,
'split': self.is_bool,
'ticks': self.is_number,
'title': self.is_string,
'transform': self.check_transform,
'unit': self.is_string,
'vertical_index': self.is_int,
'vertical_level_name': self.is_string,
'wind': self.is_wind,
}
def check_kwargs(self, accepted_args, kwargs):
''' Ensure a dictionary entry matches the kwargs accepted by a function.
'''
assert isinstance(kwargs, dict)
for key, args in kwargs.items():
lev = None
if '_' in key:
short_name, lev = key.split('_')
else:
short_name = key
assert self.is_a_key(short_name)
if lev:
assert self.cfg.get(short_name).get(lev) is not None
for arg in args.keys():
assert arg in accepted_args
return True
def check_transform(self, entry):
'''
Check that the transform entry is either a single transformation
function, a list of transformation functions, or a dictionary containing
the functions list and the kwargs list like so:
transform:
funcs: [list, of, functions]
kwargs:
first_arg: value
sec_arg: value
The functions listed under functions MUST be methods, not attributes!
'''
kwargs = dict()
# Check that each item listed is callable
if isinstance(entry, (list, str)):
assert self.is_callable(entry)
# If the transform entry is a dictionary, check that it has the
# appropriate contents
elif isinstance(entry, dict):
funcs = entry.get('funcs')
assert funcs is not None
# Make sure funcs is a list
funcs = funcs if isinstance(funcs, list) else [funcs]
# Key word arguments may not be present.
kwargs = entry.get('kwargs')
transforms = []
for func in funcs:
callables = self.get_callable(func)
callables = callables if isinstance(callables, list) else \
[callables]
transforms.extend(callables)
# The argspecs bit gives us a list of all the accepted arguments
# for the functions listed in the variable all_params. Test fails
# when provided arguments don't appear in all_params.
# arguments not in that list, we fail.
if kwargs:
argspecs = [getfullargspec(func) for func in transforms if
callable(func)]
all_params = []
for argspec in argspecs:
# Make sure all functions accept key word arguments
assert argspec.varkw is not None
parameters = []
for argtype in [argspec.args, argspec.varargs, argspec.varkw]:
if argtype is not None:
parameters.extend(argtype)
all_params.extend(parameters)
for key in kwargs.keys():
if key not in all_params:
msg = f'Function key {key} is not an expicit parameter \
in any of the transforms: {funcs}!'
warnings.warn(msg, UserWarning)
return True
# pylint: disable=inconsistent-return-statements
def get_callable(self, func):
''' Return the callable function given a function name. '''
if func in dir(self.varspec):
return self.varspec.__getattribute__(func)
# Check datahandler.gribdata objects if a single word is provided
if len(func.split('.')) == 1:
funcs = []
for attr in dir(gribdata):
# pylint: disable=no-member
if func in dir(gribdata.__getattribute__(attr)):
funcs.append(gribdata.__getattribute__(attr).__dict__.get(func))
return funcs
if callable(utils.get_func(func)):
return utils.get_func(func)
raise ValueError('{func} is not a known callable function!')
@staticmethod
def is_a_clev(clev):
''' Returns true for a clev that is a list, a range, or a callable function. '''
if isinstance(clev, (list, np.ndarray)):
return True
if 'range' in clev.split('[')[0]:
clean = lambda x: x.strip().split('-')[-1].replace('.', '1')
items = clev.split(' ', 1)[1].strip('[').strip(']').split(',')
nums = [clean(i).isnumeric() for i in items]
return all(nums)
return callable(utils.get_func(clev))
@staticmethod
def is_a_cmap(cmap):
''' Returns true for a cmap that is a Colormap object. '''
return cmap in dir(cm) + list(ctables.colortables.keys())
def is_a_contour_dict(self, entry):
''' Set up the accepted arguments for plt.contour, and check the given
arguments. '''
args = ['X', 'Y', 'Z', 'levels',
'corner_mask', 'colors', 'alpha', 'cmap', 'norm', 'vmin',
'vmax', 'origin', 'extent', 'locator', 'extend', 'xunits',
'yunits', 'antialiased', 'nchunk', 'linewidths', 'linestyles']
if entry is None:
return True
return self.check_kwargs(args, entry)
def is_a_contourf_dict(self, entry):
''' Set up the accepted arguments for plt.contourf, and check the given
arguments. '''
args = ['X', 'Y', 'Z', 'levels',
'corner_mask', 'colors', 'alpha', 'cmap', 'labels', 'norm', 'vmin',
'vmax', 'origin', 'extent', 'locator', 'extend', 'xunits',
'yunits', 'antialiased', 'nchunk', 'linewidths',
'hatches']
if entry is None:
return True
return self.check_kwargs(args, entry)
def is_a_color(self, color):
''' Returns true if color is contained in the list of recognized colors. '''
colors = dict(mcolors.BASE_COLORS, **mcolors.CSS4_COLORS,
**ctables.colortables)
if color in colors.keys():
return True
if color in dir(self.varspec):
return True
return False
@staticmethod
def is_a_level(key):
'''
Returns true if the key fits one of the level descriptor formats.
Allowable formats include:
[str_descriptor] e.g. sfc, max, mup
[numeric][lev_type] e.g. 500mb, or 2m
[stat][numeric] e.g. mn02, mx25
'''
allowed_levels = [
'agl', # above ground level
'best', # Best
'bndylay', # boundary layer cld cover
'esbl', # ???
'esblmn', # ???
'high', # high clouds
'int', # vertical integral
'low', # low clouds
'max', # maximum in column
'maxsfc', # max surface value
'mdn', # maximum downward
'mid', # mid-level clouds
'mnsfc', # min surface value
'msl', # mean sea level
'mu', # most unstable
'mul', # most unstable layer
'mup', # maximum upward
'mu', # most unstable
'pw', # wrt precipitable water
'sat', # satellite
'sfc', # surface
'sfclt', # surface (less than)
'top', # nominal top of atmosphere
'total', # total clouds
'ua', # upper air
]
allowed_lev_type = [
'cm', # centimeters
'ds', # difference
'ft', # feet
'km', # kilometers
'm', # meters
'mm', # millimeters
'mb', # milibars
'sr', # storm relative
]
allowed_stat = [
'in', # ???
'ens', # ensemble
'm', # ???
'maxm', # ???
'mn', # minimum
'mx', # maximum
]
# Easy check first -- it is in the allowed_levels list
if key in allowed_levels:
return True
# Check for [numeric][lev_type] or [lev_type][numeric] pattern
# Numbers come at beginning or end, only
numeric = ''.join([c for c in key if c in digits + '.']) in key
# The level is allowed
level_str = [c for c in key if c in ascii_letters]
allowed = ''.join(level_str) in allowed_lev_type + allowed_stat
# Check the other direction - level string contains one of the allowed
# types.
if not allowed:
for lev in allowed_lev_type + allowed_stat:
if lev in level_str:
allowed = True
break
if numeric and allowed:
return True
return False
def is_a_key(self, key):
''' Returns true if key exists as a key in the config file. '''
return self.cfg.get(key) is not None
@staticmethod
def is_bool(k):
''' Returns true if k is a boolean variable. '''
return isinstance(k, bool)
def is_callable(self, funcs):
''' Returns true if func in funcs list is the name of a callable function. '''
funcs = funcs if isinstance(funcs, list) else [funcs]
callables = []
for func in funcs:
callable_ = self.get_callable(func)
callable_ = callable_ if isinstance(callable_, list) else [callable_]
for clbl in callable_:
if isinstance(clbl, np.ndarray):
callables.append(True)
elif callable(clbl):
callables.append(True)
else:
callables.append(False)
return all(callables)
@staticmethod
def is_dict(d):
''' Returns true if d is a dictionary '''
return isinstance(d, dict)
@staticmethod
def is_int(i):
''' Returns true if i is an integer. '''
if isinstance(i, int):
return True
return i.isnumeric() and len(i.split('.')) == 1
@staticmethod
def is_number(i):
''' Returns true if i is a number. '''
if isinstance(i, (int, float)):
return True
return i.isnumeric() and len(i.split('.')) <= 2
@staticmethod
def is_string(s):
''' Returns true if s is a string. '''
return isinstance(s, str)
def is_wind(self, wind):
''' Returns true if wind is a bool or is_a_level. '''
return isinstance(wind, bool) or self.is_a_level(wind)
def check_keys(self, d, depth=0):
''' Helper function that recursively checks the keys in the dictionary by calling the
function defined in allowable. '''
max_depth = 2
# Only proceed if d is a dictionary
if not isinstance(d, dict):
return
# Proceed only up to max depth.
if depth >= max_depth:
return
level = depth+1
for k, v in d.items():
# Check that the key is allowable
assert (k in self.allowable.keys()) or self.is_a_level(k)
# Call a checker if one exists for the key, otherwise descend into
# next level of dict
checker = self.allowable.get(k)
if checker:
if isinstance(checker, bool):
assert checker
else:
assert checker(v)
else:
if isinstance(v, dict):
self.check_keys(v, depth=level)
def test_keys(self):
''' Tests each of top-level variables in the config file by calling the helper function. '''
for short_name, spec in self.cfg.items():
assert '_' not in short_name
self.check_keys(spec)
|
[
"adb_graphics.conversions.m_to_mi",
"adb_graphics.conversions.pa_to_hpa",
"inspect.getfullargspec",
"adb_graphics.conversions.m_to_kft",
"adb_graphics.datahandler.gribdata.__getattribute__",
"adb_graphics.conversions.weasd_to_1hsnw",
"adb_graphics.conversions.k_to_f",
"adb_graphics.conversions.ms_to_kt",
"adb_graphics.conversions.to_micro",
"adb_graphics.conversions.vort_scale",
"warnings.warn",
"adb_graphics.conversions.m_to_in",
"numpy.ones",
"adb_graphics.conversions.k_to_c",
"numpy.shape",
"adb_graphics.conversions.percent",
"adb_graphics.conversions.m_to_dm",
"adb_graphics.utils.get_func",
"adb_graphics.conversions.vvel_scale",
"adb_graphics.conversions.kgm2_to_in",
"metpy.plots.ctables.colortables.keys"
] |
[((830, 845), 'numpy.ones', 'np.ones', (['[3, 2]'], {}), '([3, 2])\n', (837, 845), True, 'import numpy as np\n'), ((928, 949), 'adb_graphics.conversions.k_to_c', 'conversions.k_to_c', (['a'], {}), '(a)\n', (946, 949), True, 'import adb_graphics.conversions as conversions\n'), ((989, 1010), 'adb_graphics.conversions.k_to_f', 'conversions.k_to_f', (['a'], {}), '(a)\n', (1007, 1010), True, 'import adb_graphics.conversions as conversions\n'), ((1063, 1088), 'adb_graphics.conversions.kgm2_to_in', 'conversions.kgm2_to_in', (['a'], {}), '(a)\n', (1085, 1088), True, 'import adb_graphics.conversions as conversions\n'), ((1129, 1151), 'adb_graphics.conversions.m_to_dm', 'conversions.m_to_dm', (['a'], {}), '(a)\n', (1148, 1151), True, 'import adb_graphics.conversions as conversions\n'), ((1187, 1209), 'adb_graphics.conversions.m_to_in', 'conversions.m_to_in', (['a'], {}), '(a)\n', (1206, 1209), True, 'import adb_graphics.conversions as conversions\n'), ((1250, 1273), 'adb_graphics.conversions.m_to_kft', 'conversions.m_to_kft', (['a'], {}), '(a)\n', (1270, 1273), True, 'import adb_graphics.conversions as conversions\n'), ((1312, 1334), 'adb_graphics.conversions.m_to_mi', 'conversions.m_to_mi', (['a'], {}), '(a)\n', (1331, 1334), True, 'import adb_graphics.conversions as conversions\n'), ((1376, 1399), 'adb_graphics.conversions.ms_to_kt', 'conversions.ms_to_kt', (['a'], {}), '(a)\n', (1396, 1399), True, 'import adb_graphics.conversions as conversions\n'), ((1439, 1463), 'adb_graphics.conversions.pa_to_hpa', 'conversions.pa_to_hpa', (['a'], {}), '(a)\n', (1460, 1463), True, 'import adb_graphics.conversions as conversions\n'), ((1500, 1522), 'adb_graphics.conversions.percent', 'conversions.percent', (['a'], {}), '(a)\n', (1519, 1522), True, 'import adb_graphics.conversions as conversions\n'), ((1559, 1582), 'adb_graphics.conversions.to_micro', 'conversions.to_micro', (['a'], {}), '(a)\n', (1579, 1582), True, 'import adb_graphics.conversions as conversions\n'), ((1619, 1644), 'adb_graphics.conversions.vvel_scale', 'conversions.vvel_scale', (['a'], {}), '(a)\n', (1641, 1644), True, 'import adb_graphics.conversions as conversions\n'), ((1681, 1706), 'adb_graphics.conversions.vort_scale', 'conversions.vort_scale', (['a'], {}), '(a)\n', (1703, 1706), True, 'import adb_graphics.conversions as conversions\n'), ((1745, 1774), 'adb_graphics.conversions.weasd_to_1hsnw', 'conversions.weasd_to_1hsnw', (['a'], {}), '(a)\n', (1771, 1774), True, 'import adb_graphics.conversions as conversions\n'), ((3050, 3076), 'numpy.shape', 'np.shape', (['varspec.t_colors'], {}), '(varspec.t_colors)\n', (3058, 3076), True, 'import numpy as np\n'), ((3115, 3142), 'numpy.shape', 'np.shape', (['varspec.ps_colors'], {}), '(varspec.ps_colors)\n', (3123, 3142), True, 'import numpy as np\n'), ((3246, 3282), 'adb_graphics.utils.get_func', 'utils.get_func', (['"""conversions.k_to_c"""'], {}), "('conversions.k_to_c')\n", (3260, 3282), True, 'import adb_graphics.utils as utils\n'), ((8254, 8274), 'adb_graphics.utils.get_func', 'utils.get_func', (['func'], {}), '(func)\n', (8268, 8274), True, 'import adb_graphics.utils as utils\n'), ((8296, 8316), 'adb_graphics.utils.get_func', 'utils.get_func', (['func'], {}), '(func)\n', (8310, 8316), True, 'import adb_graphics.utils as utils\n'), ((8897, 8917), 'adb_graphics.utils.get_func', 'utils.get_func', (['clev'], {}), '(clev)\n', (8911, 8917), True, 'import adb_graphics.utils as utils\n'), ((9069, 9095), 'metpy.plots.ctables.colortables.keys', 'ctables.colortables.keys', ([], {}), '()\n', (9093, 9095), False, 'from metpy.plots import ctables\n'), ((6705, 6725), 'inspect.getfullargspec', 'getfullargspec', (['func'], {}), '(func)\n', (6719, 6725), False, 'from inspect import getfullargspec\n'), ((8089, 8120), 'adb_graphics.datahandler.gribdata.__getattribute__', 'gribdata.__getattribute__', (['attr'], {}), '(attr)\n', (8114, 8120), True, 'import adb_graphics.datahandler.gribdata as gribdata\n'), ((7531, 7562), 'warnings.warn', 'warnings.warn', (['msg', 'UserWarning'], {}), '(msg, UserWarning)\n', (7544, 7562), False, 'import warnings\n'), ((8156, 8187), 'adb_graphics.datahandler.gribdata.__getattribute__', 'gribdata.__getattribute__', (['attr'], {}), '(attr)\n', (8181, 8187), True, 'import adb_graphics.datahandler.gribdata as gribdata\n')]
|
import os
import shutil
import tempfile
import numpy as np
from yt.loaders import load, load_uniform_grid
from yt.testing import (
assert_array_equal,
assert_fname,
fake_random_ds,
requires_file,
requires_module,
)
from yt.utilities.answer_testing.framework import data_dir_load
from yt.visualization.plot_window import ProjectionPlot, SlicePlot
ytdata_dir = "ytdata_test"
@requires_module("h5py")
@requires_file(os.path.join(ytdata_dir, "slice.h5"))
@requires_file(os.path.join(ytdata_dir, "proj.h5"))
@requires_file(os.path.join(ytdata_dir, "oas.h5"))
def test_old_plot_data():
tmpdir = tempfile.mkdtemp()
curdir = os.getcwd()
os.chdir(tmpdir)
fn = "slice.h5"
full_fn = os.path.join(ytdata_dir, fn)
ds_slice = data_dir_load(full_fn)
p = SlicePlot(ds_slice, "z", "density")
fn = p.save()
assert_fname(fn[0])
fn = "proj.h5"
full_fn = os.path.join(ytdata_dir, fn)
ds_proj = data_dir_load(full_fn)
p = ProjectionPlot(ds_proj, "z", "density")
fn = p.save()
assert_fname(fn[0])
fn = "oas.h5"
full_fn = os.path.join(ytdata_dir, fn)
ds_oas = data_dir_load(full_fn)
p = SlicePlot(ds_oas, [1, 1, 1], "density")
fn = p.save()
assert_fname(fn[0])
os.chdir(curdir)
shutil.rmtree(tmpdir)
@requires_module("h5py")
def test_plot_data():
tmpdir = tempfile.mkdtemp()
curdir = os.getcwd()
os.chdir(tmpdir)
ds = fake_random_ds(16)
plot = SlicePlot(ds, "z", "density")
fn = plot.data_source.save_as_dataset("slice.h5")
ds_slice = load(fn)
p = SlicePlot(ds_slice, "z", "density")
fn = p.save()
assert_fname(fn[0])
plot = ProjectionPlot(ds, "z", "density")
fn = plot.data_source.save_as_dataset("proj.h5")
ds_proj = load(fn)
p = ProjectionPlot(ds_proj, "z", "density")
fn = p.save()
assert_fname(fn[0])
plot = SlicePlot(ds, [1, 1, 1], "density")
fn = plot.data_source.save_as_dataset("oas.h5")
ds_oas = load(fn)
p = SlicePlot(ds_oas, [1, 1, 1], "density")
fn = p.save()
assert_fname(fn[0])
os.chdir(curdir)
if tmpdir != ".":
shutil.rmtree(tmpdir)
@requires_module("h5py")
def test_non_square_frb():
tmpdir = tempfile.mkdtemp()
curdir = os.getcwd()
os.chdir(tmpdir)
# construct an arbitrary dataset
arr = np.arange(8.0 * 9.0 * 10.0).reshape((8, 9, 10))
data = dict(density=(arr, "g/cm**3"))
bbox = np.array([[-4, 4.0], [-4.5, 4.5], [-5.0, 5]])
ds = load_uniform_grid(
data, arr.shape, length_unit="Mpc", bbox=bbox, periodicity=(False, False, False)
)
# make a slice
slc = ds.slice(axis="z", coord=ds.quan(0.0, "code_length"))
# make a frb and save it to disk
center = (ds.quan(0.0, "code_length"), ds.quan(0.0, "code_length"))
xax, yax = ds.coordinates.x_axis[slc.axis], ds.coordinates.y_axis[slc.axis]
res = [ds.domain_dimensions[xax], ds.domain_dimensions[yax]] # = [8,9]
width = ds.domain_right_edge[xax] - ds.domain_left_edge[xax] # = 8 code_length
height = ds.domain_right_edge[yax] - ds.domain_left_edge[yax] # = 9 code_length
frb = slc.to_frb(width=width, height=height, resolution=res, center=center)
fname = "test_frb_roundtrip.h5"
frb.save_as_dataset(fname, fields=["density"])
expected_vals = arr[:, :, 5].T
print(
"\nConfirmation that initial frb results are expected:",
(expected_vals == frb["density"].v).all(),
"\n",
)
# yt-reload:
reloaded_ds = load(fname)
assert_array_equal(frb["density"].shape, reloaded_ds.data["density"].shape)
assert_array_equal(frb["density"], reloaded_ds.data["density"])
os.chdir(curdir)
if tmpdir != ".":
shutil.rmtree(tmpdir)
|
[
"yt.loaders.load_uniform_grid",
"yt.visualization.plot_window.SlicePlot",
"yt.testing.assert_fname",
"yt.testing.assert_array_equal",
"numpy.arange",
"yt.testing.fake_random_ds",
"os.path.join",
"yt.loaders.load",
"os.getcwd",
"os.chdir",
"yt.utilities.answer_testing.framework.data_dir_load",
"numpy.array",
"tempfile.mkdtemp",
"shutil.rmtree",
"yt.testing.requires_module",
"yt.visualization.plot_window.ProjectionPlot"
] |
[((399, 422), 'yt.testing.requires_module', 'requires_module', (['"""h5py"""'], {}), "('h5py')\n", (414, 422), False, 'from yt.testing import assert_array_equal, assert_fname, fake_random_ds, requires_file, requires_module\n'), ((1300, 1323), 'yt.testing.requires_module', 'requires_module', (['"""h5py"""'], {}), "('h5py')\n", (1315, 1323), False, 'from yt.testing import assert_array_equal, assert_fname, fake_random_ds, requires_file, requires_module\n'), ((2160, 2183), 'yt.testing.requires_module', 'requires_module', (['"""h5py"""'], {}), "('h5py')\n", (2175, 2183), False, 'from yt.testing import assert_array_equal, assert_fname, fake_random_ds, requires_file, requires_module\n'), ((618, 636), 'tempfile.mkdtemp', 'tempfile.mkdtemp', ([], {}), '()\n', (634, 636), False, 'import tempfile\n'), ((650, 661), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (659, 661), False, 'import os\n'), ((666, 682), 'os.chdir', 'os.chdir', (['tmpdir'], {}), '(tmpdir)\n', (674, 682), False, 'import os\n'), ((718, 746), 'os.path.join', 'os.path.join', (['ytdata_dir', 'fn'], {}), '(ytdata_dir, fn)\n', (730, 746), False, 'import os\n'), ((762, 784), 'yt.utilities.answer_testing.framework.data_dir_load', 'data_dir_load', (['full_fn'], {}), '(full_fn)\n', (775, 784), False, 'from yt.utilities.answer_testing.framework import data_dir_load\n'), ((793, 828), 'yt.visualization.plot_window.SlicePlot', 'SlicePlot', (['ds_slice', '"""z"""', '"""density"""'], {}), "(ds_slice, 'z', 'density')\n", (802, 828), False, 'from yt.visualization.plot_window import ProjectionPlot, SlicePlot\n'), ((851, 870), 'yt.testing.assert_fname', 'assert_fname', (['fn[0]'], {}), '(fn[0])\n', (863, 870), False, 'from yt.testing import assert_array_equal, assert_fname, fake_random_ds, requires_file, requires_module\n'), ((905, 933), 'os.path.join', 'os.path.join', (['ytdata_dir', 'fn'], {}), '(ytdata_dir, fn)\n', (917, 933), False, 'import os\n'), ((948, 970), 'yt.utilities.answer_testing.framework.data_dir_load', 'data_dir_load', (['full_fn'], {}), '(full_fn)\n', (961, 970), False, 'from yt.utilities.answer_testing.framework import data_dir_load\n'), ((979, 1018), 'yt.visualization.plot_window.ProjectionPlot', 'ProjectionPlot', (['ds_proj', '"""z"""', '"""density"""'], {}), "(ds_proj, 'z', 'density')\n", (993, 1018), False, 'from yt.visualization.plot_window import ProjectionPlot, SlicePlot\n'), ((1041, 1060), 'yt.testing.assert_fname', 'assert_fname', (['fn[0]'], {}), '(fn[0])\n', (1053, 1060), False, 'from yt.testing import assert_array_equal, assert_fname, fake_random_ds, requires_file, requires_module\n'), ((1094, 1122), 'os.path.join', 'os.path.join', (['ytdata_dir', 'fn'], {}), '(ytdata_dir, fn)\n', (1106, 1122), False, 'import os\n'), ((1136, 1158), 'yt.utilities.answer_testing.framework.data_dir_load', 'data_dir_load', (['full_fn'], {}), '(full_fn)\n', (1149, 1158), False, 'from yt.utilities.answer_testing.framework import data_dir_load\n'), ((1167, 1206), 'yt.visualization.plot_window.SlicePlot', 'SlicePlot', (['ds_oas', '[1, 1, 1]', '"""density"""'], {}), "(ds_oas, [1, 1, 1], 'density')\n", (1176, 1206), False, 'from yt.visualization.plot_window import ProjectionPlot, SlicePlot\n'), ((1229, 1248), 'yt.testing.assert_fname', 'assert_fname', (['fn[0]'], {}), '(fn[0])\n', (1241, 1248), False, 'from yt.testing import assert_array_equal, assert_fname, fake_random_ds, requires_file, requires_module\n'), ((1254, 1270), 'os.chdir', 'os.chdir', (['curdir'], {}), '(curdir)\n', (1262, 1270), False, 'import os\n'), ((1275, 1296), 'shutil.rmtree', 'shutil.rmtree', (['tmpdir'], {}), '(tmpdir)\n', (1288, 1296), False, 'import shutil\n'), ((438, 474), 'os.path.join', 'os.path.join', (['ytdata_dir', '"""slice.h5"""'], {}), "(ytdata_dir, 'slice.h5')\n", (450, 474), False, 'import os\n'), ((491, 526), 'os.path.join', 'os.path.join', (['ytdata_dir', '"""proj.h5"""'], {}), "(ytdata_dir, 'proj.h5')\n", (503, 526), False, 'import os\n'), ((543, 577), 'os.path.join', 'os.path.join', (['ytdata_dir', '"""oas.h5"""'], {}), "(ytdata_dir, 'oas.h5')\n", (555, 577), False, 'import os\n'), ((1359, 1377), 'tempfile.mkdtemp', 'tempfile.mkdtemp', ([], {}), '()\n', (1375, 1377), False, 'import tempfile\n'), ((1391, 1402), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (1400, 1402), False, 'import os\n'), ((1407, 1423), 'os.chdir', 'os.chdir', (['tmpdir'], {}), '(tmpdir)\n', (1415, 1423), False, 'import os\n'), ((1433, 1451), 'yt.testing.fake_random_ds', 'fake_random_ds', (['(16)'], {}), '(16)\n', (1447, 1451), False, 'from yt.testing import assert_array_equal, assert_fname, fake_random_ds, requires_file, requires_module\n'), ((1464, 1493), 'yt.visualization.plot_window.SlicePlot', 'SlicePlot', (['ds', '"""z"""', '"""density"""'], {}), "(ds, 'z', 'density')\n", (1473, 1493), False, 'from yt.visualization.plot_window import ProjectionPlot, SlicePlot\n'), ((1563, 1571), 'yt.loaders.load', 'load', (['fn'], {}), '(fn)\n', (1567, 1571), False, 'from yt.loaders import load, load_uniform_grid\n'), ((1580, 1615), 'yt.visualization.plot_window.SlicePlot', 'SlicePlot', (['ds_slice', '"""z"""', '"""density"""'], {}), "(ds_slice, 'z', 'density')\n", (1589, 1615), False, 'from yt.visualization.plot_window import ProjectionPlot, SlicePlot\n'), ((1638, 1657), 'yt.testing.assert_fname', 'assert_fname', (['fn[0]'], {}), '(fn[0])\n', (1650, 1657), False, 'from yt.testing import assert_array_equal, assert_fname, fake_random_ds, requires_file, requires_module\n'), ((1670, 1704), 'yt.visualization.plot_window.ProjectionPlot', 'ProjectionPlot', (['ds', '"""z"""', '"""density"""'], {}), "(ds, 'z', 'density')\n", (1684, 1704), False, 'from yt.visualization.plot_window import ProjectionPlot, SlicePlot\n'), ((1772, 1780), 'yt.loaders.load', 'load', (['fn'], {}), '(fn)\n', (1776, 1780), False, 'from yt.loaders import load, load_uniform_grid\n'), ((1789, 1828), 'yt.visualization.plot_window.ProjectionPlot', 'ProjectionPlot', (['ds_proj', '"""z"""', '"""density"""'], {}), "(ds_proj, 'z', 'density')\n", (1803, 1828), False, 'from yt.visualization.plot_window import ProjectionPlot, SlicePlot\n'), ((1851, 1870), 'yt.testing.assert_fname', 'assert_fname', (['fn[0]'], {}), '(fn[0])\n', (1863, 1870), False, 'from yt.testing import assert_array_equal, assert_fname, fake_random_ds, requires_file, requires_module\n'), ((1883, 1918), 'yt.visualization.plot_window.SlicePlot', 'SlicePlot', (['ds', '[1, 1, 1]', '"""density"""'], {}), "(ds, [1, 1, 1], 'density')\n", (1892, 1918), False, 'from yt.visualization.plot_window import ProjectionPlot, SlicePlot\n'), ((1984, 1992), 'yt.loaders.load', 'load', (['fn'], {}), '(fn)\n', (1988, 1992), False, 'from yt.loaders import load, load_uniform_grid\n'), ((2001, 2040), 'yt.visualization.plot_window.SlicePlot', 'SlicePlot', (['ds_oas', '[1, 1, 1]', '"""density"""'], {}), "(ds_oas, [1, 1, 1], 'density')\n", (2010, 2040), False, 'from yt.visualization.plot_window import ProjectionPlot, SlicePlot\n'), ((2063, 2082), 'yt.testing.assert_fname', 'assert_fname', (['fn[0]'], {}), '(fn[0])\n', (2075, 2082), False, 'from yt.testing import assert_array_equal, assert_fname, fake_random_ds, requires_file, requires_module\n'), ((2088, 2104), 'os.chdir', 'os.chdir', (['curdir'], {}), '(curdir)\n', (2096, 2104), False, 'import os\n'), ((2224, 2242), 'tempfile.mkdtemp', 'tempfile.mkdtemp', ([], {}), '()\n', (2240, 2242), False, 'import tempfile\n'), ((2256, 2267), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (2265, 2267), False, 'import os\n'), ((2272, 2288), 'os.chdir', 'os.chdir', (['tmpdir'], {}), '(tmpdir)\n', (2280, 2288), False, 'import os\n'), ((2438, 2483), 'numpy.array', 'np.array', (['[[-4, 4.0], [-4.5, 4.5], [-5.0, 5]]'], {}), '([[-4, 4.0], [-4.5, 4.5], [-5.0, 5]])\n', (2446, 2483), True, 'import numpy as np\n'), ((2493, 2596), 'yt.loaders.load_uniform_grid', 'load_uniform_grid', (['data', 'arr.shape'], {'length_unit': '"""Mpc"""', 'bbox': 'bbox', 'periodicity': '(False, False, False)'}), "(data, arr.shape, length_unit='Mpc', bbox=bbox,\n periodicity=(False, False, False))\n", (2510, 2596), False, 'from yt.loaders import load, load_uniform_grid\n'), ((3511, 3522), 'yt.loaders.load', 'load', (['fname'], {}), '(fname)\n', (3515, 3522), False, 'from yt.loaders import load, load_uniform_grid\n'), ((3528, 3603), 'yt.testing.assert_array_equal', 'assert_array_equal', (["frb['density'].shape", "reloaded_ds.data['density'].shape"], {}), "(frb['density'].shape, reloaded_ds.data['density'].shape)\n", (3546, 3603), False, 'from yt.testing import assert_array_equal, assert_fname, fake_random_ds, requires_file, requires_module\n'), ((3608, 3671), 'yt.testing.assert_array_equal', 'assert_array_equal', (["frb['density']", "reloaded_ds.data['density']"], {}), "(frb['density'], reloaded_ds.data['density'])\n", (3626, 3671), False, 'from yt.testing import assert_array_equal, assert_fname, fake_random_ds, requires_file, requires_module\n'), ((3677, 3693), 'os.chdir', 'os.chdir', (['curdir'], {}), '(curdir)\n', (3685, 3693), False, 'import os\n'), ((2135, 2156), 'shutil.rmtree', 'shutil.rmtree', (['tmpdir'], {}), '(tmpdir)\n', (2148, 2156), False, 'import shutil\n'), ((3724, 3745), 'shutil.rmtree', 'shutil.rmtree', (['tmpdir'], {}), '(tmpdir)\n', (3737, 3745), False, 'import shutil\n'), ((2337, 2364), 'numpy.arange', 'np.arange', (['(8.0 * 9.0 * 10.0)'], {}), '(8.0 * 9.0 * 10.0)\n', (2346, 2364), True, 'import numpy as np\n')]
|
import numba as nb
import numpy as np
import scipy.stats
@nb.njit(parallel=True)
def tiecorrect(rankvals):
"""
parallelized version of scipy.stats.tiecorrect
:param rankvals: p x n array of ranked data (output of rankdata function)
"""
tc = np.ones(rankvals.shape[1], dtype=np.float64)
for j in nb.prange(rankvals.shape[1]):
arr = np.sort(np.ravel(rankvals[:, j]))
idx = np.nonzero(
np.concatenate((np.array([True]), arr[1:] != arr[:-1], np.array([True])))
)[0]
t_k = np.diff(idx).astype(np.float64)
size = np.float64(arr.size)
if size >= 2:
tc[j] = 1.0 - (t_k ** 3 - t_k).sum() / (size ** 3 - size)
return tc
@nb.njit(parallel=True)
def rankdata(data):
"""
parallelized version of scipy.stats.rankdata
:param data: p x n array of data to rank, column-wise
"""
ranked = np.empty(data.shape, dtype=np.float64)
for j in nb.prange(data.shape[1]):
arr = np.ravel(data[:, j])
sorter = np.argsort(arr)
arr = arr[sorter]
obs = np.concatenate((np.array([True]), arr[1:] != arr[:-1]))
dense = np.empty(obs.size, dtype=np.int64)
dense[sorter] = obs.cumsum()
# cumulative counts of each unique value
count = np.concatenate((np.nonzero(obs)[0], np.array([len(obs)])))
ranked[:, j] = 0.5 * (count[dense] + count[dense - 1] + 1)
return ranked
def mannwhitneyu(x, y, use_continuity=True):
"""Version of Mann-Whitney U-test that runs in parallel on 2d arrays
This is the two-sided test, asymptotic algo only. Returns log p-values
"""
x = np.asarray(x)
y = np.asarray(y)
assert x.shape[1] == y.shape[1]
n1 = x.shape[0]
n2 = y.shape[0]
ranked = rankdata(np.concatenate((x, y)))
rankx = ranked[:n1, :] # get the x-ranks
u1 = n1 * n2 + (n1 * (n1 + 1)) / 2.0 - np.sum(rankx, axis=0) # calc U for x
u2 = n1 * n2 - u1 # remainder is U for y
T = tiecorrect(ranked)
# if *everything* is identical we'll raise an error, not otherwise
if np.all(T == 0):
raise ValueError("All numbers are identical in mannwhitneyu")
sd = np.sqrt(T * n1 * n2 * (n1 + n2 + 1) / 12.0)
meanrank = n1 * n2 / 2.0 + 0.5 * use_continuity
bigu = np.maximum(u1, u2)
with np.errstate(divide="ignore", invalid="ignore"):
z = (bigu - meanrank) / sd
logp = np.minimum(scipy.stats.norm.logsf(z) + np.log(2), 0)
return u2, logp
|
[
"numpy.sqrt",
"numpy.ones",
"numpy.float64",
"numpy.log",
"numba.njit",
"numpy.asarray",
"numpy.diff",
"numpy.argsort",
"numpy.sum",
"numpy.errstate",
"numpy.array",
"numpy.empty",
"numpy.concatenate",
"numpy.nonzero",
"numpy.maximum",
"numba.prange",
"numpy.all",
"numpy.ravel"
] |
[((60, 82), 'numba.njit', 'nb.njit', ([], {'parallel': '(True)'}), '(parallel=True)\n', (67, 82), True, 'import numba as nb\n'), ((718, 740), 'numba.njit', 'nb.njit', ([], {'parallel': '(True)'}), '(parallel=True)\n', (725, 740), True, 'import numba as nb\n'), ((264, 308), 'numpy.ones', 'np.ones', (['rankvals.shape[1]'], {'dtype': 'np.float64'}), '(rankvals.shape[1], dtype=np.float64)\n', (271, 308), True, 'import numpy as np\n'), ((322, 350), 'numba.prange', 'nb.prange', (['rankvals.shape[1]'], {}), '(rankvals.shape[1])\n', (331, 350), True, 'import numba as nb\n'), ((898, 936), 'numpy.empty', 'np.empty', (['data.shape'], {'dtype': 'np.float64'}), '(data.shape, dtype=np.float64)\n', (906, 936), True, 'import numpy as np\n'), ((950, 974), 'numba.prange', 'nb.prange', (['data.shape[1]'], {}), '(data.shape[1])\n', (959, 974), True, 'import numba as nb\n'), ((1653, 1666), 'numpy.asarray', 'np.asarray', (['x'], {}), '(x)\n', (1663, 1666), True, 'import numpy as np\n'), ((1675, 1688), 'numpy.asarray', 'np.asarray', (['y'], {}), '(y)\n', (1685, 1688), True, 'import numpy as np\n'), ((2092, 2106), 'numpy.all', 'np.all', (['(T == 0)'], {}), '(T == 0)\n', (2098, 2106), True, 'import numpy as np\n'), ((2187, 2230), 'numpy.sqrt', 'np.sqrt', (['(T * n1 * n2 * (n1 + n2 + 1) / 12.0)'], {}), '(T * n1 * n2 * (n1 + n2 + 1) / 12.0)\n', (2194, 2230), True, 'import numpy as np\n'), ((2295, 2313), 'numpy.maximum', 'np.maximum', (['u1', 'u2'], {}), '(u1, u2)\n', (2305, 2313), True, 'import numpy as np\n'), ((587, 607), 'numpy.float64', 'np.float64', (['arr.size'], {}), '(arr.size)\n', (597, 607), True, 'import numpy as np\n'), ((990, 1010), 'numpy.ravel', 'np.ravel', (['data[:, j]'], {}), '(data[:, j])\n', (998, 1010), True, 'import numpy as np\n'), ((1028, 1043), 'numpy.argsort', 'np.argsort', (['arr'], {}), '(arr)\n', (1038, 1043), True, 'import numpy as np\n'), ((1158, 1192), 'numpy.empty', 'np.empty', (['obs.size'], {'dtype': 'np.int64'}), '(obs.size, dtype=np.int64)\n', (1166, 1192), True, 'import numpy as np\n'), ((1789, 1811), 'numpy.concatenate', 'np.concatenate', (['(x, y)'], {}), '((x, y))\n', (1803, 1811), True, 'import numpy as np\n'), ((1902, 1923), 'numpy.sum', 'np.sum', (['rankx'], {'axis': '(0)'}), '(rankx, axis=0)\n', (1908, 1923), True, 'import numpy as np\n'), ((2324, 2370), 'numpy.errstate', 'np.errstate', ([], {'divide': '"""ignore"""', 'invalid': '"""ignore"""'}), "(divide='ignore', invalid='ignore')\n", (2335, 2370), True, 'import numpy as np\n'), ((374, 398), 'numpy.ravel', 'np.ravel', (['rankvals[:, j]'], {}), '(rankvals[:, j])\n', (382, 398), True, 'import numpy as np\n'), ((2458, 2467), 'numpy.log', 'np.log', (['(2)'], {}), '(2)\n', (2464, 2467), True, 'import numpy as np\n'), ((539, 551), 'numpy.diff', 'np.diff', (['idx'], {}), '(idx)\n', (546, 551), True, 'import numpy as np\n'), ((1101, 1117), 'numpy.array', 'np.array', (['[True]'], {}), '([True])\n', (1109, 1117), True, 'import numpy as np\n'), ((1312, 1327), 'numpy.nonzero', 'np.nonzero', (['obs'], {}), '(obs)\n', (1322, 1327), True, 'import numpy as np\n'), ((454, 470), 'numpy.array', 'np.array', (['[True]'], {}), '([True])\n', (462, 470), True, 'import numpy as np\n'), ((493, 509), 'numpy.array', 'np.array', (['[True]'], {}), '([True])\n', (501, 509), True, 'import numpy as np\n')]
|
from collections import deque
import numpy as np
import os
from abc import ABCMeta, abstractmethod
import random
random.seed(42)
from common import config, VehicleState
from helper import Helper
INFO = """Average merging time: {} s
Traffic flow: {} vehicle/s
Average speed: {} km/h
Average fuel consumption: {} ml/vehicle"""
class Vehicle(object):
"""docstring for Vehicle"""
def __init__(self, builder):
super(Vehicle, self).__init__()
self.ID = builder.ID
self.size = builder.size
self.speed = builder.speed
self.acceleration = builder.acceleration
self.max_speed = builder.max_speed
self.min_speed = builder.min_speed
self.max_acc = builder.max_acc
self.lane = builder.lane
self.position = builder.position
class VehicleBuilder(object):
"""docstring for VehicleBuilder"""
def __init__(self, ID):
super(VehicleBuilder, self).__init__()
self.ID = ID
self.max_acc = config.max_acc
self.max_speed = config.max_speed
self.min_speed = config.min_speed
self.size = config.size
def setSpeed(self, speed):
self.speed = speed
return self
def setPosition(self, position):
self.position = position
return self
def setLane(self, lane):
self.lane = lane
return self
def setAcceleration(self, acceleration):
self.acceleration = acceleration
return self
def build(self):
return Vehicle(self)
class OnBoardVehicle(object):
"""docstring for OnBoardVehicle"""
def __init__(self, vehicle, t0, min_pass_time=config.min_pass_time):
self.vehicle = vehicle
self.t0 = t0
self.tm = float('Inf')
self.position_history = [vehicle.position]
self.speed_history = [vehicle.speed]
self.acc_history = [vehicle.acceleration]
self.fuel_history = [0]
self.time_steps = [t0]
self.ParaV = None
self.min_pass_time = min_pass_time
self.state = VehicleState.PENDING
@property
def v0(self):
return self.speed_history[0]
@property
def p0(self):
return self.position_history[0]
@property
def merge_time(self):
return self.time_steps[-1] - self.time_steps[0]
@property
def tf(self):
return self.time_steps[-1]
@property
def average_speed(self):
return np.array(self.speed_history).mean()
@property
def fuel_consumption(self):
return self.fuel_history[-1]
class VehicleGeneratorBase(metaclass=ABCMeta):
"""docstring for VehicleGeneratorBase"""
def __init__(self):
self.schedule = deque()
self.buildSchedule()
@abstractmethod
def buildSchedule(self):
pass
def getAtTime(self, ctime):
vehicle_to_add = []
while self.hasVehicle() and self.schedule[0].t0 <= ctime:
vehicle_to_add.append(self.schedule.popleft())
return vehicle_to_add
def hasVehicle(self):
return len(self.schedule) > 0
def FIFOIDAssigner(self):
self.schedule = deque(sorted(self.schedule, key=lambda x:x.t0))
for i, ove in enumerate(self.schedule):
ove.vehicle.ID = i
def SpeedIDAssigner(self):
for ove in self.schedule:
ove.min_pass_time = Helper.getTmOptimal2(ove.v0, config.case_speed['speed_merge'],
-config.control_len, 0)
self.schedule = deque(sorted(self.schedule, key=lambda x:x.t0 + x.min_pass_time))
for i, ove in enumerate(self.schedule):
ove.vehicle.ID = i
self.schedule = deque(sorted(self.schedule, key=lambda x:x.t0))
class Case1VehicleGenerator(VehicleGeneratorBase):
"""docstring for Case1VehicleGenerator"""
def __init__(self):
super(Case1VehicleGenerator, self).__init__()
def buildSchedule(self):
for i in range(config.case1['total_cars']):
v = VehicleBuilder(i)\
.setSpeed(config.case1['speed'])\
.setPosition(-config.control_len)\
.setAcceleration(0)\
.setLane(i % 2).build()
t = 10.0 if (i < 2) else 15.0
# self.schedule.append(OnBoardVehicle(v, t, config.control_len / config.case1['speed']))
tm = Helper.getTmOptimal2(config.case1['speed'], config.case_speed['speed_merge'],
-config.control_len, 0) if i == 0 else 0
self.schedule.append(OnBoardVehicle(v, t, tm))
# self.schedule.sort(key=lambda x: x.vehicle.ID)
class Case2VehicleGenerator(VehicleGeneratorBase):
"""docstring for Case1VehicleGenerator"""
def __init__(self):
super(Case2VehicleGenerator, self).__init__()
def buildSchedule(self):
tnum = config.case2['total_cars']
# Randomly generate tnum//2 cars on each lane, with time span 10~50
# This does not ensure feasibility at initial state
t0_lane0 = np.random.rand(tnum//2) * 40.0 + 10.0
t0_lane1 = np.random.rand(tnum//2) * 40.0 + 10.0
for i in range(tnum):
v = VehicleBuilder(-1)\
.setSpeed(config.case2['speed'])\
.setPosition(-config.control_len)\
.setAcceleration(0)\
.setLane(i % 2).build()
t = t0_lane0[i//2] if (i % 2 == 0) else t0_lane1[i//2]
self.schedule.append(OnBoardVehicle(v, t, config.control_len / config.case2['speed']))
self.FIFOIDAssigner()
class MainHigherSpeedVG(VehicleGeneratorBase):
def __init__(self):
super(MainHigherSpeedVG, self).__init__()
def buildSchedule(self):
# lane0 (main road)
t0_lane0 = np.arange(10, 30.1, 2.0)
t0_lane1 = np.arange(9, 30.1, 3.1)
v0_lane0 = 25.0
v0_lane1 = 15.0
for ti0 in t0_lane0:
v = VehicleBuilder(-1)\
.setSpeed(v0_lane0)\
.setPosition(-config.control_len)\
.setAcceleration(0)\
.setLane(0).build()
self.schedule.append(OnBoardVehicle(v, ti0, Helper.getTc(v)))
for ti0 in t0_lane1:
v = VehicleBuilder(-1)\
.setSpeed(v0_lane1)\
.setPosition(-config.control_len)\
.setAcceleration(0)\
.setLane(1).build()
self.schedule.append(OnBoardVehicle(v, ti0, Helper.getTc(v)))
self.FIFOIDAssigner()
# self.SpeedIDAssigner()
class PoissonVehicleGenerator(VehicleGeneratorBase):
"""docstring for Case1VehicleGenerator"""
def __init__(self, tnum_lane0, tnum_lane1):
self.tnum_lane0 = tnum_lane0
self.tnum_lane1 = tnum_lane1
super(PoissonVehicleGenerator, self).__init__()
def buildSchedule(self):
speed_lane0 = config.case_speed['speed_init_lane0']
speed_lane1 = config.case_speed['speed_init_lane1']
t0_lane0 = [0]
t0_lane1 = [0]
tsp_lane0 = (config.delta) / speed_lane0
tsp_lane1 = (config.delta) / speed_lane1
for i in range(self.tnum_lane0):
t0_lane0.append(t0_lane0[-1] + tsp_lane0 + np.random.exponential(5.0))
for i in range(self.tnum_lane1):
t0_lane1.append(t0_lane1[-1] + tsp_lane1 + np.random.exponential(5.0))
t0_lane0 = np.array(t0_lane0[1:])
t0_lane1 = np.array(t0_lane1[1:])
for i in range(self.tnum_lane0):
speed_v = speed_lane0 + np.random.randn()
v = VehicleBuilder(-1)\
.setSpeed(speed_v)\
.setPosition(-config.control_len)\
.setAcceleration(0)\
.setLane(0).build()
t = t0_lane0[i]
self.schedule.append(OnBoardVehicle(v, t, Helper.getTc(v)))
for i in range(self.tnum_lane1):
speed_v = speed_lane1 + np.random.randn()
v = VehicleBuilder(-1)\
.setSpeed(speed_v)\
.setPosition(-config.control_len)\
.setAcceleration(0)\
.setLane(1).build()
t = t0_lane1[i]
self.schedule.append(OnBoardVehicle(v, t, Helper.getTc(v)))
self.FIFOIDAssigner()
# self.SpeedIDAssigner()
class APPVehicleGenerator(VehicleGeneratorBase):
def __init__(self, tnum, id_assigner, min_pass_time):
self.tnum = tnum
self.ida = id_assigner
self.mpt = min_pass_time
super(APPVehicleGenerator, self).__init__()
def buildSchedule(self):
tnum = self.tnum
t0_lane0 = np.random.rand(tnum//2) * 40.0 + 10.0
t0_lane1 = np.random.rand(tnum//2) * 40.0 + 10.0
for i in range(tnum):
v = VehicleBuilder(-1)\
.setSpeed(config.case2['speed'])\
.setPosition(-config.control_len)\
.setAcceleration(0)\
.setLane(i % 2).build()
t = t0_lane0[i//2] if (i % 2 == 0) else t0_lane1[i//2]
self.schedule.append(OnBoardVehicle(v, t, self.mpt))
if self.ida == 'FIFO':
self.FIFOIDAssigner()
elif self.ida == 'main':
self.MainRoadFirstIDAssigner()
class GameLoop(object):
"""docstring for GameLoop"""
def __init__(self, vscd):
super(GameLoop, self).__init__()
self.ctime = 0
self.vscd = vscd
self.on_board_vehicles = deque()
self.finished_vehicels = deque()
def isOver(self):
if self.ctime >= config.max_sim_time:
print("Simulation time out.")
return True
return (not self.vscd.hasVehicle()) and self.isEmpty()
def isEmpty(self):
return len(self.on_board_vehicles) == 0
def nextStep(self):
self.ctime += config.time_meta
t = self.ctime
ove_t = self.vscd.getAtTime(t)
for v in ove_t:
if v.vehicle.ID == 0:
# v.tm = v.t0 + max(config.min_pass_time, v.min_pass_time)
v.tm = v.t0 + Helper.getTmOptimal2(v.v0, config.speed_merge, v.p0, 0)
elif len(self.on_board_vehicles) > 0:
v.tm = Helper.getTm(v, self.on_board_vehicles[-1])
else:
v.tm = Helper.getTm(v, self.finished_vehicels[-1])
self.on_board_vehicles.append(v)
TimeM = Helper.getTimeMatrix(t, v.tm)
ConfV = Helper.getConfigVec(v)
v.ParaV = np.dot(np.linalg.inv(TimeM), ConfV)
v.state = VehicleState.ON_RAMP
for v in self.on_board_vehicles:
Helper.updateAVP(v, t)
if v.vehicle.position >= 0:
v.state = VehicleState.ON_MERGING
while not self.isEmpty() and self.on_board_vehicles[0].vehicle.position >= config.merging_len:
self.on_board_vehicles[0].state = VehicleState.FINISHED
self.finished_vehicels.append((self.on_board_vehicles.popleft()))
def play(self):
while not self.isOver():
self.nextStep()
self.measure()
def measure(self):
# Measure average merging time
AMT = np.array([v.merge_time for v in self.finished_vehicels]).mean()
# Measure traffic flow
TF = len(self.finished_vehicels) / (self.finished_vehicels[-1].tf - self.finished_vehicels[0].t0)
# Measure average speed
AS = 1 / np.array([1 / v.average_speed for v in self.finished_vehicels]).mean() * 3.6
# Measure average fuel consumption
AFC = np.array([v.fuel_consumption for v in self.finished_vehicels]).mean()
print(INFO.format(AMT, TF, AS, AFC))
def draw_result_pyplot(self, file_path=None):
import matplotlib.pyplot as plt
plt.figure(1)
plt.subplot(221)
plt.xlabel('time')
plt.ylabel('position')
plt.title('positions')
for tv in self.finished_vehicels:
linecolor = 'r--' if tv.vehicle.lane == 0 else 'b'
plt.plot(tv.time_steps, tv.position_history, linecolor,
label="Car {}".format(tv.vehicle.ID))
plt.grid(True)
if file_path:
plt.savefig(os.path.join(file_path, "position.pdf"), format="pdf")
plt.subplot(222)
plt.xlabel('time')
plt.ylabel('speed')
plt.title('speeds')
for tv in self.finished_vehicels:
linecolor = 'r--' if tv.vehicle.lane == 0 else 'b'
plt.plot(tv.time_steps, tv.speed_history, linecolor,
label="Car {}".format(tv.vehicle.ID))
plt.grid(True)
if file_path:
plt.savefig(os.path.join(file_path, "speed.pdf"), format="pdf")
plt.subplot(223)
plt.xlabel('time')
plt.ylabel('acceleration')
plt.title('accelerations')
for tv in self.finished_vehicels:
linecolor = 'r--' if tv.vehicle.lane == 0 else 'b'
plt.plot(tv.time_steps, tv.acc_history, linecolor,
label="Car {}".format(tv.vehicle.ID))
plt.grid(True)
if file_path:
plt.savefig(os.path.join(file_path, "acc.pdf"), format="pdf")
plt.subplot(224)
plt.xlabel('time')
plt.ylabel('fuel')
plt.title('fuels')
for tv in self.finished_vehicels:
linecolor = 'r--' if tv.vehicle.lane == 0 else 'b'
plt.plot(tv.time_steps, tv.fuel_history, linecolor,
label="Car {}".format(tv.vehicle.ID))
plt.grid(True)
if file_path:
plt.savefig(os.path.join(file_path, "fuel.pdf"), format="pdf")
if not file_path:
plt.subplots_adjust(top=0.92, bottom=-0.35, left=0.10, right=1.35, hspace=0.35,
wspace=0.35)
plt.show()
def draw_result(self, file_path):
from bokeh.layouts import gridplot
from bokeh.plotting import figure, output_file, show
output_file(file_path)
TOOLS = "pan,wheel_zoom,box_zoom,reset,save,box_select,lasso_select"
s1 = figure(tools=TOOLS, title="positions", x_axis_label="time", y_axis_label="position")
for tv in self.finished_vehicels:
s1.line(tv.time_steps, tv.position_history,
line_color="red" if tv.vehicle.lane == 0 else "blue",
legend="Car {}".format(tv.vehicle.ID), line_width=2)
s1.xgrid.minor_grid_line_color = 'navy'
s1.xgrid.minor_grid_line_alpha = 0.1
s1.ygrid.minor_grid_line_color = 'navy'
s1.ygrid.minor_grid_line_alpha = 0.1
s2 = figure(tools=TOOLS, title="speed", x_axis_label="time", y_axis_label="speed",
x_range=s1.x_range)
for tv in self.finished_vehicels:
s2.line(tv.time_steps, tv.speed_history,
line_color="red" if tv.vehicle.lane == 0 else "blue",
legend="Car {}".format(tv.vehicle.ID), line_width=2)
s2.xgrid.minor_grid_line_color = 'navy'
s2.xgrid.minor_grid_line_alpha = 0.1
s2.ygrid.minor_grid_line_color = 'navy'
s2.ygrid.minor_grid_line_alpha = 0.1
s3 = figure(tools=TOOLS, title="acceleration", x_axis_label="time", y_axis_label="acceleration",
x_range=s1.x_range)
for tv in self.finished_vehicels:
s3.line(tv.time_steps, tv.acc_history,
line_color="red" if tv.vehicle.lane == 0 else "blue",
legend="Car {}".format(tv.vehicle.ID), line_width=2)
s3.xgrid.minor_grid_line_color = 'navy'
s3.xgrid.minor_grid_line_alpha = 0.1
s3.ygrid.minor_grid_line_color = 'navy'
s3.ygrid.minor_grid_line_alpha = 0.1
s4 = figure(tools=TOOLS, title="fuel consumption", x_axis_label="time", y_axis_label="fuel",
x_range=s1.x_range)
for tv in self.finished_vehicels:
s4.line(tv.time_steps, tv.fuel_history,
line_color="red" if tv.vehicle.lane == 0 else "blue",
legend="Car {}".format(tv.vehicle.ID), line_width=2)
s4.xgrid.minor_grid_line_color = 'navy'
s4.xgrid.minor_grid_line_alpha = 0.1
s4.ygrid.minor_grid_line_color = 'navy'
s4.ygrid.minor_grid_line_alpha = 0.1
p = gridplot([[s1, s2, s3, s4]])
try:
show(p)
except Exception as e:
pass
show(p)
class SpeedGameLoop(GameLoop):
"""docstring for SpeedGameLoop"""
def __init__(self, vscd):
super(SpeedGameLoop, self).__init__(vscd)
self.on_board_vehicles = []
def nextStep(self):
self.ctime += config.time_meta
t = self.ctime
ove_t = self.vscd.getAtTime(t)
for v in ove_t:
tmp_v_stack = []
while len(self.on_board_vehicles) > 0 and self.on_board_vehicles[-1].vehicle.ID > v.vehicle.ID:
tmpv = self.on_board_vehicles.pop()
# tmpv.t0 = t
# tmpv.min_pass_time = max(tmpv.min_pass_time, Helper.getTmOptimal2(tmpv.vehicle.speed,
# config.case_speed['speed_merge'], tmpv.vehicle.position, 0))
tmp_v_stack.append(tmpv)
# Get t_m
if len(self.on_board_vehicles) == 0 and len(self.finished_vehicels) == 0:
v.tm = v.t0 + max(config.min_pass_time, v.min_pass_time)
elif len(self.on_board_vehicles) > 0:
v.tm = Helper.getTm(v, self.on_board_vehicles[-1])
else:
v.tm = Helper.getTm(v, self.finished_vehicels[-1])
tmp_v_stack.append(v)
prevve = None
for i in reversed(range(len(tmp_v_stack))):
ve = tmp_v_stack[i]
if prevve is not None:
ve.tm = Helper.getTm(ve, prevve)
self.on_board_vehicles.append(ve)
TimeM = Helper.getTimeMatrix(t, ve.tm)
ConfV = Helper.getConfigVec(ve)
# from IPython import embed; embed()
ve.ParaV = np.dot(np.linalg.inv(TimeM), ConfV)
ve.state = VehicleState.ON_RAMP
prevve = ve
# print("ID {}".format(prevve.vehicle.ID))
for v in self.on_board_vehicles:
Helper.updateAVP(v, t)
if v.vehicle.position >= 0:
v.state = VehicleState.ON_MERGING
while not self.isEmpty() and self.on_board_vehicles[0].vehicle.position >= config.merging_len:
self.on_board_vehicles[0].state = VehicleState.FINISHED
self.finished_vehicels.append((self.on_board_vehicles.pop(0)))
def main():
# vehicle_generator = Case1VehicleGenerator()
# game = GameLoop(vehicle_generator)
# game.play()
# game.draw_result_pyplot("case1")
vehicle_generator = MainHigherSpeedVG()
game = GameLoop(vehicle_generator)
# game = SpeedGameLoop(vehicle_generator)
game.play()
game.draw_result_pyplot("case2")
# vehicle_generator = APPVehicleGenerator(12, 'FIFO', 16.9)
# vehicle_generator = PoissonVehicleGenerator(config.case_speed['tnum_lane0'],
# config.case_speed['tnum_lane1'])
# ggame = GameLoop(vehicle_generator)
# ggame.play()
# # ggame.draw_result("result.html")
# ggame.draw_result_pyplot(".")
if __name__ == '__main__':
main()
|
[
"matplotlib.pyplot.grid",
"bokeh.plotting.figure",
"helper.Helper.getTmOptimal2",
"matplotlib.pyplot.ylabel",
"numpy.random.rand",
"helper.Helper.getConfigVec",
"numpy.random.exponential",
"numpy.array",
"numpy.arange",
"helper.Helper.getTc",
"helper.Helper.getTimeMatrix",
"collections.deque",
"matplotlib.pyplot.xlabel",
"helper.Helper.updateAVP",
"bokeh.plotting.show",
"bokeh.layouts.gridplot",
"matplotlib.pyplot.title",
"numpy.random.randn",
"matplotlib.pyplot.subplots_adjust",
"matplotlib.pyplot.show",
"helper.Helper.getTm",
"os.path.join",
"random.seed",
"matplotlib.pyplot.figure",
"numpy.linalg.inv",
"matplotlib.pyplot.subplot",
"bokeh.plotting.output_file"
] |
[((118, 133), 'random.seed', 'random.seed', (['(42)'], {}), '(42)\n', (129, 133), False, 'import random\n'), ((2806, 2813), 'collections.deque', 'deque', ([], {}), '()\n', (2811, 2813), False, 'from collections import deque\n'), ((5912, 5936), 'numpy.arange', 'np.arange', (['(10)', '(30.1)', '(2.0)'], {}), '(10, 30.1, 2.0)\n', (5921, 5936), True, 'import numpy as np\n'), ((5957, 5980), 'numpy.arange', 'np.arange', (['(9)', '(30.1)', '(3.1)'], {}), '(9, 30.1, 3.1)\n', (5966, 5980), True, 'import numpy as np\n'), ((7571, 7593), 'numpy.array', 'np.array', (['t0_lane0[1:]'], {}), '(t0_lane0[1:])\n', (7579, 7593), True, 'import numpy as np\n'), ((7614, 7636), 'numpy.array', 'np.array', (['t0_lane1[1:]'], {}), '(t0_lane1[1:])\n', (7622, 7636), True, 'import numpy as np\n'), ((9689, 9696), 'collections.deque', 'deque', ([], {}), '()\n', (9694, 9696), False, 'from collections import deque\n'), ((9731, 9738), 'collections.deque', 'deque', ([], {}), '()\n', (9736, 9738), False, 'from collections import deque\n'), ((12048, 12061), 'matplotlib.pyplot.figure', 'plt.figure', (['(1)'], {}), '(1)\n', (12058, 12061), True, 'import matplotlib.pyplot as plt\n'), ((12071, 12087), 'matplotlib.pyplot.subplot', 'plt.subplot', (['(221)'], {}), '(221)\n', (12082, 12087), True, 'import matplotlib.pyplot as plt\n'), ((12097, 12115), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""time"""'], {}), "('time')\n", (12107, 12115), True, 'import matplotlib.pyplot as plt\n'), ((12125, 12147), 'matplotlib.pyplot.ylabel', 'plt.ylabel', (['"""position"""'], {}), "('position')\n", (12135, 12147), True, 'import matplotlib.pyplot as plt\n'), ((12157, 12179), 'matplotlib.pyplot.title', 'plt.title', (['"""positions"""'], {}), "('positions')\n", (12166, 12179), True, 'import matplotlib.pyplot as plt\n'), ((12420, 12434), 'matplotlib.pyplot.grid', 'plt.grid', (['(True)'], {}), '(True)\n', (12428, 12434), True, 'import matplotlib.pyplot as plt\n'), ((12549, 12565), 'matplotlib.pyplot.subplot', 'plt.subplot', (['(222)'], {}), '(222)\n', (12560, 12565), True, 'import matplotlib.pyplot as plt\n'), ((12575, 12593), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""time"""'], {}), "('time')\n", (12585, 12593), True, 'import matplotlib.pyplot as plt\n'), ((12603, 12622), 'matplotlib.pyplot.ylabel', 'plt.ylabel', (['"""speed"""'], {}), "('speed')\n", (12613, 12622), True, 'import matplotlib.pyplot as plt\n'), ((12632, 12651), 'matplotlib.pyplot.title', 'plt.title', (['"""speeds"""'], {}), "('speeds')\n", (12641, 12651), True, 'import matplotlib.pyplot as plt\n'), ((12889, 12903), 'matplotlib.pyplot.grid', 'plt.grid', (['(True)'], {}), '(True)\n', (12897, 12903), True, 'import matplotlib.pyplot as plt\n'), ((13015, 13031), 'matplotlib.pyplot.subplot', 'plt.subplot', (['(223)'], {}), '(223)\n', (13026, 13031), True, 'import matplotlib.pyplot as plt\n'), ((13041, 13059), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""time"""'], {}), "('time')\n", (13051, 13059), True, 'import matplotlib.pyplot as plt\n'), ((13069, 13095), 'matplotlib.pyplot.ylabel', 'plt.ylabel', (['"""acceleration"""'], {}), "('acceleration')\n", (13079, 13095), True, 'import matplotlib.pyplot as plt\n'), ((13105, 13131), 'matplotlib.pyplot.title', 'plt.title', (['"""accelerations"""'], {}), "('accelerations')\n", (13114, 13131), True, 'import matplotlib.pyplot as plt\n'), ((13367, 13381), 'matplotlib.pyplot.grid', 'plt.grid', (['(True)'], {}), '(True)\n', (13375, 13381), True, 'import matplotlib.pyplot as plt\n'), ((13491, 13507), 'matplotlib.pyplot.subplot', 'plt.subplot', (['(224)'], {}), '(224)\n', (13502, 13507), True, 'import matplotlib.pyplot as plt\n'), ((13517, 13535), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""time"""'], {}), "('time')\n", (13527, 13535), True, 'import matplotlib.pyplot as plt\n'), ((13545, 13563), 'matplotlib.pyplot.ylabel', 'plt.ylabel', (['"""fuel"""'], {}), "('fuel')\n", (13555, 13563), True, 'import matplotlib.pyplot as plt\n'), ((13573, 13591), 'matplotlib.pyplot.title', 'plt.title', (['"""fuels"""'], {}), "('fuels')\n", (13582, 13591), True, 'import matplotlib.pyplot as plt\n'), ((13828, 13842), 'matplotlib.pyplot.grid', 'plt.grid', (['(True)'], {}), '(True)\n', (13836, 13842), True, 'import matplotlib.pyplot as plt\n'), ((14280, 14302), 'bokeh.plotting.output_file', 'output_file', (['file_path'], {}), '(file_path)\n', (14291, 14302), False, 'from bokeh.plotting import figure, output_file, show\n'), ((14395, 14484), 'bokeh.plotting.figure', 'figure', ([], {'tools': 'TOOLS', 'title': '"""positions"""', 'x_axis_label': '"""time"""', 'y_axis_label': '"""position"""'}), "(tools=TOOLS, title='positions', x_axis_label='time', y_axis_label=\n 'position')\n", (14401, 14484), False, 'from bokeh.plotting import figure, output_file, show\n'), ((14927, 15029), 'bokeh.plotting.figure', 'figure', ([], {'tools': 'TOOLS', 'title': '"""speed"""', 'x_axis_label': '"""time"""', 'y_axis_label': '"""speed"""', 'x_range': 's1.x_range'}), "(tools=TOOLS, title='speed', x_axis_label='time', y_axis_label=\n 'speed', x_range=s1.x_range)\n", (14933, 15029), False, 'from bokeh.plotting import figure, output_file, show\n'), ((15482, 15598), 'bokeh.plotting.figure', 'figure', ([], {'tools': 'TOOLS', 'title': '"""acceleration"""', 'x_axis_label': '"""time"""', 'y_axis_label': '"""acceleration"""', 'x_range': 's1.x_range'}), "(tools=TOOLS, title='acceleration', x_axis_label='time', y_axis_label\n ='acceleration', x_range=s1.x_range)\n", (15488, 15598), False, 'from bokeh.plotting import figure, output_file, show\n'), ((16049, 16160), 'bokeh.plotting.figure', 'figure', ([], {'tools': 'TOOLS', 'title': '"""fuel consumption"""', 'x_axis_label': '"""time"""', 'y_axis_label': '"""fuel"""', 'x_range': 's1.x_range'}), "(tools=TOOLS, title='fuel consumption', x_axis_label='time',\n y_axis_label='fuel', x_range=s1.x_range)\n", (16055, 16160), False, 'from bokeh.plotting import figure, output_file, show\n'), ((16612, 16640), 'bokeh.layouts.gridplot', 'gridplot', (['[[s1, s2, s3, s4]]'], {}), '([[s1, s2, s3, s4]])\n', (16620, 16640), False, 'from bokeh.layouts import gridplot\n'), ((16735, 16742), 'bokeh.plotting.show', 'show', (['p'], {}), '(p)\n', (16739, 16742), False, 'from bokeh.plotting import figure, output_file, show\n'), ((3490, 3581), 'helper.Helper.getTmOptimal2', 'Helper.getTmOptimal2', (['ove.v0', "config.case_speed['speed_merge']", '(-config.control_len)', '(0)'], {}), "(ove.v0, config.case_speed['speed_merge'], -config.\n control_len, 0)\n", (3510, 3581), False, 'from helper import Helper\n'), ((10645, 10674), 'helper.Helper.getTimeMatrix', 'Helper.getTimeMatrix', (['t', 'v.tm'], {}), '(t, v.tm)\n', (10665, 10674), False, 'from helper import Helper\n'), ((10696, 10718), 'helper.Helper.getConfigVec', 'Helper.getConfigVec', (['v'], {}), '(v)\n', (10715, 10718), False, 'from helper import Helper\n'), ((10879, 10901), 'helper.Helper.updateAVP', 'Helper.updateAVP', (['v', 't'], {}), '(v, t)\n', (10895, 10901), False, 'from helper import Helper\n'), ((13984, 14080), 'matplotlib.pyplot.subplots_adjust', 'plt.subplots_adjust', ([], {'top': '(0.92)', 'bottom': '(-0.35)', 'left': '(0.1)', 'right': '(1.35)', 'hspace': '(0.35)', 'wspace': '(0.35)'}), '(top=0.92, bottom=-0.35, left=0.1, right=1.35, hspace=\n 0.35, wspace=0.35)\n', (14003, 14080), True, 'import matplotlib.pyplot as plt\n'), ((14111, 14121), 'matplotlib.pyplot.show', 'plt.show', ([], {}), '()\n', (14119, 14121), True, 'import matplotlib.pyplot as plt\n'), ((16668, 16675), 'bokeh.plotting.show', 'show', (['p'], {}), '(p)\n', (16672, 16675), False, 'from bokeh.plotting import figure, output_file, show\n'), ((18658, 18680), 'helper.Helper.updateAVP', 'Helper.updateAVP', (['v', 't'], {}), '(v, t)\n', (18674, 18680), False, 'from helper import Helper\n'), ((2534, 2562), 'numpy.array', 'np.array', (['self.speed_history'], {}), '(self.speed_history)\n', (2542, 2562), True, 'import numpy as np\n'), ((4488, 4594), 'helper.Helper.getTmOptimal2', 'Helper.getTmOptimal2', (["config.case1['speed']", "config.case_speed['speed_merge']", '(-config.control_len)', '(0)'], {}), "(config.case1['speed'], config.case_speed['speed_merge'\n ], -config.control_len, 0)\n", (4508, 4594), False, 'from helper import Helper\n'), ((5158, 5183), 'numpy.random.rand', 'np.random.rand', (['(tnum // 2)'], {}), '(tnum // 2)\n', (5172, 5183), True, 'import numpy as np\n'), ((5216, 5241), 'numpy.random.rand', 'np.random.rand', (['(tnum // 2)'], {}), '(tnum // 2)\n', (5230, 5241), True, 'import numpy as np\n'), ((7718, 7735), 'numpy.random.randn', 'np.random.randn', ([], {}), '()\n', (7733, 7735), True, 'import numpy as np\n'), ((8120, 8137), 'numpy.random.randn', 'np.random.randn', ([], {}), '()\n', (8135, 8137), True, 'import numpy as np\n'), ((8844, 8869), 'numpy.random.rand', 'np.random.rand', (['(tnum // 2)'], {}), '(tnum // 2)\n', (8858, 8869), True, 'import numpy as np\n'), ((8902, 8927), 'numpy.random.rand', 'np.random.rand', (['(tnum // 2)'], {}), '(tnum // 2)\n', (8916, 8927), True, 'import numpy as np\n'), ((10749, 10769), 'numpy.linalg.inv', 'np.linalg.inv', (['TimeM'], {}), '(TimeM)\n', (10762, 10769), True, 'import numpy as np\n'), ((11439, 11495), 'numpy.array', 'np.array', (['[v.merge_time for v in self.finished_vehicels]'], {}), '([v.merge_time for v in self.finished_vehicels])\n', (11447, 11495), True, 'import numpy as np\n'), ((11829, 11891), 'numpy.array', 'np.array', (['[v.fuel_consumption for v in self.finished_vehicels]'], {}), '([v.fuel_consumption for v in self.finished_vehicels])\n', (11837, 11891), True, 'import numpy as np\n'), ((12483, 12522), 'os.path.join', 'os.path.join', (['file_path', '"""position.pdf"""'], {}), "(file_path, 'position.pdf')\n", (12495, 12522), False, 'import os\n'), ((12952, 12988), 'os.path.join', 'os.path.join', (['file_path', '"""speed.pdf"""'], {}), "(file_path, 'speed.pdf')\n", (12964, 12988), False, 'import os\n'), ((13430, 13464), 'os.path.join', 'os.path.join', (['file_path', '"""acc.pdf"""'], {}), "(file_path, 'acc.pdf')\n", (13442, 13464), False, 'import os\n'), ((13891, 13926), 'os.path.join', 'os.path.join', (['file_path', '"""fuel.pdf"""'], {}), "(file_path, 'fuel.pdf')\n", (13903, 13926), False, 'import os\n'), ((18265, 18295), 'helper.Helper.getTimeMatrix', 'Helper.getTimeMatrix', (['t', 've.tm'], {}), '(t, ve.tm)\n', (18285, 18295), False, 'from helper import Helper\n'), ((18321, 18344), 'helper.Helper.getConfigVec', 'Helper.getConfigVec', (['ve'], {}), '(ve)\n', (18340, 18344), False, 'from helper import Helper\n'), ((6320, 6335), 'helper.Helper.getTc', 'Helper.getTc', (['v'], {}), '(v)\n', (6332, 6335), False, 'from helper import Helper\n'), ((6627, 6642), 'helper.Helper.getTc', 'Helper.getTc', (['v'], {}), '(v)\n', (6639, 6642), False, 'from helper import Helper\n'), ((7397, 7423), 'numpy.random.exponential', 'np.random.exponential', (['(5.0)'], {}), '(5.0)\n', (7418, 7423), True, 'import numpy as np\n'), ((7523, 7549), 'numpy.random.exponential', 'np.random.exponential', (['(5.0)'], {}), '(5.0)\n', (7544, 7549), True, 'import numpy as np\n'), ((8021, 8036), 'helper.Helper.getTc', 'Helper.getTc', (['v'], {}), '(v)\n', (8033, 8036), False, 'from helper import Helper\n'), ((8423, 8438), 'helper.Helper.getTc', 'Helper.getTc', (['v'], {}), '(v)\n', (8435, 8438), False, 'from helper import Helper\n'), ((10316, 10371), 'helper.Helper.getTmOptimal2', 'Helper.getTmOptimal2', (['v.v0', 'config.speed_merge', 'v.p0', '(0)'], {}), '(v.v0, config.speed_merge, v.p0, 0)\n', (10336, 10371), False, 'from helper import Helper\n'), ((10447, 10490), 'helper.Helper.getTm', 'Helper.getTm', (['v', 'self.on_board_vehicles[-1]'], {}), '(v, self.on_board_vehicles[-1])\n', (10459, 10490), False, 'from helper import Helper\n'), ((10534, 10577), 'helper.Helper.getTm', 'Helper.getTm', (['v', 'self.finished_vehicels[-1]'], {}), '(v, self.finished_vehicels[-1])\n', (10546, 10577), False, 'from helper import Helper\n'), ((17808, 17851), 'helper.Helper.getTm', 'Helper.getTm', (['v', 'self.on_board_vehicles[-1]'], {}), '(v, self.on_board_vehicles[-1])\n', (17820, 17851), False, 'from helper import Helper\n'), ((17895, 17938), 'helper.Helper.getTm', 'Helper.getTm', (['v', 'self.finished_vehicels[-1]'], {}), '(v, self.finished_vehicels[-1])\n', (17907, 17938), False, 'from helper import Helper\n'), ((18164, 18188), 'helper.Helper.getTm', 'Helper.getTm', (['ve', 'prevve'], {}), '(ve, prevve)\n', (18176, 18188), False, 'from helper import Helper\n'), ((18434, 18454), 'numpy.linalg.inv', 'np.linalg.inv', (['TimeM'], {}), '(TimeM)\n', (18447, 18454), True, 'import numpy as np\n'), ((11693, 11758), 'numpy.array', 'np.array', (['[(1 / v.average_speed) for v in self.finished_vehicels]'], {}), '([(1 / v.average_speed) for v in self.finished_vehicels])\n', (11701, 11758), True, 'import numpy as np\n')]
|
# -*- coding: utf-8 -*-
import os
import torch
from torch.autograd import Variable
import numpy as np
import scipy
import matplotlib.pyplot as plt
import cv2
import scipy.ndimage
import shutil
import scipy.misc as misc
from PIL import Image
def mkdirs(folders, erase=False):
if type(folders) is not list:
folders = [folders]
for fold in folders:
if not os.path.exists(fold):
os.makedirs(fold)
else:
if erase:
shutil.rmtree(fold)
os.makedirs(fold)
def normalize_img(X):
min_, max_ = np.min(X), np.max(X)
X = (X - min_) / (max_ - min_ + 1e-9)
X = X * 255
return X.astype(np.uint8)
def imread(imgfile):
assert os.path.exists(imgfile), '{} does not exist!'.format(imgfile)
srcBGR = cv2.imread(imgfile)
destRGB = cv2.cvtColor(srcBGR, cv2.COLOR_BGR2RGB)
return destRGB
def writeImg(array, savepath):
scipy.misc.imsave(savepath, array)
def imresize(img, resizeratio=1):
'''Take care of cv2 reshape squeeze behevaior'''
if resizeratio == 1:
return img
outshape = (int(img.shape[1] * resizeratio), int(img.shape[0] * resizeratio))
# temp = cv2.resize(img, outshape).astype(float)
temp = misc.imresize(img, size=outshape).astype(float)
if len(img.shape) == 3 and img.shape[2] == 1:
temp = np.reshape(temp, temp.shape + (1,))
return temp
def imresize_shape(img, outshape):
if len(img.shape) == 3:
if img.shape[0] == 1 or img.shape[0] == 3:
transpose_img = np.transpose(img, (1, 2, 0))
_img = imresize_shape(transpose_img, outshape)
return np.transpose(_img, (2, 0, 1))
if len(img.shape) == 4:
img_out = []
for this_img in img:
img_out.append(imresize_shape(this_img, outshape))
return np.stack(img_out, axis=0)
img = img.astype(np.float32)
outshape = (int(outshape[1]), int(outshape[0]))
# temp = cv2.resize(img, outshape).astype(float)
temp = misc.imresize(img, size=outshape, interp='bilinear').astype(float)
if len(img.shape) == 3 and img.shape[2] == 1:
temp = np.reshape(temp, temp.shape + (1,))
return temp
def imshow(img, size=None):
if size is not None:
plt.figure(figsize=size)
else:
plt.figure()
plt.imshow(img)
plt.show()
def Indexflow(Totalnum, batch_size, random=True):
numberofchunk = int(Totalnum + batch_size - 1) // int(batch_size) # the floor
# Chunkfile = np.zeros((batch_size, row*col*channel))
totalIndx = np.arange(Totalnum).astype(np.int)
if random is True:
totalIndx = np.random.permutation(totalIndx)
chunkstart = 0
for chunkidx in range(int(numberofchunk)):
thisnum = min(batch_size, Totalnum - chunkidx * batch_size)
thisInd = totalIndx[chunkstart: chunkstart + thisnum]
chunkstart += thisnum
yield thisInd
def IndexH5(h5_array, indices):
read_list = []
for idx in indices:
read_list.append(h5_array[idx])
return np.stack(read_list, 0)
def ensure_dir(path):
if not os.path.exists(path):
os.makedirs(path)
def word_list(word_idx_list, vocab):
"""Take a list of word ids and a vocabulary from a dataset as inputs
and return the corresponding words as a list.
"""
word_list = []
for i in range(len(word_idx_list)):
vocab_id = word_idx_list[i]
word = vocab.idx2word[vocab_id]
if word == vocab.end_word:
break
if word != vocab.start_word:
word_list.append(word)
return word_list
def clean_sentence(word_idx_list, vocab):
"""Take a list of word ids and a vocabulary from a dataset as inputs
and return the corresponding sentence (as a single Python string).
"""
sentence = []
for i in range(len(word_idx_list)):
vocab_id = word_idx_list[i]
word = vocab.idx2word[vocab_id]
if word == vocab.end_word:
break
if word != vocab.start_word:
sentence.append(word)
sentence = " ".join(sentence)
return sentence
def get_end_symbol_index(caption_list):
if 1 in caption_list:
return caption_list.index(1) + 1
else:
return len(caption_list)
def get_caption_lengths(captions_list):
caption_lengths = [get_end_symbol_index(caption) for caption in captions_list]
caption_lengths.sort(reverse=True)
batch_captions = torch.zeros(len(captions_list), max(caption_lengths)).long()
caption_lengths = torch.LongTensor(caption_lengths)
for i, cap in enumerate(captions_list):
end = caption_lengths[i]
batch_captions[i, :end] = torch.tensor(cap[:end]).long()
if torch.cuda.is_available():
batch_captions = batch_captions.cuda()
caption_lengths = caption_lengths.cuda()
return batch_captions, caption_lengths
def to_numpy(src):
if type(src) == np.ndarray:
return src
elif type(src) == Variable:
x = src.data
else:
x = src
return x.detach().cpu().numpy()
def tensor2im(input_image, imtype=np.uint8):
""""Converts a Tensor array into a numpy image array.
Parameters:
input_image (tensor) -- the input image tensor array
imtype (type) -- the desired type of the converted numpy array
"""
if not isinstance(input_image, np.ndarray):
if isinstance(input_image, torch.Tensor): # get the data from a variable
image_tensor = input_image.data
else:
return input_image
image_numpy = image_tensor[0].cpu().float().numpy() # convert it into a numpy array
if image_numpy.shape[0] == 1: # grayscale to RGB
image_numpy = np.tile(image_numpy, (3, 1, 1))
image_numpy = (np.transpose(image_numpy, (1, 2, 0)) + 1) / 2.0 * 255.0 # post-processing: tranpose and scaling
else: # if it is a numpy array, do nothing
image_numpy = input_image
return image_numpy.astype(imtype)
def diagnose_network(net, name='network'):
"""Calculate and print the mean of average absolute(gradients)
Parameters:
net (torch network) -- Torch network
name (str) -- the name of the network
"""
mean = 0.0
count = 0
for param in net.parameters():
if param.grad is not None:
mean += torch.mean(torch.abs(param.grad.data))
count += 1
if count > 0:
mean = mean / count
print(name)
print(mean)
def save_image(image_numpy, image_path):
"""Save a numpy image to the disk
Parameters:
image_numpy (numpy array) -- input numpy array
image_path (str) -- the path of the image
"""
image_pil = Image.fromarray(image_numpy)
image_pil.save(image_path)
def print_numpy(x, val=True, shp=False):
"""Print the mean, min, max, median, std, and size of a numpy array
Parameters:
val (bool) -- if print the values of the numpy array
shp (bool) -- if print the shape of the numpy array
"""
x = x.astype(np.float64)
if shp:
print('shape,', x.shape)
if val:
x = x.flatten()
print('mean = %3.3f, min = %3.3f, max = %3.3f, median = %3.3f, std=%3.3f' % (
np.mean(x), np.min(x), np.max(x), np.median(x), np.std(x)))
def mkdirs(paths):
"""create empty directories if they don't exist
Parameters:
paths (str list) -- a list of directory paths
"""
if isinstance(paths, list) and not isinstance(paths, str):
for path in paths:
mkdir(path)
else:
mkdir(paths)
def mkdir(path):
"""create a single empty directory if it didn't exist
Parameters:
path (str) -- a single directory path
"""
if not os.path.exists(path):
os.makedirs(path)
def convert_back_to_text(word_idx_array, vocab):
from itertools import takewhile
blacklist = [vocab.word2idx[word] for word in [vocab.start_word]]
predicate = lambda word_id: vocab.idx2word[word_id] != vocab.end_word
sampled_caption = [vocab.idx2word[word_id] for word_id in takewhile(predicate, word_idx_array) if word_id not in blacklist]
sentence = '-'.join(sampled_caption)
return sentence
|
[
"torch.LongTensor",
"torch.cuda.is_available",
"scipy.misc.imresize",
"numpy.arange",
"matplotlib.pyplot.imshow",
"os.path.exists",
"numpy.mean",
"numpy.reshape",
"scipy.misc.imsave",
"numpy.max",
"numpy.stack",
"numpy.min",
"numpy.random.permutation",
"numpy.tile",
"torch.abs",
"itertools.takewhile",
"cv2.cvtColor",
"numpy.std",
"numpy.transpose",
"cv2.imread",
"matplotlib.pyplot.show",
"PIL.Image.fromarray",
"numpy.median",
"os.makedirs",
"torch.tensor",
"matplotlib.pyplot.figure",
"shutil.rmtree"
] |
[((724, 747), 'os.path.exists', 'os.path.exists', (['imgfile'], {}), '(imgfile)\n', (738, 747), False, 'import os\n'), ((799, 818), 'cv2.imread', 'cv2.imread', (['imgfile'], {}), '(imgfile)\n', (809, 818), False, 'import cv2\n'), ((833, 872), 'cv2.cvtColor', 'cv2.cvtColor', (['srcBGR', 'cv2.COLOR_BGR2RGB'], {}), '(srcBGR, cv2.COLOR_BGR2RGB)\n', (845, 872), False, 'import cv2\n'), ((929, 963), 'scipy.misc.imsave', 'scipy.misc.imsave', (['savepath', 'array'], {}), '(savepath, array)\n', (946, 963), False, 'import scipy\n'), ((2330, 2345), 'matplotlib.pyplot.imshow', 'plt.imshow', (['img'], {}), '(img)\n', (2340, 2345), True, 'import matplotlib.pyplot as plt\n'), ((2350, 2360), 'matplotlib.pyplot.show', 'plt.show', ([], {}), '()\n', (2358, 2360), True, 'import matplotlib.pyplot as plt\n'), ((3058, 3080), 'numpy.stack', 'np.stack', (['read_list', '(0)'], {}), '(read_list, 0)\n', (3066, 3080), True, 'import numpy as np\n'), ((4542, 4575), 'torch.LongTensor', 'torch.LongTensor', (['caption_lengths'], {}), '(caption_lengths)\n', (4558, 4575), False, 'import torch\n'), ((4726, 4751), 'torch.cuda.is_available', 'torch.cuda.is_available', ([], {}), '()\n', (4749, 4751), False, 'import torch\n'), ((6739, 6767), 'PIL.Image.fromarray', 'Image.fromarray', (['image_numpy'], {}), '(image_numpy)\n', (6754, 6767), False, 'from PIL import Image\n'), ((581, 590), 'numpy.min', 'np.min', (['X'], {}), '(X)\n', (587, 590), True, 'import numpy as np\n'), ((592, 601), 'numpy.max', 'np.max', (['X'], {}), '(X)\n', (598, 601), True, 'import numpy as np\n'), ((1356, 1391), 'numpy.reshape', 'np.reshape', (['temp', '(temp.shape + (1,))'], {}), '(temp, temp.shape + (1,))\n', (1366, 1391), True, 'import numpy as np\n'), ((1845, 1870), 'numpy.stack', 'np.stack', (['img_out'], {'axis': '(0)'}), '(img_out, axis=0)\n', (1853, 1870), True, 'import numpy as np\n'), ((2155, 2190), 'numpy.reshape', 'np.reshape', (['temp', '(temp.shape + (1,))'], {}), '(temp, temp.shape + (1,))\n', (2165, 2190), True, 'import numpy as np\n'), ((2270, 2294), 'matplotlib.pyplot.figure', 'plt.figure', ([], {'figsize': 'size'}), '(figsize=size)\n', (2280, 2294), True, 'import matplotlib.pyplot as plt\n'), ((2313, 2325), 'matplotlib.pyplot.figure', 'plt.figure', ([], {}), '()\n', (2323, 2325), True, 'import matplotlib.pyplot as plt\n'), ((2648, 2680), 'numpy.random.permutation', 'np.random.permutation', (['totalIndx'], {}), '(totalIndx)\n', (2669, 2680), True, 'import numpy as np\n'), ((3116, 3136), 'os.path.exists', 'os.path.exists', (['path'], {}), '(path)\n', (3130, 3136), False, 'import os\n'), ((3146, 3163), 'os.makedirs', 'os.makedirs', (['path'], {}), '(path)\n', (3157, 3163), False, 'import os\n'), ((7781, 7801), 'os.path.exists', 'os.path.exists', (['path'], {}), '(path)\n', (7795, 7801), False, 'import os\n'), ((7811, 7828), 'os.makedirs', 'os.makedirs', (['path'], {}), '(path)\n', (7822, 7828), False, 'import os\n'), ((382, 402), 'os.path.exists', 'os.path.exists', (['fold'], {}), '(fold)\n', (396, 402), False, 'import os\n'), ((416, 433), 'os.makedirs', 'os.makedirs', (['fold'], {}), '(fold)\n', (427, 433), False, 'import os\n'), ((1243, 1276), 'scipy.misc.imresize', 'misc.imresize', (['img'], {'size': 'outshape'}), '(img, size=outshape)\n', (1256, 1276), True, 'import scipy.misc as misc\n'), ((1552, 1580), 'numpy.transpose', 'np.transpose', (['img', '(1, 2, 0)'], {}), '(img, (1, 2, 0))\n', (1564, 1580), True, 'import numpy as np\n'), ((1659, 1688), 'numpy.transpose', 'np.transpose', (['_img', '(2, 0, 1)'], {}), '(_img, (2, 0, 1))\n', (1671, 1688), True, 'import numpy as np\n'), ((2022, 2074), 'scipy.misc.imresize', 'misc.imresize', (['img'], {'size': 'outshape', 'interp': '"""bilinear"""'}), "(img, size=outshape, interp='bilinear')\n", (2035, 2074), True, 'import scipy.misc as misc\n'), ((2570, 2589), 'numpy.arange', 'np.arange', (['Totalnum'], {}), '(Totalnum)\n', (2579, 2589), True, 'import numpy as np\n'), ((5746, 5777), 'numpy.tile', 'np.tile', (['image_numpy', '(3, 1, 1)'], {}), '(image_numpy, (3, 1, 1))\n', (5753, 5777), True, 'import numpy as np\n'), ((8122, 8158), 'itertools.takewhile', 'takewhile', (['predicate', 'word_idx_array'], {}), '(predicate, word_idx_array)\n', (8131, 8158), False, 'from itertools import takewhile\n'), ((486, 505), 'shutil.rmtree', 'shutil.rmtree', (['fold'], {}), '(fold)\n', (499, 505), False, 'import shutil\n'), ((522, 539), 'os.makedirs', 'os.makedirs', (['fold'], {}), '(fold)\n', (533, 539), False, 'import os\n'), ((4687, 4710), 'torch.tensor', 'torch.tensor', (['cap[:end]'], {}), '(cap[:end])\n', (4699, 4710), False, 'import torch\n'), ((6375, 6401), 'torch.abs', 'torch.abs', (['param.grad.data'], {}), '(param.grad.data)\n', (6384, 6401), False, 'import torch\n'), ((5801, 5837), 'numpy.transpose', 'np.transpose', (['image_numpy', '(1, 2, 0)'], {}), '(image_numpy, (1, 2, 0))\n', (5813, 5837), True, 'import numpy as np\n'), ((7267, 7277), 'numpy.mean', 'np.mean', (['x'], {}), '(x)\n', (7274, 7277), True, 'import numpy as np\n'), ((7279, 7288), 'numpy.min', 'np.min', (['x'], {}), '(x)\n', (7285, 7288), True, 'import numpy as np\n'), ((7290, 7299), 'numpy.max', 'np.max', (['x'], {}), '(x)\n', (7296, 7299), True, 'import numpy as np\n'), ((7301, 7313), 'numpy.median', 'np.median', (['x'], {}), '(x)\n', (7310, 7313), True, 'import numpy as np\n'), ((7315, 7324), 'numpy.std', 'np.std', (['x'], {}), '(x)\n', (7321, 7324), True, 'import numpy as np\n')]
|
"""plot.py: Utility builder class for ML plots.
Uses scikit-learn code samples and framework
"""
__author__ = "<NAME>"
__license__ = "BSD"
__email__ = "<EMAIL>"
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import randomcolor
import math
from sklearn.metrics import confusion_matrix
from sklearn.metrics import roc_curve
from sklearn.metrics import auc
from .image import Image
class PlotBuilder:
def __init__(self):
self.__figures = []
self._subplot_idx = None
self._subplot_size = [1, 1]
self._current_subplot = None
self._next_plot = True
def show(self, close=True):
plt.show()
if close:
self.close()
def close(self):
for fig in self.__figures:
plt.close(fig)
self.__figures = []
self._subplot_idx = None
self._subplot_size = [1, 1]
def same(self):
self._next_plot = False
return self
@staticmethod
def get_plot():
return plt
def create_subplots(self, rows, cols, fig_size=(18, 18)):
self.__figures.append(plt.figure(figsize=fig_size))
self._subplot_idx = 0
self._subplot_size = [rows, cols]
return self
def _get_next_plot(self, **kwargs):
if not self._next_plot:
self._next_plot = False
return self._current_subplot
if self._subplot_idx is not None and self._subplot_idx >= (self._subplot_size[0] * self._subplot_size[1]):
self._subplot_idx = None
self._subplot_size = [1, 1]
if self._subplot_idx is None:
self.__figures.append(plt.figure(**kwargs))
self._current_subplot = self.__figures[-1].add_subplot(1, 1, 1)
return self._current_subplot
self._subplot_idx += 1
self._current_subplot = self.__figures[-1].add_subplot(*self._subplot_size, self._subplot_idx, **kwargs)
return self._current_subplot
def create_plot(self, title, x_data, *args):
"""
Plot a series of graphs on X axis points given by x_data
and Y axis by tuples of (y_values, y_title) in args
"""
sp = self._get_next_plot()
rand_color = randomcolor.RandomColor()
limits = [[100000, -100000], [100000, -100000], [100000, -100000]]
x_values, x_label = x_data
limits[0][0] = min(limits[0][0], min(x_values))
limits[0][1] = max(limits[0][1], max(x_values))
for data in args:
color = rand_color.generate()[0]
if isinstance(data, list):
i = 0
for y_values in data:
i += 1
limits[1][0] = min(limits[1][0], min(y_values))
limits[1][1] = max(limits[1][1], max(y_values))
sp.plot(x_values, y_values, color=color, linewidth=2,
linestyle='--' if i % 2 else '-')
else:
y_values, y_title = data
limits[1][0] = min(limits[1][0], min(y_values))
limits[1][1] = max(limits[1][1], max(y_values))
sp.plot(x_values, y_values, label=y_title, color=color, linewidth=2, linestyle='-')
sp.set_xlim(limits[0])
sp.set_xlabel(x_label)
sp.set_ylim(limits[1])
sp.legend(loc='upper right')
sp.set_title(title)
return self
def create_horizontal_line(self, *args, **kwargs):
sp = self._get_next_plot()
rand_color = randomcolor.RandomColor()
y_limits = list(sp.get_ylim())
for data in args:
y_value, y_title = data
y_limits[0] = min(y_limits[0], y_value)
y_limits[1] = max(y_limits[1], y_value)
sp.plot(sp.get_xlim(), [y_value, y_value], label=y_title, color=rand_color.generate()[0], **kwargs)
sp.set_ylim([y_limits[0] * 0.9, y_limits[1] * 1.1])
sp.legend(loc='upper right')
return self
def create_scatter_plot(self, title, axis_labels, *args):
"""
Plot a series of graphs of scatter points given by the
list of tuples (x, y, data_label)
"""
markers = ['o', '*', '+', 'P', 'X', 'D']
is_3d = len(axis_labels) == 3
sp = self._get_next_plot(projection='3d') if is_3d else self._get_next_plot()
rand_color = randomcolor.RandomColor()
limits = [[100000, -100000], [100000, -100000], [100000, -100000]]
marker_id = 0
for data in args:
data = list(data)
values = data[:-1]
label = data[-1]
color = rand_color.generate()[0]
for i, v in enumerate(values):
limits[i][0] = min(limits[i][0], min(v))
limits[i][1] = max(limits[i][1], max(v))
sp.scatter(*values, label=label, color=color, marker=markers[marker_id % len(markers)])
marker_id += 1
if is_3d:
x_label, y_label, z_label = axis_labels
else:
x_label, y_label = axis_labels
sp.set_xlim(limits[0])
sp.set_xlabel(x_label)
sp.set_ylim(limits[1])
sp.set_ylabel(y_label)
if is_3d:
sp.set_zlim(limits[2])
sp.set_zlabel(z_label)
sp.legend(loc='upper right')
sp.set_title(title)
return self
def create_histograms(self, pd_categoricals, titles, bins='auto', fig_size=(13, 6)):
"""
Creates a histogram based on x_data
"""
fig, ax = plt.subplots(figsize=fig_size)
self.__figures.append(fig)
subplot_no = len(pd_categoricals)
ax.axes.get_xaxis().set_visible(False)
ax.axes.get_yaxis().set_visible(False)
colors = {}
for i in range(len(pd_categoricals)):
data = pd_categoricals[i]
if isinstance(data, pd.core.series.Series):
data = data[data.isnull() == False].value_counts()
else:
data, labels = data
class_id, data = np.unique(data, return_counts=True)
sort_freq = np.argsort(-data)
data = dict(zip([labels[c] for c in class_id[sort_freq]], data[sort_freq]))
labels = [name for name in data.keys()]
data = [data[name] for name in labels]
if len(colors) != len(labels):
colors = dict(zip(labels, randomcolor.RandomColor().generate(count=len(labels))))
sp = fig.add_subplot(1, subplot_no, i + 1)
plt.bar(labels, data, color=[colors[l] for l in labels])
plt.xticks(labels, rotation=90)
sp.set_title(titles[i])
plt.tight_layout()
return self
def create_images(self, images, titles, **kwargs):
"""
Creates a grid of images
"""
subplot_cols = min(len(images), 6)
subplot_rows = math.ceil(len(images) / subplot_cols)
fig_size = kwargs.pop('figsize', 3)
dpi = kwargs.pop('dpi', 80)
fig = plt.figure(figsize=(subplot_cols * fig_size, subplot_rows * fig_size), dpi=dpi)
self.__figures.append(fig)
if len(images) != len(titles):
raise(Exception("Image and title list must be the same"))
for i in range(len(images)):
sp = fig.add_subplot(subplot_rows, subplot_cols, i + 1)
sp.set_title(titles[i])
image = images[i]
if isinstance(image, str):
image = Image.load(image)
plt.imshow(Image.to_image(image), **kwargs)
sp.axes.get_xaxis().set_visible(False)
sp.axes.get_yaxis().set_visible(False)
sp.grid(None)
plt.tight_layout()
return self
# https://scikit-learn.org/stable/auto_examples/model_selection/plot_confusion_matrix.html
def create_confusion_matrix(self, y_true, y_pred, classes, title=None,
x_label='Predicted class', y_label='True class', normalize=False, cmap=plt.cm.Blues):
"""
This function prints and plots the confusion matrix.
Normalization can be applied by setting `normalize=True`.
"""
fig, ax = plt.subplots(figsize=(8, 8))
self.__figures.append(fig)
if not title:
if normalize:
title = 'Normalized confusion matrix'
else:
title = 'Confusion matrix, without normalization'
# Compute confusion matrix
cm = confusion_matrix(y_true, y_pred, labels=np.array(range(len(classes))))
if normalize:
cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
im = ax.imshow(cm, interpolation='nearest', cmap=cmap)
# ax.figure.colorbar(im, ax=ax)
# We want to show all ticks...and label them with the respective list entries
ax.set(xticks=np.arange(cm.shape[1]),
yticks=np.arange(cm.shape[0]),
xticklabels=classes, yticklabels=classes,
title=title,
ylabel=y_label,
xlabel=x_label)
# Rotate the tick labels and set their alignment.
plt.setp(ax.get_xticklabels(), rotation=45, ha="right", rotation_mode="anchor")
ax.spines['bottom'].set_visible(False)
ax.spines['top'].set_visible(False)
ax.tick_params(axis='both', which='major', pad=10)
# Loop over data dimensions and create text annotations.
fmt = '.2f' if normalize else 'd'
thresh = cm.max() / 2.
for i in range(cm.shape[0]):
for j in range(cm.shape[1]):
ax.text(j, i, format(cm[i, j], fmt),
ha="center", va="center",
color="green" if i == j else "white" if cm[i, j] > thresh else "black")
fig.tight_layout()
return self
# https://scikit-learn.org/stable/auto_examples/model_selection/plot_roc.html
def create_roc_curve_multiclass(self, y_true_labels, y_predicted_scores, classes, plot_mask=False):
"""
Compute ROC curve and ROC area for each class
classes contains a list of target label names in the multiclass clasification
plot_mask can contain a list of True/False values for each of the above class to be predicted
"""
fpr = dict()
tpr = dict()
roc_auc = dict()
if not plot_mask:
plot_mask = classes != None
for i in range(len(classes)):
if plot_mask[i]:
fpr[i], tpr[i], _ = roc_curve(y_true_labels, y_predicted_scores[:, i], pos_label=i)
roc_auc[i] = auc(fpr[i], tpr[i])
# https://datascience.stackexchange.com/questions/15989/micro-average-vs-macro-average-performance-in-a-multiclass-classification-settin
# Compute micro-average ROC curve and ROC area for all classes
y_true_micro = np.array([], dtype=np.int32)
y_scores_micro = np.array([], dtype=np.float64)
for i in range(len(classes)):
if plot_mask[i]:
y_true_micro = np.append(y_true_micro, y_true_labels == i)
y_scores_micro = np.append(y_scores_micro, y_predicted_scores[:, i])
fpr["micro"], tpr["micro"], _ = roc_curve(y_true_micro, y_scores_micro)
roc_auc["micro"] = auc(fpr["micro"], tpr["micro"])
self.__plot_roc_curve(fpr, tpr, roc_auc, classes)
return self
def __plot_roc_curve(self, fpr, tpr, roc_auc, classes):
self.__figures.append(plt.figure(figsize=(15, 15)))
rand_color = randomcolor.RandomColor()
for i, c in enumerate(classes):
if i in fpr:
plt.plot(fpr[i], tpr[i], label='ROC curve [class=%s] (area = %0.2f)' % (c, roc_auc[i]),
color=rand_color.generate()[0], linewidth=2)
if 'micro' in fpr:
plt.plot(fpr['micro'], tpr['micro'], label='ROC curve Micro Average (area = %0.2f)' % roc_auc['micro'],
color='deeppink', linewidth=4, linestyle=':')
if 'macro' in fpr:
plt.plot(fpr['macro'], tpr['macro'], label='ROC curve Macro Average (area = %0.2f)' % roc_auc['macro'],
color='darkorange', linewidth=4, linestyle=':')
plt.plot([0, 1], [0, 1], color='navy', linewidth=2, linestyle='--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('Recall (False Positive Rate)')
plt.ylabel('Precision (True Positive Rate)')
plt.title('Receiver operating characteristic')
plt.legend(loc="lower right")
|
[
"matplotlib.pyplot.ylabel",
"sklearn.metrics.auc",
"numpy.argsort",
"numpy.array",
"sklearn.metrics.roc_curve",
"randomcolor.RandomColor",
"numpy.arange",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.close",
"matplotlib.pyplot.ylim",
"matplotlib.pyplot.xticks",
"matplotlib.pyplot.title",
"matplotlib.pyplot.xlim",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.show",
"numpy.unique",
"numpy.append",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.bar",
"matplotlib.pyplot.tight_layout",
"matplotlib.pyplot.subplots"
] |
[((697, 707), 'matplotlib.pyplot.show', 'plt.show', ([], {}), '()\n', (705, 707), True, 'import matplotlib.pyplot as plt\n'), ((2273, 2298), 'randomcolor.RandomColor', 'randomcolor.RandomColor', ([], {}), '()\n', (2296, 2298), False, 'import randomcolor\n'), ((3572, 3597), 'randomcolor.RandomColor', 'randomcolor.RandomColor', ([], {}), '()\n', (3595, 3597), False, 'import randomcolor\n'), ((4421, 4446), 'randomcolor.RandomColor', 'randomcolor.RandomColor', ([], {}), '()\n', (4444, 4446), False, 'import randomcolor\n'), ((5593, 5623), 'matplotlib.pyplot.subplots', 'plt.subplots', ([], {'figsize': 'fig_size'}), '(figsize=fig_size)\n', (5605, 5623), True, 'import matplotlib.pyplot as plt\n'), ((7098, 7177), 'matplotlib.pyplot.figure', 'plt.figure', ([], {'figsize': '(subplot_cols * fig_size, subplot_rows * fig_size)', 'dpi': 'dpi'}), '(figsize=(subplot_cols * fig_size, subplot_rows * fig_size), dpi=dpi)\n', (7108, 7177), True, 'import matplotlib.pyplot as plt\n'), ((7768, 7786), 'matplotlib.pyplot.tight_layout', 'plt.tight_layout', ([], {}), '()\n', (7784, 7786), True, 'import matplotlib.pyplot as plt\n'), ((8266, 8294), 'matplotlib.pyplot.subplots', 'plt.subplots', ([], {'figsize': '(8, 8)'}), '(figsize=(8, 8))\n', (8278, 8294), True, 'import matplotlib.pyplot as plt\n'), ((10963, 10991), 'numpy.array', 'np.array', (['[]'], {'dtype': 'np.int32'}), '([], dtype=np.int32)\n', (10971, 10991), True, 'import numpy as np\n'), ((11017, 11047), 'numpy.array', 'np.array', (['[]'], {'dtype': 'np.float64'}), '([], dtype=np.float64)\n', (11025, 11047), True, 'import numpy as np\n'), ((11316, 11355), 'sklearn.metrics.roc_curve', 'roc_curve', (['y_true_micro', 'y_scores_micro'], {}), '(y_true_micro, y_scores_micro)\n', (11325, 11355), False, 'from sklearn.metrics import roc_curve\n'), ((11383, 11414), 'sklearn.metrics.auc', 'auc', (["fpr['micro']", "tpr['micro']"], {}), "(fpr['micro'], tpr['micro'])\n", (11386, 11414), False, 'from sklearn.metrics import auc\n'), ((11638, 11663), 'randomcolor.RandomColor', 'randomcolor.RandomColor', ([], {}), '()\n', (11661, 11663), False, 'import randomcolor\n'), ((12335, 12402), 'matplotlib.pyplot.plot', 'plt.plot', (['[0, 1]', '[0, 1]'], {'color': '"""navy"""', 'linewidth': '(2)', 'linestyle': '"""--"""'}), "([0, 1], [0, 1], color='navy', linewidth=2, linestyle='--')\n", (12343, 12402), True, 'import matplotlib.pyplot as plt\n'), ((12411, 12431), 'matplotlib.pyplot.xlim', 'plt.xlim', (['[0.0, 1.0]'], {}), '([0.0, 1.0])\n', (12419, 12431), True, 'import matplotlib.pyplot as plt\n'), ((12440, 12461), 'matplotlib.pyplot.ylim', 'plt.ylim', (['[0.0, 1.05]'], {}), '([0.0, 1.05])\n', (12448, 12461), True, 'import matplotlib.pyplot as plt\n'), ((12470, 12512), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""Recall (False Positive Rate)"""'], {}), "('Recall (False Positive Rate)')\n", (12480, 12512), True, 'import matplotlib.pyplot as plt\n'), ((12521, 12565), 'matplotlib.pyplot.ylabel', 'plt.ylabel', (['"""Precision (True Positive Rate)"""'], {}), "('Precision (True Positive Rate)')\n", (12531, 12565), True, 'import matplotlib.pyplot as plt\n'), ((12574, 12620), 'matplotlib.pyplot.title', 'plt.title', (['"""Receiver operating characteristic"""'], {}), "('Receiver operating characteristic')\n", (12583, 12620), True, 'import matplotlib.pyplot as plt\n'), ((12629, 12658), 'matplotlib.pyplot.legend', 'plt.legend', ([], {'loc': '"""lower right"""'}), "(loc='lower right')\n", (12639, 12658), True, 'import matplotlib.pyplot as plt\n'), ((820, 834), 'matplotlib.pyplot.close', 'plt.close', (['fig'], {}), '(fig)\n', (829, 834), True, 'import matplotlib.pyplot as plt\n'), ((1157, 1185), 'matplotlib.pyplot.figure', 'plt.figure', ([], {'figsize': 'fig_size'}), '(figsize=fig_size)\n', (1167, 1185), True, 'import matplotlib.pyplot as plt\n'), ((6597, 6653), 'matplotlib.pyplot.bar', 'plt.bar', (['labels', 'data'], {'color': '[colors[l] for l in labels]'}), '(labels, data, color=[colors[l] for l in labels])\n', (6604, 6653), True, 'import matplotlib.pyplot as plt\n'), ((6666, 6697), 'matplotlib.pyplot.xticks', 'plt.xticks', (['labels'], {'rotation': '(90)'}), '(labels, rotation=90)\n', (6676, 6697), True, 'import matplotlib.pyplot as plt\n'), ((6746, 6764), 'matplotlib.pyplot.tight_layout', 'plt.tight_layout', ([], {}), '()\n', (6762, 6764), True, 'import matplotlib.pyplot as plt\n'), ((11586, 11614), 'matplotlib.pyplot.figure', 'plt.figure', ([], {'figsize': '(15, 15)'}), '(figsize=(15, 15))\n', (11596, 11614), True, 'import matplotlib.pyplot as plt\n'), ((11943, 12102), 'matplotlib.pyplot.plot', 'plt.plot', (["fpr['micro']", "tpr['micro']"], {'label': "('ROC curve Micro Average (area = %0.2f)' % roc_auc['micro'])", 'color': '"""deeppink"""', 'linewidth': '(4)', 'linestyle': '""":"""'}), "(fpr['micro'], tpr['micro'], label=\n 'ROC curve Micro Average (area = %0.2f)' % roc_auc['micro'], color=\n 'deeppink', linewidth=4, linestyle=':')\n", (11951, 12102), True, 'import matplotlib.pyplot as plt\n'), ((12153, 12314), 'matplotlib.pyplot.plot', 'plt.plot', (["fpr['macro']", "tpr['macro']"], {'label': "('ROC curve Macro Average (area = %0.2f)' % roc_auc['macro'])", 'color': '"""darkorange"""', 'linewidth': '(4)', 'linestyle': '""":"""'}), "(fpr['macro'], tpr['macro'], label=\n 'ROC curve Macro Average (area = %0.2f)' % roc_auc['macro'], color=\n 'darkorange', linewidth=4, linestyle=':')\n", (12161, 12314), True, 'import matplotlib.pyplot as plt\n'), ((1696, 1716), 'matplotlib.pyplot.figure', 'plt.figure', ([], {}), '(**kwargs)\n', (1706, 1716), True, 'import matplotlib.pyplot as plt\n'), ((6110, 6145), 'numpy.unique', 'np.unique', (['data'], {'return_counts': '(True)'}), '(data, return_counts=True)\n', (6119, 6145), True, 'import numpy as np\n'), ((6174, 6191), 'numpy.argsort', 'np.argsort', (['(-data)'], {}), '(-data)\n', (6184, 6191), True, 'import numpy as np\n'), ((8940, 8962), 'numpy.arange', 'np.arange', (['cm.shape[1]'], {}), '(cm.shape[1])\n', (8949, 8962), True, 'import numpy as np\n'), ((8986, 9008), 'numpy.arange', 'np.arange', (['cm.shape[0]'], {}), '(cm.shape[0])\n', (8995, 9008), True, 'import numpy as np\n'), ((10610, 10673), 'sklearn.metrics.roc_curve', 'roc_curve', (['y_true_labels', 'y_predicted_scores[:, i]'], {'pos_label': 'i'}), '(y_true_labels, y_predicted_scores[:, i], pos_label=i)\n', (10619, 10673), False, 'from sklearn.metrics import roc_curve\n'), ((10703, 10722), 'sklearn.metrics.auc', 'auc', (['fpr[i]', 'tpr[i]'], {}), '(fpr[i], tpr[i])\n', (10706, 10722), False, 'from sklearn.metrics import auc\n'), ((11146, 11189), 'numpy.append', 'np.append', (['y_true_micro', '(y_true_labels == i)'], {}), '(y_true_micro, y_true_labels == i)\n', (11155, 11189), True, 'import numpy as np\n'), ((11223, 11274), 'numpy.append', 'np.append', (['y_scores_micro', 'y_predicted_scores[:, i]'], {}), '(y_scores_micro, y_predicted_scores[:, i])\n', (11232, 11274), True, 'import numpy as np\n'), ((6473, 6498), 'randomcolor.RandomColor', 'randomcolor.RandomColor', ([], {}), '()\n', (6496, 6498), False, 'import randomcolor\n')]
|
import os
import time
import random
import scipy.sparse as sp
import numpy as np
import tensorflow as tf
import argparse
from models import SpHGAT
from utils import process
parser = argparse.ArgumentParser()
parser.add_argument('--dataset', help='Dataset.', default='imdb', type=str)
parser.add_argument('--epochs', help='Epochs.', default=100000, type=int)
parser.add_argument('--patience', help='Patience for early stopping.', default=100, type=int)
parser.add_argument('--lr', help='Learning rate.', default=0.005, type=float)
parser.add_argument('--l2_coef', help='Weight decay.', default=0.0005, type=float)
parser.add_argument('--dropout', help='Dropout.', default=0.6, type=float)
parser.add_argument('--train_rate', help='Label rate for training.', default=0.1, type=float)
parser.add_argument('--seed', help='Random seed for data splitting.', default=None, type=int)
parser.add_argument('--layers', help='Number of layers.', default=2, type=int)
parser.add_argument('--hid', help='Number of hidden units per head in each layer.',
nargs='*', default=[8, 8], type=int)
parser.add_argument('--heads', help='Number of attention heads in each layer.',
nargs='*', default=[8, 1], type=int)
parser.add_argument('--residue', help='Using residue.', action='store_true')
parser.add_argument('--repeat', help='Repeat.', default=10, type=int)
parser.add_argument('--random_feature', help='Random features', action='store_true')
parser.add_argument('--target_node', help='index of target nodes for classification.',
nargs='*', default=[0, 1], type=int)
parser.add_argument('--target_is_multilabels', help='each type of target node for classification is multi-labels or not.(0 means not else means yes)',
nargs='*', default=[0, 1], type=int)
parser.add_argument('--saved_model_suffix', help='to splite checkpoint by suffix', default="", type=str)
parser.add_argument('--no_attn_reg', help='Do not use edge direction regularization', action='store_true')
parser.add_argument('--simple_inner', help='Use original inner product', action='store_true')
parser.add_argument('--loop_coef', help='Coefficient for regularization.', default=1e-3, type=float)
parser.add_argument('--inv_coef', help='Coefficient for regularization.', default=1e-3, type=float)
config = tf.ConfigProto(allow_soft_placement=True)
config.gpu_options.allow_growth = True
args= parser.parse_args()
dataset = args.dataset
checkpt_file = 'pre_trained/{}/{}/{}.ckpt'.format(dataset, args.saved_model_suffix, dataset)
checkpt_file = checkpt_file.replace('//', '/')
process.mkdir(os.path.split(checkpt_file)[0])
# training params
batch_size = 1
train_rate = args.train_rate
seed = args.seed
nb_epochs = args.epochs
patience = args.patience
lr = args.lr # learning rate
l2_coef = args.l2_coef # weight decay
dropout = args.dropout
repeat = args.repeat
random_feature = args.random_feature
target_node = args.target_node
is_multilabel = [False if t==0 else True for t in args.target_is_multilabels]
loop_coef = args.loop_coef
inv_coef = args.inv_coef
layers = args.layers
hid = args.hid
if len(hid) == 1:
hid_units = hid * layers
elif len(hid) == layers:
hid_units = hid
heads = args.heads
if len(heads) == 1:
n_heads = heads * layers
elif len(heads) == 2:
n_heads = [heads[0]] * (layers - 1) + [heads[1]]
elif len(heads) == layers:
n_heads = heads
residual = args.residue # False
nonlinearity = tf.nn.elu
model = SpHGAT
no_attn_reg = args.no_attn_reg
simple_inner = args.simple_inner
random.seed(seed) # random seed for random data split only
print('Dataset: ' + dataset)
print('Train rate: ' + str(train_rate))
print('----- Opt. hyperparams -----')
print('lr: ' + str(lr))
print('l2_coef: ' + str(l2_coef))
print('----- Archi. hyperparams -----')
print('nb. layers: ' + str(len(hid_units)))
print('nb. units per layer: ' + str(hid_units))
print('nb. attention heads: ' + str(n_heads))
print('residual: ' + str(residual))
print('nonlinearity: ' + str(nonlinearity))
print('model: ' + str(model))
print('target nodes: ', target_node)
print('is_multilabel: ', is_multilabel)
print('loop_coef:', loop_coef)
print('inv_coef:', inv_coef)
sparse = True
metr_num = 2
total_vl_acc = np.array([0.]*(len(target_node)*metr_num)) # should be array
total_ts_acc = np.array([0.]*(len(target_node)*metr_num)) # should be array
def get_loss_acc(logits, labels, msk, is_multilabel=False):
global model
class_num = labels.shape[-1]
log_resh = tf.reshape(logits, [-1, class_num])
lab_resh = tf.reshape(labels, [-1, class_num])
msk_resh = tf.reshape(msk, [-1])
if is_multilabel:
loss = model.masked_sigmoid_cross_entropy(log_resh, lab_resh, msk_resh)
accuracy = [model.micro_f1(log_resh, lab_resh, msk_resh), model.macro_f1(log_resh, lab_resh, msk_resh)]
acc_name = ['if1', 'af1']
acc_full_name = ['micro f1', 'macro f1']
else:
loss = model.masked_softmax_cross_entropy(log_resh, lab_resh, msk_resh)
accuracy = [model.micro_f1_onelabel(log_resh, lab_resh, msk_resh), model.macro_f1_onelabel(log_resh, lab_resh, msk_resh)]
acc_name = ['if1', 'af1']
acc_full_name = ['micro f1', 'macro f1']
return loss, accuracy, acc_name, acc_full_name
def print_eachclass_info(train_loss_each, train_acc_each, val_loss_each, val_acc_each, acc_name):
tl_average = np.mean(np.array(train_loss_each), axis=0)
ta_average = np.mean(np.array(train_acc_each), axis=0)
vl_average = np.mean(np.array(val_loss_each), axis=0)
va_average = np.mean(np.array(val_acc_each), axis=0)
metric_num = int(len(ta_average)/len(tl_average))
for i in range(len(tl_average)):
line = '\t\t target %s: loss = %.3f, ' % (i, tl_average[i])
for j in range(metric_num):
line += '%s = %.5f, ' % (acc_name[i*metric_num+j], ta_average[i*metric_num+j])
line += '| Val: loss = %.3f, ' % (vl_average[i])
for j in range(metric_num):
line += '%s = %.5f, ' % (acc_name[i*metric_num+j], va_average[i*metric_num+j])
print(line)
for repeat_i in range(repeat):
print('Run #' + str(repeat_i) + ':')
adj, adj_type, edge_list, features, y_train, y_val, y_test,\
train_mask, val_mask, test_mask = process.load_heterogeneous_data(dataset, train_rate=train_rate, target_node=target_node)
features = [process.preprocess_features(feature)[0] for feature in features]
nb_nodes = [feature.shape[0] for feature in features]
ft_size = [feature.shape[1] for feature in features]
nb_classes = [y.shape[1] for y in y_train]
features = [feature[np.newaxis] for feature in features]
y_train = [y[np.newaxis] for y in y_train]
y_val = [y[np.newaxis] for y in y_val]
y_test = [y[np.newaxis] for y in y_test]
train_mask = [m[np.newaxis] for m in train_mask]
val_mask = [m[np.newaxis] for m in val_mask]
test_mask = [m[np.newaxis] for m in test_mask]
if random_feature:
features[0] = np.random.standard_normal(features[0].shape)
if sparse:
biases = [process.preprocess_adj_hete(a) for a in adj] # transposed here
else:
biases = []
for a in adj:
a = a.todense()
a = a[np.newaxis]
if no_attn_reg:
edge_list = [(i,) for i in range(len(adj_type))]
if simple_inner:
edge_list = []
with tf.Graph().as_default():
with tf.name_scope('input'):
ftr_in = [tf.placeholder(dtype=tf.float32,
shape=(batch_size, nb, ft)) for nb, ft in zip(nb_nodes, ft_size)]
if sparse:
bias_in = [tf.sparse_placeholder(dtype=tf.float32) for _ in biases]
else:
bias_in = None
lbl_in = [tf.placeholder(dtype=tf.int32, shape=(batch_size, nb_nodes[target_node[i]], nb_classes[i])) for i in range(len(nb_classes))]
msk_in = [tf.placeholder(dtype=tf.int32, shape=(batch_size, nb_nodes[target_node[i]])) for i in range(len(nb_classes))]
attn_drop = tf.placeholder(dtype=tf.float32, shape=())
ffd_drop = tf.placeholder(dtype=tf.float32, shape=())
is_train = tf.placeholder(dtype=tf.bool, shape=())
logits = model.inference(ftr_in, nb_classes, nb_nodes, is_train,
attn_drop, ffd_drop, target_nodes=target_node,
bias_mat=bias_in, adj_type=adj_type,
edge_list=edge_list,
hid_units=hid_units, n_heads=n_heads,
residual=residual, activation=nonlinearity)
with tf.name_scope('loss_acc'):
loss, accuracy, acc_name, acc_full_name = [], [], [], []
all_class_loss = 0.0
for tn in range(len(target_node)):
tn_logits = logits[tn]
tn_labels = lbl_in[tn]
tn_masks = msk_in[tn]
tn_is_multilabel = is_multilabel[tn]
tn_loss, tn_accuracy, tn_acc_name, tn_acc_full_name = get_loss_acc(tn_logits, tn_labels, tn_masks, is_multilabel=tn_is_multilabel)
loss.append(tn_loss)
accuracy.extend(tn_accuracy)
acc_name.extend(tn_acc_name)
acc_full_name.extend(tn_acc_full_name)
all_class_loss += tn_loss
loss_loop = tf.add_n(tf.get_collection('loss_loop')) * loop_coef
loss_inv= tf.add_n(tf.get_collection('loss_inv')) * inv_coef
train_op = model.training(all_class_loss + loss_loop + loss_inv, lr, l2_coef)
saver = tf.train.Saver()
init_op = tf.group(tf.global_variables_initializer(), tf.local_variables_initializer())
vlss_mn = np.inf
vacc_mx = 0.0
curr_step = 0
with tf.Session(config=config) as sess:
sess.run(init_op)
vacc_early_model = 0.0
vlss_early_model = 0.0
vacc_each_early_model = np.array([0.]*(len(target_node)*metr_num))
for epoch in range(nb_epochs):
# summary information
train_loss_avg = 0
train_acc_avg = 0
val_loss_avg = 0
val_acc_avg = 0
# for each class information
train_loss_each = []
train_acc_each = []
val_loss_each = []
val_acc_each = []
tr_step = 0
tr_size = features[0].shape[0]
while tr_step * batch_size < tr_size:
if sparse:
fd = {i: d for i, d in zip(ftr_in, features)}
fd.update({i: d for i, d in zip(bias_in, biases)})
else:
fd = {i: d[tr_step * batch_size:(tr_step + 1) * batch_size]
for i, d in zip(ftr_in, features)}
fd.update({i: d[tr_step * batch_size:(tr_step + 1) * batch_size]
for i, d in zip(bias_in, biases)})
fd.update({i:d[tr_step*batch_size:(tr_step+1)*batch_size] for i, d in zip(lbl_in, y_train)})
fd.update({i:d[tr_step*batch_size:(tr_step+1)*batch_size] for i, d in zip(msk_in, train_mask)})
fd.update({is_train: True})
fd.update({attn_drop: dropout, ffd_drop:dropout})
_, loss_list_tr, acc_list_tr, loss_loop_tr, loss_inv_tr = sess.run([train_op, loss, accuracy, loss_loop, loss_inv], feed_dict=fd)
train_loss_each.append(np.array(loss_list_tr))
train_acc_each.append(np.array(acc_list_tr))
train_loss_avg += np.sum(np.array(loss_list_tr))
train_acc_avg += np.sum(np.array(acc_list_tr))
tr_step += 1
vl_step = 0
vl_size = features[0].shape[0]
while vl_step * batch_size < vl_size:
if sparse:
fd = {i: d for i, d in zip(ftr_in, features)}
fd.update({i: d for i, d in zip(bias_in, biases)})
else:
fd = {i: d[vl_step * batch_size:(vl_step + 1) * batch_size]
for i, d in zip(ftr_in, features)}
fd.update({i: d[vl_step * batch_size:(vl_step + 1) * batch_size]
for i, d in zip(bias_in, biases)})
fd.update({i:d[vl_step*batch_size:(vl_step+1)*batch_size] for i, d in zip(lbl_in, y_val)})
fd.update({i:d[vl_step*batch_size:(vl_step+1)*batch_size] for i, d in zip(msk_in, val_mask)})
fd.update({is_train: False})
fd.update({attn_drop: 0.0, ffd_drop:0.0})
loss_list_vl, acc_list_vl = sess.run([loss, accuracy], feed_dict=fd)
acc_list_vl = [0. if np.isnan(acc_vl) else acc_vl for acc_vl in acc_list_vl]
val_loss_each.append(np.array(loss_list_vl))
val_acc_each.append(np.array(acc_list_vl))
val_loss_avg += np.sum(np.array(loss_list_vl))
val_acc_avg += np.sum(np.array(acc_list_vl))
vl_step += 1
print('Training %s: loss = %.5f, %s = %.5f, loss_loop = %.5f, loss_inv = %.5f | Val: loss = %.5f, %s = %.5f' %
(epoch, train_loss_avg/tr_step, 'acc/F1', train_acc_avg/tr_step,
loss_loop_tr, loss_inv_tr,
val_loss_avg/vl_step, 'acc/F1', val_acc_avg/vl_step))
print_eachclass_info(train_loss_each, train_acc_each, val_loss_each, val_acc_each, acc_name)
if val_acc_avg/vl_step > vacc_mx or val_loss_avg/vl_step < vlss_mn:
if val_acc_avg/vl_step > vacc_mx and val_loss_avg/vl_step < vlss_mn:
vacc_early_model = val_acc_avg/vl_step
vlss_early_model = val_loss_avg/vl_step
vacc_each_early_model = np.mean(np.array(val_acc_each), axis=0)
saver.save(sess, checkpt_file)
print("saved model as %s"%checkpt_file)
vacc_mx = np.max((val_acc_avg/vl_step, vacc_mx))
vlss_mn = np.min((val_loss_avg/vl_step, vlss_mn))
curr_step = 0
else:
curr_step += 1
if curr_step == patience:
print('Early stop! Min loss: ', vlss_mn,
', Max', 'acc/F1', ': ', vacc_mx)
print('Early stop model validation loss: ', vlss_early_model,
', ', 'acc/F1', ': ', vacc_early_model)
total_vl_acc += vacc_each_early_model
break
if curr_step < patience:
print('Min loss: ', vlss_mn, ', Max', 'acc/F1', ': ', vacc_mx)
print('model validation loss: ', vlss_early_model, ', ', 'acc/F1', ': ', vacc_early_model)
total_vl_acc += vacc_each_early_model
saver.restore(sess, checkpt_file)
ts_size = features[0].shape[0]
ts_step = 0
test_loss_each = []
test_acc_each = []
while ts_step * batch_size < ts_size:
if sparse:
fd = {i: d for i, d in zip(ftr_in, features)}
fd.update({i: d for i, d in zip(bias_in, biases)})
else:
fd = {i: d[ts_step * batch_size:(ts_step + 1) * batch_size]
for i, d in zip(ftr_in, features)}
fd.update({i: d[ts_step * batch_size:(ts_step + 1) * batch_size]
for i, d in zip(bias_in, biases)})
fd.update({i:d[ts_step*batch_size:(ts_step+1)*batch_size] for i, d in zip(lbl_in, y_test)})
fd.update({i:d[ts_step*batch_size:(ts_step+1)*batch_size] for i, d in zip(msk_in, test_mask)})
fd.update({is_train: False})
fd.update({attn_drop: 0.0, ffd_drop:0.0})
loss_list_ts, acc_list_ts = sess.run([loss, accuracy], feed_dict=fd)
test_loss_each.append(np.array(loss_list_ts))
test_acc_each.append(np.array(acc_list_ts))
ts_step += 1
test_loss_each = np.mean(np.array(test_loss_each), axis=0)
test_acc_each = np.mean(np.array(test_acc_each), axis=0)
print('*'*10,'Test information:', '*'*10)
for e in range(len(target_node)):
print('target %s: loss: %.3f, %s:%.5f, %s:%.5f' % (e, test_loss_each[e], acc_full_name[e*metr_num], test_acc_each[e*metr_num], acc_full_name[e*metr_num+1], test_acc_each[e*metr_num+1]))
total_ts_acc += test_acc_each
sess.close()
print('Validation:', total_vl_acc/repeat, 'Test:', total_ts_acc/repeat)
|
[
"tensorflow.local_variables_initializer",
"numpy.random.standard_normal",
"tensorflow.sparse_placeholder",
"utils.process.load_heterogeneous_data",
"numpy.array",
"utils.process.preprocess_features",
"tensorflow.Graph",
"argparse.ArgumentParser",
"tensorflow.placeholder",
"tensorflow.Session",
"os.path.split",
"numpy.max",
"utils.process.preprocess_adj_hete",
"numpy.min",
"tensorflow.ConfigProto",
"numpy.isnan",
"tensorflow.reshape",
"tensorflow.train.Saver",
"random.seed",
"tensorflow.global_variables_initializer",
"tensorflow.name_scope",
"tensorflow.get_collection"
] |
[((184, 209), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (207, 209), False, 'import argparse\n'), ((2336, 2377), 'tensorflow.ConfigProto', 'tf.ConfigProto', ([], {'allow_soft_placement': '(True)'}), '(allow_soft_placement=True)\n', (2350, 2377), True, 'import tensorflow as tf\n'), ((3550, 3567), 'random.seed', 'random.seed', (['seed'], {}), '(seed)\n', (3561, 3567), False, 'import random\n'), ((4509, 4544), 'tensorflow.reshape', 'tf.reshape', (['logits', '[-1, class_num]'], {}), '(logits, [-1, class_num])\n', (4519, 4544), True, 'import tensorflow as tf\n'), ((4560, 4595), 'tensorflow.reshape', 'tf.reshape', (['labels', '[-1, class_num]'], {}), '(labels, [-1, class_num])\n', (4570, 4595), True, 'import tensorflow as tf\n'), ((4611, 4632), 'tensorflow.reshape', 'tf.reshape', (['msk', '[-1]'], {}), '(msk, [-1])\n', (4621, 4632), True, 'import tensorflow as tf\n'), ((6293, 6386), 'utils.process.load_heterogeneous_data', 'process.load_heterogeneous_data', (['dataset'], {'train_rate': 'train_rate', 'target_node': 'target_node'}), '(dataset, train_rate=train_rate, target_node\n =target_node)\n', (6324, 6386), False, 'from utils import process\n'), ((2621, 2648), 'os.path.split', 'os.path.split', (['checkpt_file'], {}), '(checkpt_file)\n', (2634, 2648), False, 'import os\n'), ((5414, 5439), 'numpy.array', 'np.array', (['train_loss_each'], {}), '(train_loss_each)\n', (5422, 5439), True, 'import numpy as np\n'), ((5474, 5498), 'numpy.array', 'np.array', (['train_acc_each'], {}), '(train_acc_each)\n', (5482, 5498), True, 'import numpy as np\n'), ((5533, 5556), 'numpy.array', 'np.array', (['val_loss_each'], {}), '(val_loss_each)\n', (5541, 5556), True, 'import numpy as np\n'), ((5591, 5613), 'numpy.array', 'np.array', (['val_acc_each'], {}), '(val_acc_each)\n', (5599, 5613), True, 'import numpy as np\n'), ((7034, 7078), 'numpy.random.standard_normal', 'np.random.standard_normal', (['features[0].shape'], {}), '(features[0].shape)\n', (7059, 7078), True, 'import numpy as np\n'), ((9690, 9706), 'tensorflow.train.Saver', 'tf.train.Saver', ([], {}), '()\n', (9704, 9706), True, 'import tensorflow as tf\n'), ((6398, 6434), 'utils.process.preprocess_features', 'process.preprocess_features', (['feature'], {}), '(feature)\n', (6425, 6434), False, 'from utils import process\n'), ((7117, 7147), 'utils.process.preprocess_adj_hete', 'process.preprocess_adj_hete', (['a'], {}), '(a)\n', (7144, 7147), False, 'from utils import process\n'), ((7476, 7498), 'tensorflow.name_scope', 'tf.name_scope', (['"""input"""'], {}), "('input')\n", (7489, 7498), True, 'import tensorflow as tf\n'), ((8096, 8138), 'tensorflow.placeholder', 'tf.placeholder', ([], {'dtype': 'tf.float32', 'shape': '()'}), '(dtype=tf.float32, shape=())\n', (8110, 8138), True, 'import tensorflow as tf\n'), ((8162, 8204), 'tensorflow.placeholder', 'tf.placeholder', ([], {'dtype': 'tf.float32', 'shape': '()'}), '(dtype=tf.float32, shape=())\n', (8176, 8204), True, 'import tensorflow as tf\n'), ((8228, 8267), 'tensorflow.placeholder', 'tf.placeholder', ([], {'dtype': 'tf.bool', 'shape': '()'}), '(dtype=tf.bool, shape=())\n', (8242, 8267), True, 'import tensorflow as tf\n'), ((8722, 8747), 'tensorflow.name_scope', 'tf.name_scope', (['"""loss_acc"""'], {}), "('loss_acc')\n", (8735, 8747), True, 'import tensorflow as tf\n'), ((9739, 9772), 'tensorflow.global_variables_initializer', 'tf.global_variables_initializer', ([], {}), '()\n', (9770, 9772), True, 'import tensorflow as tf\n'), ((9774, 9806), 'tensorflow.local_variables_initializer', 'tf.local_variables_initializer', ([], {}), '()\n', (9804, 9806), True, 'import tensorflow as tf\n'), ((9900, 9925), 'tensorflow.Session', 'tf.Session', ([], {'config': 'config'}), '(config=config)\n', (9910, 9925), True, 'import tensorflow as tf\n'), ((7438, 7448), 'tensorflow.Graph', 'tf.Graph', ([], {}), '()\n', (7446, 7448), True, 'import tensorflow as tf\n'), ((7522, 7582), 'tensorflow.placeholder', 'tf.placeholder', ([], {'dtype': 'tf.float32', 'shape': '(batch_size, nb, ft)'}), '(dtype=tf.float32, shape=(batch_size, nb, ft))\n', (7536, 7582), True, 'import tensorflow as tf\n'), ((7815, 7910), 'tensorflow.placeholder', 'tf.placeholder', ([], {'dtype': 'tf.int32', 'shape': '(batch_size, nb_nodes[target_node[i]], nb_classes[i])'}), '(dtype=tf.int32, shape=(batch_size, nb_nodes[target_node[i]],\n nb_classes[i]))\n', (7829, 7910), True, 'import tensorflow as tf\n'), ((7962, 8038), 'tensorflow.placeholder', 'tf.placeholder', ([], {'dtype': 'tf.int32', 'shape': '(batch_size, nb_nodes[target_node[i]])'}), '(dtype=tf.int32, shape=(batch_size, nb_nodes[target_node[i]]))\n', (7976, 8038), True, 'import tensorflow as tf\n'), ((16595, 16619), 'numpy.array', 'np.array', (['test_loss_each'], {}), '(test_loss_each)\n', (16603, 16619), True, 'import numpy as np\n'), ((16665, 16688), 'numpy.array', 'np.array', (['test_acc_each'], {}), '(test_acc_each)\n', (16673, 16688), True, 'import numpy as np\n'), ((7687, 7726), 'tensorflow.sparse_placeholder', 'tf.sparse_placeholder', ([], {'dtype': 'tf.float32'}), '(dtype=tf.float32)\n', (7708, 7726), True, 'import tensorflow as tf\n'), ((9471, 9501), 'tensorflow.get_collection', 'tf.get_collection', (['"""loss_loop"""'], {}), "('loss_loop')\n", (9488, 9501), True, 'import tensorflow as tf\n'), ((9546, 9575), 'tensorflow.get_collection', 'tf.get_collection', (['"""loss_inv"""'], {}), "('loss_inv')\n", (9563, 9575), True, 'import tensorflow as tf\n'), ((14392, 14432), 'numpy.max', 'np.max', (['(val_acc_avg / vl_step, vacc_mx)'], {}), '((val_acc_avg / vl_step, vacc_mx))\n', (14398, 14432), True, 'import numpy as np\n'), ((14461, 14502), 'numpy.min', 'np.min', (['(val_loss_avg / vl_step, vlss_mn)'], {}), '((val_loss_avg / vl_step, vlss_mn))\n', (14467, 14502), True, 'import numpy as np\n'), ((16445, 16467), 'numpy.array', 'np.array', (['loss_list_ts'], {}), '(loss_list_ts)\n', (16453, 16467), True, 'import numpy as np\n'), ((16506, 16527), 'numpy.array', 'np.array', (['acc_list_ts'], {}), '(acc_list_ts)\n', (16514, 16527), True, 'import numpy as np\n'), ((11684, 11706), 'numpy.array', 'np.array', (['loss_list_tr'], {}), '(loss_list_tr)\n', (11692, 11706), True, 'import numpy as np\n'), ((11750, 11771), 'numpy.array', 'np.array', (['acc_list_tr'], {}), '(acc_list_tr)\n', (11758, 11771), True, 'import numpy as np\n'), ((11818, 11840), 'numpy.array', 'np.array', (['loss_list_tr'], {}), '(loss_list_tr)\n', (11826, 11840), True, 'import numpy as np\n'), ((11886, 11907), 'numpy.array', 'np.array', (['acc_list_tr'], {}), '(acc_list_tr)\n', (11894, 11907), True, 'import numpy as np\n'), ((13138, 13160), 'numpy.array', 'np.array', (['loss_list_vl'], {}), '(loss_list_vl)\n', (13146, 13160), True, 'import numpy as np\n'), ((13202, 13223), 'numpy.array', 'np.array', (['acc_list_vl'], {}), '(acc_list_vl)\n', (13210, 13223), True, 'import numpy as np\n'), ((13268, 13290), 'numpy.array', 'np.array', (['loss_list_vl'], {}), '(loss_list_vl)\n', (13276, 13290), True, 'import numpy as np\n'), ((13334, 13355), 'numpy.array', 'np.array', (['acc_list_vl'], {}), '(acc_list_vl)\n', (13342, 13355), True, 'import numpy as np\n'), ((13041, 13057), 'numpy.isnan', 'np.isnan', (['acc_vl'], {}), '(acc_vl)\n', (13049, 13057), True, 'import numpy as np\n'), ((14211, 14233), 'numpy.array', 'np.array', (['val_acc_each'], {}), '(val_acc_each)\n', (14219, 14233), True, 'import numpy as np\n')]
|
import numpy as np
import h5py
import os
import sys
from copy import deepcopy
#handle .(period) and slash specially since it is part of path
#replace with \period or \slash-forward when store, recover later
#not using '\forward-slash' is because \f is a special character
PERIOD='\period'
SLASH='\slash-forward'
'''
This function will save a python dictionary with format {'key':vector} to hdf5 format
target_dict is the target dictionary
f_name is the HDF5 file name including path to it
mode is file open mode, 'a' for append is the default setting
output file is a HDF5 file which the keys of HDF5 are keys of target dict
dataset is corresponding array of each key in target dict
'''
def dict2hdf5(target_dict, f_name, sub_group='/', mode='a'):
print ('Saving In HDF5 Format...')
index_count=0
bar_count=0
total=len(target_dict)
if total<50:
total=50
#open HDF5 file
f = h5py.File(f_name, mode)
for key in target_dict:
######### print progress #############
index_count +=1
if index_count % (total/50) ==0:
sys.stdout.write('\r'),
bar_count += 1
sys.stdout.write("[%-50s] %d%% %d/%d" % ('#'*bar_count, 2*bar_count, index_count, total))
sys.stdout.flush()
######### end print progress #########
#print os.path.join(sub_group,key)
#sys.stdout.flush()
#replace special handled chars, will not change string if / is not in it
dataset_key=key.replace('.',PERIOD).replace('/',SLASH)
f.create_dataset(os.path.join(sub_group,dataset_key), data=target_dict[key])
f.close()
'''
This function will convert saved hdf5 file from previous function back to {'key':vector} dictionary
f_name is the HDF5 file name including path to it
'''
def hdf52dict(f_name, sub_group='/' ):
rv=dict()
#open HDF5 file
f = h5py.File(f_name, 'r')
group=f[sub_group]
for key in group:
#replace back special handled chars
key=key.replace(PERIOD, '.').replace(SLASH,'/')
rv[key]=np.array(group[key])
f.close()
return rv
def main():
d=dict()
d['hello']=[1,0,0,0,0,0,0,0,0,0,0]
d['world']=[0,1,0,0,0,0,0,0,0,0,0]
dict2hdf5(target_dict=d, f_name='test')
rv=hdf52dict('test')
print (rv)
if __name__ == '__main__':
main()
|
[
"os.path.join",
"h5py.File",
"numpy.array",
"sys.stdout.flush",
"sys.stdout.write"
] |
[((892, 915), 'h5py.File', 'h5py.File', (['f_name', 'mode'], {}), '(f_name, mode)\n', (901, 915), False, 'import h5py\n'), ((1759, 1781), 'h5py.File', 'h5py.File', (['f_name', '"""r"""'], {}), "(f_name, 'r')\n", (1768, 1781), False, 'import h5py\n'), ((1923, 1943), 'numpy.array', 'np.array', (['group[key]'], {}), '(group[key])\n', (1931, 1943), True, 'import numpy as np\n'), ((1085, 1182), 'sys.stdout.write', 'sys.stdout.write', (["('[%-50s] %d%% %d/%d' % ('#' * bar_count, 2 * bar_count, index_count, total))"], {}), "('[%-50s] %d%% %d/%d' % ('#' * bar_count, 2 * bar_count,\n index_count, total))\n", (1101, 1182), False, 'import sys\n'), ((1178, 1196), 'sys.stdout.flush', 'sys.stdout.flush', ([], {}), '()\n', (1194, 1196), False, 'import sys\n'), ((1453, 1489), 'os.path.join', 'os.path.join', (['sub_group', 'dataset_key'], {}), '(sub_group, dataset_key)\n', (1465, 1489), False, 'import os\n'), ((1040, 1062), 'sys.stdout.write', 'sys.stdout.write', (["'\\r'"], {}), "('\\r')\n", (1056, 1062), False, 'import sys\n')]
|
# Copyright 2021 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import bigbench.api.model as model
import bigbench.api.util as util
import numpy as np
import scipy.special
class DummyModel(model.Model):
def generate_text(
self, inputs, max_length=100, stop_string=None, output_regex=None
):
dummy_text = "dummy text, 123. Easy peasy lemon squeezy."
if isinstance(inputs, str):
text = dummy_text
elif isinstance(inputs, list):
text = [f"{i}_{dummy_text}" for i, _ in enumerate(inputs)]
else:
raise ValueError("inputs has unexpected type %s" % type(inputs))
text = util.postprocess_output(text, max_length, stop_string, output_regex)
return text
def cond_log_prob(self, inputs, targets, absolute_normalization=False):
def generate_dummy_scores(inpt, tgts):
unnorm_log_probs = [np.log(1 / (i + 1)) for i, _ in enumerate(tgts)]
if len(unnorm_log_probs) > 1:
# we want to make sure tasks can correctly handle responses which are
# assigned zero probability
unnorm_log_probs[0] = -np.inf
if absolute_normalization:
log_probs = unnorm_log_probs
else:
log_normalizer = scipy.special.logsumexp(unnorm_log_probs)
log_probs = [lp - log_normalizer for lp in unnorm_log_probs]
return log_probs
if isinstance(inputs, str):
return generate_dummy_scores(inputs, targets)
elif isinstance(inputs, list):
return [
generate_dummy_scores(inpt, tgts) for inpt, tgts in zip(inputs, targets)
]
else:
raise ValueError("inputs has unexpected type %s" % type(inputs))
|
[
"bigbench.api.util.postprocess_output",
"numpy.log"
] |
[((1171, 1239), 'bigbench.api.util.postprocess_output', 'util.postprocess_output', (['text', 'max_length', 'stop_string', 'output_regex'], {}), '(text, max_length, stop_string, output_regex)\n', (1194, 1239), True, 'import bigbench.api.util as util\n'), ((1417, 1436), 'numpy.log', 'np.log', (['(1 / (i + 1))'], {}), '(1 / (i + 1))\n', (1423, 1436), True, 'import numpy as np\n')]
|
import pybullet_data
import pybullet as p
import time
import numpy as np
from src.utils_geom import *
from src.utils_depth import *
from src.panda import Panda
def full_jacob_pb(jac_t, jac_r):
return np.vstack((jac_t[0], jac_t[1], jac_t[2], jac_r[0], jac_r[1], jac_r[2]))
class pandaEnv():
def __init__(self,
urdfRoot=pybullet_data.getDataPath(),
mu=0.3,
sigma=0.01,
timestep=1./240.,
long_finger=False,
):
self._urdfRoot = urdfRoot
self._timeStep = timestep
self._pandaId = None
self._planeId = None
self._tableId = None
self._mu = mu
self._sigma = sigma
self.long_finger = long_finger
def reset_env(self):
p.resetSimulation()
p.setPhysicsEngineParameter(numSolverIterations=150,
enableConeFriction=1,
contactBreakingThreshold=1e-3)
p.setTimeStep(self._timeStep)
# Set gravity
p.setGravity(0, 0, -9.81)
# Load plane and table
self._planeId = p.loadURDF(self._urdfRoot+'/plane.urdf', basePosition=[0, 0, -1], useFixedBase=1)
self._tableId = p.loadURDF(self._urdfRoot+'/table/table.urdf', basePosition=[0.4000000, 0.00000, -0.63+0.005], baseOrientation=[0, 0, 0, 1.0], useFixedBase=1)
# Load arm, no need to settle (joint angle set instantly)
self._panda = Panda(self.long_finger)
self._pandaId = self._panda.load()
# Set friction coefficients of arm and table
self.change_friction_coeffs(self._mu, self._sigma)
# Create a constraint to keep the fingers centered (upper links)
fingerGear = p.createConstraint(self._pandaId,
9,
self._pandaId,
11,
jointType=p.JOINT_GEAR,
jointAxis=[1, 0, 0],
parentFramePosition=[0, 0, 0],
childFramePosition=[0, 0, 0])
p.changeConstraint(fingerGear, gearRatio=-1, erp=0.1, maxForce=2*self._panda.maxFingerForce)
# Disable damping for all links
for i in range(self._panda.numJoints):
p.changeDynamics(self._pandaId, i,
linearDamping=0,
angularDamping=0)
def change_friction_coeffs(self, mu, sigma):
p.changeDynamics(self._pandaId, self._panda.pandaLeftFingerLinkIndex, lateralFriction=mu,
spinningFriction=sigma,
frictionAnchor=1,
)
p.changeDynamics(self._pandaId, self._panda.pandaRightFingerLinkIndex, lateralFriction=mu,
spinningFriction=sigma,
frictionAnchor=1,
)
p.changeDynamics(self._tableId, -1,
lateralFriction=mu,
spinningFriction=sigma,
frictionAnchor=1,
)
def reset_arm_joints_ik(self, pos, orn, fingerPos=0.0):
jointPoses = list(p.calculateInverseKinematics(self._pandaId,
self._panda.pandaEndEffectorLinkIndex,
pos, orn,
jointDamping=self._panda.jd,
lowerLimits=self._panda.jointLowerLimit,
upperLimits=self._panda.jointUpperLimit,
jointRanges=self._panda.jointRange,
restPoses=self._panda.jointRestPose,
residualThreshold=1e-4))
# , maxNumIterations=1e5))
jointPoses = jointPoses[:7] + [0, -np.pi/4, fingerPos, 0.00, fingerPos, 0.00]
self._panda.reset(jointPoses)
def reset_arm_joints(self, joints):
jointPoses = joints + [0, -np.pi/4, self._panda.fingerOpenPos,
0.00, self._panda.fingerOpenPos, 0.00]
self._panda.reset(jointPoses)
########################* Arm control *#######################
def move_pos(self, absolute_pos=None,
relative_pos=None,
absolute_global_euler=None, # preferred
relative_global_euler=None, # preferred
relative_local_euler=None, # not using
absolute_global_quat=None, # preferred
relative_azi=None, # for arm
# relative_quat=None, # never use relative quat
numSteps=50,
maxJointVel=0.20,
relativePos=True,
globalOrn=True,
checkContact=False,
checkPalmContact=False,
objId=None,
gripper_target_pos=None,
timeStep=0):
# Get trajectory
eePosNow, eeQuatNow = self._panda.get_ee()
# Determine target pos
if absolute_pos is not None:
targetPos = absolute_pos
elif relative_pos is not None:
targetPos = eePosNow + relative_pos
else:
targetPos = eePosNow
# Determine target orn
if absolute_global_euler is not None:
targetOrn = euler2quat(absolute_global_euler)
elif relative_global_euler is not None:
targetOrn = quatMult(euler2quat(relative_global_euler), eeQuatNow)
elif relative_local_euler is not None:
targetOrn = quatMult(eeQuatNow, euler2quat(relative_local_euler))
elif absolute_global_quat is not None:
targetOrn = absolute_global_quat
elif relative_azi is not None:
# Extrinsic yaw
targetOrn = quatMult(euler2quat([relative_azi[0],0,0]), eeQuatNow)
# Intrinsic pitch
targetOrn = quatMult(targetOrn, euler2quat([0,relative_azi[1],0]))
# elif relative_quat is not None:
# targetOrn = quatMult(eeQuatNow, relative_quat)
else:
targetOrn = array([1.0, 0., 0., 0.])
# Get trajectory
trajPos = self.traj_time_scaling(startPos=eePosNow,
endPos=targetPos,
numSteps=numSteps)
# Run steps
numSteps = len(trajPos)
for step in range(numSteps):
# Get joint velocities from error tracking control
jointDot = self.traj_tracking_vel(targetPos=trajPos[step], targetQuat=targetOrn)
# Send velocity commands to joints
for i in range(self._panda.numJointsArm):
p.setJointMotorControl2(self._pandaId,
i,
p.VELOCITY_CONTROL,
targetVelocity=jointDot[i],
force=self._panda.maxJointForce[i],
maxVelocity=maxJointVel)
if gripper_target_pos is None:
# Keep gripper current velocity
p.setJointMotorControl2(self._pandaId,
self._panda.pandaLeftFingerJointIndex,
p.VELOCITY_CONTROL,
targetVelocity=self._panda.fingerCurVel,
force=self._panda.maxJointForce[i],
maxVelocity=0.04)
p.setJointMotorControl2(self._pandaId,
self._panda.pandaRightFingerJointIndex,
p.VELOCITY_CONTROL,
targetVelocity=self._panda.fingerCurVel,
force=self._panda.maxJointForce[i],
maxVelocity=0.04)
else:
p.setJointMotorControl2(self._pandaId,
self._panda.pandaLeftFingerJointIndex,
p.POSITION_CONTROL,
targetPosition=gripper_target_pos,
maxVelocity=0.04)
p.setJointMotorControl2(self._pandaId,
self._panda.pandaRightFingerJointIndex,
p.POSITION_CONTROL,
targetPosition=gripper_target_pos,
maxVelocity=0.04)
# Quit if contact at either finger or palm
if checkContact:
contact = self.check_contact(objId, both=False)
if contact:
return timeStep, False
if checkPalmContact:
contact = self.check_palm_contact(objId)
if contact:
return timeStep, False
# Step simulation
p.stepSimulation()
timeStep += 1
return timeStep, True
def grasp(self, targetVel=0):
# Change gripper velocity direction
if targetVel > 1e-2 or targetVel < -1e-2: # Use specified velocity if available
self._panda.fingerCurVel = targetVel
else:
if self._panda.fingerCurVel > 0.0:
self._panda.fingerCurVel = -0.05
else:
self._panda.fingerCurVel = 0.05
return
def traj_time_scaling(self, startPos, endPos, numSteps):
trajPos = np.zeros((numSteps, 3))
for step in range(numSteps):
s = 3 * (1.0 * step / numSteps) ** 2 - 2 * (1.0 * step / numSteps) ** 3
trajPos[step] = (endPos-startPos)*s+startPos
return trajPos
def traj_tracking_vel(self, targetPos, targetQuat, posGain=20, velGain=5):
eePos, eeQuat = self._panda.get_ee()
eePosError = targetPos - eePos
eeOrnError = log_rot(quat2rot(targetQuat).dot((quat2rot(eeQuat).T))) # in spatial frame
jointPoses = self._panda.get_arm_joints() + [0,0,0] # add fingers
eeState = p.getLinkState(self._pandaId,
self._panda.pandaEndEffectorLinkIndex,
computeLinkVelocity=1,
computeForwardKinematics=1)
# Get the Jacobians for the CoM of the end-effector link. Note that in this example com_rot = identity, and we would need to use com_rot.T * com_trn. The localPosition is always defined in terms of the link frame coordinates.
zero_vec = [0.0] * len(jointPoses)
jac_t, jac_r = p.calculateJacobian(self._pandaId,
self._panda.pandaEndEffectorLinkIndex,
eeState[2],
jointPoses,
zero_vec,
zero_vec) # use localInertialFrameOrientation
jac_sp = full_jacob_pb(jac_t, jac_r)[:, :7] # 6x10 -> 6x7, ignore last three columns
try:
jointDot = np.linalg.pinv(jac_sp).dot((np.hstack((posGain*eePosError, velGain*eeOrnError)).reshape(6,1))) # pseudo-inverse
except np.linalg.LinAlgError:
jointDot = np.zeros((7,1))
return jointDot
############################### Contact ##################################
def get_contact(self, objId, minForceThres=1e-1):
left_contacts = p.getContactPoints(self._pandaId,
objId,
linkIndexA=self._panda.pandaLeftFingerLinkIndex,
linkIndexB=-1)
right_contacts = p.getContactPoints(self._pandaId,
objId,
linkIndexA=self._panda.pandaRightFingerLinkIndex,
linkIndexB=-1)
left_contacts = [i for i in left_contacts if i[9] > minForceThres]
right_contacts = [i for i in right_contacts if i[9] > minForceThres]
return left_contacts, right_contacts
def get_finger_force(self, objId):
left_contacts, right_contacts = self.get_contact(objId)
left_force = np.zeros((3))
right_force = np.zeros((3))
for i in left_contacts:
left_force += i[9]*np.array(i[7])+i[10]*np.array(i[11])+i[12]*np.array(i[13])
for i in right_contacts:
right_force += i[9]*np.array(i[7])+i[10]*np.array(i[11])+i[12]*np.array(i[13])
leftNormalMag = sum([i[9] for i in left_contacts])
rightNormalMag = sum([i[9] for i in right_contacts])
numLeftContact = len(left_contacts)
numRightContact = len(right_contacts)
if numLeftContact < 1 or numRightContact < 1:
return None
else:
return left_force, right_force, \
np.array(left_contacts[0][6]), np.array(right_contacts[0][6]), \
leftNormalMag, rightNormalMag
def check_hold_object(self, objId, minForceThres=10.0):
left_contacts, right_contacts = self.get_contact(objId)
leftNormalMag = sum([i[9] for i in left_contacts])
rightNormalMag = sum([i[9] for i in right_contacts])
return leftNormalMag > minForceThres and rightNormalMag > minForceThres
def check_contact(self, objId, both=False):
leftContacts, rightContacts = self.get_contact(objId)
if both:
if len(leftContacts) > 0 and len(rightContacts) > 0:
return 1
else:
if len(leftContacts) > 0 or len(rightContacts) > 0:
return 1
return 0
def check_palm_contact(self, objId, minForceThres=1e-1):
palm_contacts = p.getContactPoints(self._pandaId,
objId,
linkIndexA=self._panda.pandaHandLinkIndex,
linkIndexB=-1)
palm_contacts = [i for i in palm_contacts if i[9] > minForceThres]
return len(palm_contacts) > 0
############################### Info ##################################
def get_ee(self):
return self._panda.get_ee()
def get_gripper_tip_long(self):
return self._panda.get_gripper_tip_long()
def get_arm_joints(self):
return self._panda.get_arm_joints()
def get_gripper_joint(self):
return self._panda.get_gripper_joint()
def get_left_finger(self):
return self._panda.get_left_finger()
def get_right_finger(self):
return self._panda.get_right_finger()
def get_obs(self):
return self._panda.get_obs()
|
[
"pybullet_data.getDataPath",
"numpy.linalg.pinv",
"numpy.hstack",
"pybullet.setTimeStep",
"pybullet.setGravity",
"numpy.array",
"pybullet.setPhysicsEngineParameter",
"src.panda.Panda",
"pybullet.calculateJacobian",
"pybullet.createConstraint",
"numpy.vstack",
"pybullet.changeConstraint",
"pybullet.resetSimulation",
"pybullet.changeDynamics",
"pybullet.loadURDF",
"pybullet.getLinkState",
"pybullet.getContactPoints",
"pybullet.calculateInverseKinematics",
"numpy.zeros",
"pybullet.stepSimulation",
"pybullet.setJointMotorControl2"
] |
[((207, 278), 'numpy.vstack', 'np.vstack', (['(jac_t[0], jac_t[1], jac_t[2], jac_r[0], jac_r[1], jac_r[2])'], {}), '((jac_t[0], jac_t[1], jac_t[2], jac_r[0], jac_r[1], jac_r[2]))\n', (216, 278), True, 'import numpy as np\n'), ((333, 360), 'pybullet_data.getDataPath', 'pybullet_data.getDataPath', ([], {}), '()\n', (358, 360), False, 'import pybullet_data\n'), ((675, 694), 'pybullet.resetSimulation', 'p.resetSimulation', ([], {}), '()\n', (692, 694), True, 'import pybullet as p\n'), ((697, 807), 'pybullet.setPhysicsEngineParameter', 'p.setPhysicsEngineParameter', ([], {'numSolverIterations': '(150)', 'enableConeFriction': '(1)', 'contactBreakingThreshold': '(0.001)'}), '(numSolverIterations=150, enableConeFriction=1,\n contactBreakingThreshold=0.001)\n', (724, 807), True, 'import pybullet as p\n'), ((827, 856), 'pybullet.setTimeStep', 'p.setTimeStep', (['self._timeStep'], {}), '(self._timeStep)\n', (840, 856), True, 'import pybullet as p\n'), ((876, 901), 'pybullet.setGravity', 'p.setGravity', (['(0)', '(0)', '(-9.81)'], {}), '(0, 0, -9.81)\n', (888, 901), True, 'import pybullet as p\n'), ((946, 1033), 'pybullet.loadURDF', 'p.loadURDF', (["(self._urdfRoot + '/plane.urdf')"], {'basePosition': '[0, 0, -1]', 'useFixedBase': '(1)'}), "(self._urdfRoot + '/plane.urdf', basePosition=[0, 0, -1],\n useFixedBase=1)\n", (956, 1033), True, 'import pybullet as p\n'), ((1046, 1187), 'pybullet.loadURDF', 'p.loadURDF', (["(self._urdfRoot + '/table/table.urdf')"], {'basePosition': '[0.4, 0.0, -0.63 + 0.005]', 'baseOrientation': '[0, 0, 0, 1.0]', 'useFixedBase': '(1)'}), "(self._urdfRoot + '/table/table.urdf', basePosition=[0.4, 0.0, -\n 0.63 + 0.005], baseOrientation=[0, 0, 0, 1.0], useFixedBase=1)\n", (1056, 1187), True, 'import pybullet as p\n'), ((1266, 1289), 'src.panda.Panda', 'Panda', (['self.long_finger'], {}), '(self.long_finger)\n', (1271, 1289), False, 'from src.panda import Panda\n'), ((1511, 1681), 'pybullet.createConstraint', 'p.createConstraint', (['self._pandaId', '(9)', 'self._pandaId', '(11)'], {'jointType': 'p.JOINT_GEAR', 'jointAxis': '[1, 0, 0]', 'parentFramePosition': '[0, 0, 0]', 'childFramePosition': '[0, 0, 0]'}), '(self._pandaId, 9, self._pandaId, 11, jointType=p.\n JOINT_GEAR, jointAxis=[1, 0, 0], parentFramePosition=[0, 0, 0],\n childFramePosition=[0, 0, 0])\n', (1529, 1681), True, 'import pybullet as p\n'), ((1717, 1816), 'pybullet.changeConstraint', 'p.changeConstraint', (['fingerGear'], {'gearRatio': '(-1)', 'erp': '(0.1)', 'maxForce': '(2 * self._panda.maxFingerForce)'}), '(fingerGear, gearRatio=-1, erp=0.1, maxForce=2 * self.\n _panda.maxFingerForce)\n', (1735, 1816), True, 'import pybullet as p\n'), ((2033, 2168), 'pybullet.changeDynamics', 'p.changeDynamics', (['self._pandaId', 'self._panda.pandaLeftFingerLinkIndex'], {'lateralFriction': 'mu', 'spinningFriction': 'sigma', 'frictionAnchor': '(1)'}), '(self._pandaId, self._panda.pandaLeftFingerLinkIndex,\n lateralFriction=mu, spinningFriction=sigma, frictionAnchor=1)\n', (2049, 2168), True, 'import pybullet as p\n'), ((2178, 2314), 'pybullet.changeDynamics', 'p.changeDynamics', (['self._pandaId', 'self._panda.pandaRightFingerLinkIndex'], {'lateralFriction': 'mu', 'spinningFriction': 'sigma', 'frictionAnchor': '(1)'}), '(self._pandaId, self._panda.pandaRightFingerLinkIndex,\n lateralFriction=mu, spinningFriction=sigma, frictionAnchor=1)\n', (2194, 2314), True, 'import pybullet as p\n'), ((2325, 2427), 'pybullet.changeDynamics', 'p.changeDynamics', (['self._tableId', '(-1)'], {'lateralFriction': 'mu', 'spinningFriction': 'sigma', 'frictionAnchor': '(1)'}), '(self._tableId, -1, lateralFriction=mu, spinningFriction=\n sigma, frictionAnchor=1)\n', (2341, 2427), True, 'import pybullet as p\n'), ((7318, 7341), 'numpy.zeros', 'np.zeros', (['(numSteps, 3)'], {}), '((numSteps, 3))\n', (7326, 7341), True, 'import numpy as np\n'), ((7837, 7960), 'pybullet.getLinkState', 'p.getLinkState', (['self._pandaId', 'self._panda.pandaEndEffectorLinkIndex'], {'computeLinkVelocity': '(1)', 'computeForwardKinematics': '(1)'}), '(self._pandaId, self._panda.pandaEndEffectorLinkIndex,\n computeLinkVelocity=1, computeForwardKinematics=1)\n', (7851, 7960), True, 'import pybullet as p\n'), ((8260, 8381), 'pybullet.calculateJacobian', 'p.calculateJacobian', (['self._pandaId', 'self._panda.pandaEndEffectorLinkIndex', 'eeState[2]', 'jointPoses', 'zero_vec', 'zero_vec'], {}), '(self._pandaId, self._panda.pandaEndEffectorLinkIndex,\n eeState[2], jointPoses, zero_vec, zero_vec)\n', (8279, 8381), True, 'import pybullet as p\n'), ((8933, 9042), 'pybullet.getContactPoints', 'p.getContactPoints', (['self._pandaId', 'objId'], {'linkIndexA': 'self._panda.pandaLeftFingerLinkIndex', 'linkIndexB': '(-1)'}), '(self._pandaId, objId, linkIndexA=self._panda.\n pandaLeftFingerLinkIndex, linkIndexB=-1)\n', (8951, 9042), True, 'import pybullet as p\n'), ((9081, 9191), 'pybullet.getContactPoints', 'p.getContactPoints', (['self._pandaId', 'objId'], {'linkIndexA': 'self._panda.pandaRightFingerLinkIndex', 'linkIndexB': '(-1)'}), '(self._pandaId, objId, linkIndexA=self._panda.\n pandaRightFingerLinkIndex, linkIndexB=-1)\n', (9099, 9191), True, 'import pybullet as p\n'), ((9503, 9514), 'numpy.zeros', 'np.zeros', (['(3)'], {}), '(3)\n', (9511, 9514), True, 'import numpy as np\n'), ((9533, 9544), 'numpy.zeros', 'np.zeros', (['(3)'], {}), '(3)\n', (9541, 9544), True, 'import numpy as np\n'), ((10813, 10916), 'pybullet.getContactPoints', 'p.getContactPoints', (['self._pandaId', 'objId'], {'linkIndexA': 'self._panda.pandaHandLinkIndex', 'linkIndexB': '(-1)'}), '(self._pandaId, objId, linkIndexA=self._panda.\n pandaHandLinkIndex, linkIndexB=-1)\n', (10831, 10916), True, 'import pybullet as p\n'), ((1895, 1964), 'pybullet.changeDynamics', 'p.changeDynamics', (['self._pandaId', 'i'], {'linearDamping': '(0)', 'angularDamping': '(0)'}), '(self._pandaId, i, linearDamping=0, angularDamping=0)\n', (1911, 1964), True, 'import pybullet as p\n'), ((2517, 2838), 'pybullet.calculateInverseKinematics', 'p.calculateInverseKinematics', (['self._pandaId', 'self._panda.pandaEndEffectorLinkIndex', 'pos', 'orn'], {'jointDamping': 'self._panda.jd', 'lowerLimits': 'self._panda.jointLowerLimit', 'upperLimits': 'self._panda.jointUpperLimit', 'jointRanges': 'self._panda.jointRange', 'restPoses': 'self._panda.jointRestPose', 'residualThreshold': '(0.0001)'}), '(self._pandaId, self._panda.\n pandaEndEffectorLinkIndex, pos, orn, jointDamping=self._panda.jd,\n lowerLimits=self._panda.jointLowerLimit, upperLimits=self._panda.\n jointUpperLimit, jointRanges=self._panda.jointRange, restPoses=self.\n _panda.jointRestPose, residualThreshold=0.0001)\n', (2545, 2838), True, 'import pybullet as p\n'), ((6855, 6873), 'pybullet.stepSimulation', 'p.stepSimulation', ([], {}), '()\n', (6871, 6873), True, 'import pybullet as p\n'), ((5360, 5518), 'pybullet.setJointMotorControl2', 'p.setJointMotorControl2', (['self._pandaId', 'i', 'p.VELOCITY_CONTROL'], {'targetVelocity': 'jointDot[i]', 'force': 'self._panda.maxJointForce[i]', 'maxVelocity': 'maxJointVel'}), '(self._pandaId, i, p.VELOCITY_CONTROL,\n targetVelocity=jointDot[i], force=self._panda.maxJointForce[i],\n maxVelocity=maxJointVel)\n', (5383, 5518), True, 'import pybullet as p\n'), ((5639, 5841), 'pybullet.setJointMotorControl2', 'p.setJointMotorControl2', (['self._pandaId', 'self._panda.pandaLeftFingerJointIndex', 'p.VELOCITY_CONTROL'], {'targetVelocity': 'self._panda.fingerCurVel', 'force': 'self._panda.maxJointForce[i]', 'maxVelocity': '(0.04)'}), '(self._pandaId, self._panda.\n pandaLeftFingerJointIndex, p.VELOCITY_CONTROL, targetVelocity=self.\n _panda.fingerCurVel, force=self._panda.maxJointForce[i], maxVelocity=0.04)\n', (5662, 5841), True, 'import pybullet as p\n'), ((5891, 6094), 'pybullet.setJointMotorControl2', 'p.setJointMotorControl2', (['self._pandaId', 'self._panda.pandaRightFingerJointIndex', 'p.VELOCITY_CONTROL'], {'targetVelocity': 'self._panda.fingerCurVel', 'force': 'self._panda.maxJointForce[i]', 'maxVelocity': '(0.04)'}), '(self._pandaId, self._panda.\n pandaRightFingerJointIndex, p.VELOCITY_CONTROL, targetVelocity=self.\n _panda.fingerCurVel, force=self._panda.maxJointForce[i], maxVelocity=0.04)\n', (5914, 6094), True, 'import pybullet as p\n'), ((6153, 6313), 'pybullet.setJointMotorControl2', 'p.setJointMotorControl2', (['self._pandaId', 'self._panda.pandaLeftFingerJointIndex', 'p.POSITION_CONTROL'], {'targetPosition': 'gripper_target_pos', 'maxVelocity': '(0.04)'}), '(self._pandaId, self._panda.\n pandaLeftFingerJointIndex, p.POSITION_CONTROL, targetPosition=\n gripper_target_pos, maxVelocity=0.04)\n', (6176, 6313), True, 'import pybullet as p\n'), ((6352, 6513), 'pybullet.setJointMotorControl2', 'p.setJointMotorControl2', (['self._pandaId', 'self._panda.pandaRightFingerJointIndex', 'p.POSITION_CONTROL'], {'targetPosition': 'gripper_target_pos', 'maxVelocity': '(0.04)'}), '(self._pandaId, self._panda.\n pandaRightFingerJointIndex, p.POSITION_CONTROL, targetPosition=\n gripper_target_pos, maxVelocity=0.04)\n', (6375, 6513), True, 'import pybullet as p\n'), ((8747, 8763), 'numpy.zeros', 'np.zeros', (['(7, 1)'], {}), '((7, 1))\n', (8755, 8763), True, 'import numpy as np\n'), ((10064, 10093), 'numpy.array', 'np.array', (['left_contacts[0][6]'], {}), '(left_contacts[0][6])\n', (10072, 10093), True, 'import numpy as np\n'), ((10095, 10125), 'numpy.array', 'np.array', (['right_contacts[0][6]'], {}), '(right_contacts[0][6])\n', (10103, 10125), True, 'import numpy as np\n'), ((8588, 8610), 'numpy.linalg.pinv', 'np.linalg.pinv', (['jac_sp'], {}), '(jac_sp)\n', (8602, 8610), True, 'import numpy as np\n'), ((9639, 9654), 'numpy.array', 'np.array', (['i[13]'], {}), '(i[13])\n', (9647, 9654), True, 'import numpy as np\n'), ((9748, 9763), 'numpy.array', 'np.array', (['i[13]'], {}), '(i[13])\n', (9756, 9763), True, 'import numpy as np\n'), ((8616, 8671), 'numpy.hstack', 'np.hstack', (['(posGain * eePosError, velGain * eeOrnError)'], {}), '((posGain * eePosError, velGain * eeOrnError))\n', (8625, 8671), True, 'import numpy as np\n'), ((9596, 9610), 'numpy.array', 'np.array', (['i[7]'], {}), '(i[7])\n', (9604, 9610), True, 'import numpy as np\n'), ((9617, 9632), 'numpy.array', 'np.array', (['i[11]'], {}), '(i[11])\n', (9625, 9632), True, 'import numpy as np\n'), ((9705, 9719), 'numpy.array', 'np.array', (['i[7]'], {}), '(i[7])\n', (9713, 9719), True, 'import numpy as np\n'), ((9726, 9741), 'numpy.array', 'np.array', (['i[11]'], {}), '(i[11])\n', (9734, 9741), True, 'import numpy as np\n')]
|
import numpy as np
import pandas as pd
from pathlib import Path
import multiprocessing as mp
from functools import partial
from src.audio import read_as_melspectrogram
from src.utils import get_params_hash
from src import config
NOISE_SOUNDS = [
'Buzz',
'Car_passing_by',
'Crackle',
'Cricket',
'Hiss',
'Mechanical_fan',
'Stream',
'Traffic_noise_and_roadway_noise',
'Walk_and_footsteps',
'Waves_and_surf',
'Crowd',
'Run',
'Female_speech_and_woman_speaking',
'Male_speech_and_man_speaking',
'Raindrop',
'Sink_(filling_or_washing)',
'Gurgling',
'Frying_(food)',
]
def check_noise(labels):
noise = True
for label in labels.split(','):
if label not in NOISE_SOUNDS:
noise = False
break
return noise
def make_spectrogram_and_save(file_path: Path, save_dir: Path, audio_params):
spec = read_as_melspectrogram(file_path, audio_params)
if spec.shape[1] >= 320:
save_dir.mkdir(parents=True, exist_ok=True)
save_path = save_dir / (file_path.name + '.npy')
np.save(save_path, spec)
def prepare_freesound_data(dir_path, audio_params):
dir_path = Path(dir_path)
file_path_lst = []
train_df = pd.read_csv(config.freesound_train_curated_csv_path)
for i, row in train_df.iterrows():
if check_noise(row.labels):
file_path = config.freesound_train_curated_dir / row.fname
file_path_lst.append(file_path)
train_df = pd.read_csv(config.freesound_train_noisy_csv_path)
for i, row in train_df.iterrows():
if check_noise(row.labels):
file_path = config.freesound_train_noisy_dir / row.fname
file_path_lst.append(file_path)
func = partial(make_spectrogram_and_save,
save_dir=dir_path, audio_params=audio_params)
with mp.Pool(mp.cpu_count()) as pool:
pool.map(func, file_path_lst)
def check_prepared_freesound_data(audio_params):
params_hash = get_params_hash({**audio_params.dict(),
'noise_sounds': NOISE_SOUNDS})
prepared_train_dir = config.freesound_prepared_train_curated_dir / params_hash
if not prepared_train_dir.exists():
print(f"Start preparing freesound dataset to '{prepared_train_dir}'")
prepare_freesound_data(prepared_train_dir, audio_params)
print(f"Dataset prepared.")
else:
print(f"'{prepared_train_dir}' already exists.")
def get_freesound_folds_data(audio_params):
params_hash = get_params_hash({**audio_params.dict(),
'noise_sounds': NOISE_SOUNDS})
prepared_train_dir = config.freesound_prepared_train_curated_dir / params_hash
folds_data = []
audio_paths = sorted(prepared_train_dir.glob("*.npy"))
for i, spec_path in enumerate(audio_paths):
sample = {
'ebird_code': 'nocall',
'spec_path': spec_path,
'fold': config.n_folds
}
folds_data.append(sample)
return folds_data
if __name__ == "__main__":
check_prepared_freesound_data(audio_params=config.audio)
|
[
"pandas.read_csv",
"pathlib.Path",
"src.audio.read_as_melspectrogram",
"multiprocessing.cpu_count",
"functools.partial",
"numpy.save"
] |
[((906, 953), 'src.audio.read_as_melspectrogram', 'read_as_melspectrogram', (['file_path', 'audio_params'], {}), '(file_path, audio_params)\n', (928, 953), False, 'from src.audio import read_as_melspectrogram\n'), ((1194, 1208), 'pathlib.Path', 'Path', (['dir_path'], {}), '(dir_path)\n', (1198, 1208), False, 'from pathlib import Path\n'), ((1247, 1299), 'pandas.read_csv', 'pd.read_csv', (['config.freesound_train_curated_csv_path'], {}), '(config.freesound_train_curated_csv_path)\n', (1258, 1299), True, 'import pandas as pd\n'), ((1518, 1568), 'pandas.read_csv', 'pd.read_csv', (['config.freesound_train_noisy_csv_path'], {}), '(config.freesound_train_noisy_csv_path)\n', (1529, 1568), True, 'import pandas as pd\n'), ((1769, 1854), 'functools.partial', 'partial', (['make_spectrogram_and_save'], {'save_dir': 'dir_path', 'audio_params': 'audio_params'}), '(make_spectrogram_and_save, save_dir=dir_path, audio_params=audio_params\n )\n', (1776, 1854), False, 'from functools import partial\n'), ((1100, 1124), 'numpy.save', 'np.save', (['save_path', 'spec'], {}), '(save_path, spec)\n', (1107, 1124), True, 'import numpy as np\n'), ((1887, 1901), 'multiprocessing.cpu_count', 'mp.cpu_count', ([], {}), '()\n', (1899, 1901), True, 'import multiprocessing as mp\n')]
|
import numpy as np
import pandas as pd
from sklearn.externals import joblib
#from sklearn.ensemble import RandomForestRegressor
#from sklearn.multioutput import MultiOutputRegressor
#from sklearn.multioutput import MultiOutputRegressor
from sklearn.model_selection import train_test_split
df = pd.read_csv('https://drive.google.com/uc?export=download&id=1XoV8SfvHmzaxRuDRe81OWSQu10dYTbO5',sep=',')
df_X = df.iloc[:, 2:13].copy()
df_X = pd.get_dummies(df_X)
df_y1 = df.iloc[:, 13:16].copy()
df_y1 = pd.get_dummies(df_y1)
df_y2 = df.iloc[:, 16:20].copy()
df_y2 = pd.get_dummies(df_y2)
#X_train, df_X, y_train, df_y1 = train_test_split(df_X, df_y1, test_size=0.2, random_state=0)
def accuracy(model, X_test, y_test):
predictions = model.predict(X_test)
print(model.score(X_test, y_test))
errors = np.abs(predictions - y_test)
mape = 100 * (errors / y_test)
for col in mape:
accuracy = 100 - np.mean(mape[col])
print('Accuracy:', round(accuracy, 2), '%.')
def test(model, df_X, df_y1, num):
accuracy(model, df_X, df_y1)
predictions = pd.DataFrame(model.predict(df_X))
errors = np.abs(predictions - df_y1)
print(type(predictions))
print(type(errors))
for i in range(num):
#results = df_X.iloc[:, 0:10].values
#results = np.append(results, df_y1.ix[:, i])
#results = np.append(results, predictions[:, i])
#results = np.append(results, errors.ix[:, i])
#result_df = pd.DataFrame(results)
df_X.join(df_y1.ix[:, i]).join(predictions.ix[:, i]).to_csv("ModelPredictions" + str(num) + str(i) + ".csv")
#model = RandomForestRegressor(n_estimators = 1900, max_depth = 70, random_state = 50, learning_rate = 0.1, min_samples_split = 0.1, max_features = 'sqrt', loss = 'lad', warm_start = True, min_samples_leaf = 0.0005)
#model1 = MultipleOutputRegressor(model)
#model2 = MultipleOutputRegressor(model, n_jobs = -1)
#model1.fit(X_train, y_train)
model = joblib.load("RegressorChainGradientBoostingRegressorEarningsNew.pkl")
test(model, df_X, df_y1, 3)
model = joblib.load("RegressorChainGradientBoostingRegressorRepaymentNew.pkl")
test(model, df_X, df_y2, 4)
#model2.fit(X_train, y_train)
#joblib.dump(model2, "MultiplepleOutputRandomForestRegressorEarnings.pkl")
#print("Model 2: ");
#accuracy(model2, df_X, df_y1)
#X_train, df_X, y_train, df_y1 = train_test_split(df_X, df_y2, test_size=0.2, random_state=0)
#model1.fit(X_train, y_train)
#joblib.dump(model1, "MultipleOutputRegressorRandomForestRegressorRepayment.pkl")
#print("Model 3: ");
#accuracy(model1, df_X, df_y1)
#model2.fit(X_train, y_train)
#joblib.dump(model2, "MultiplepleOutputRandomForestRegressorRepayment.pkl")
#print("Model 4: ");
#accuracy(model2, df_X, df_y1)
|
[
"numpy.abs",
"numpy.mean",
"pandas.read_csv",
"sklearn.externals.joblib.load",
"pandas.get_dummies"
] |
[((297, 411), 'pandas.read_csv', 'pd.read_csv', (['"""https://drive.google.com/uc?export=download&id=1XoV8SfvHmzaxRuDRe81OWSQu10dYTbO5"""'], {'sep': '""","""'}), "(\n 'https://drive.google.com/uc?export=download&id=1XoV8SfvHmzaxRuDRe81OWSQu10dYTbO5'\n , sep=',')\n", (308, 411), True, 'import pandas as pd\n'), ((440, 460), 'pandas.get_dummies', 'pd.get_dummies', (['df_X'], {}), '(df_X)\n', (454, 460), True, 'import pandas as pd\n'), ((503, 524), 'pandas.get_dummies', 'pd.get_dummies', (['df_y1'], {}), '(df_y1)\n', (517, 524), True, 'import pandas as pd\n'), ((567, 588), 'pandas.get_dummies', 'pd.get_dummies', (['df_y2'], {}), '(df_y2)\n', (581, 588), True, 'import pandas as pd\n'), ((1882, 1951), 'sklearn.externals.joblib.load', 'joblib.load', (['"""RegressorChainGradientBoostingRegressorEarningsNew.pkl"""'], {}), "('RegressorChainGradientBoostingRegressorEarningsNew.pkl')\n", (1893, 1951), False, 'from sklearn.externals import joblib\n'), ((1988, 2058), 'sklearn.externals.joblib.load', 'joblib.load', (['"""RegressorChainGradientBoostingRegressorRepaymentNew.pkl"""'], {}), "('RegressorChainGradientBoostingRegressorRepaymentNew.pkl')\n", (1999, 2058), False, 'from sklearn.externals import joblib\n'), ((804, 832), 'numpy.abs', 'np.abs', (['(predictions - y_test)'], {}), '(predictions - y_test)\n', (810, 832), True, 'import numpy as np\n'), ((1099, 1126), 'numpy.abs', 'np.abs', (['(predictions - df_y1)'], {}), '(predictions - df_y1)\n', (1105, 1126), True, 'import numpy as np\n'), ((905, 923), 'numpy.mean', 'np.mean', (['mape[col]'], {}), '(mape[col])\n', (912, 923), True, 'import numpy as np\n')]
|
# Costs
# 2019 - Luque, Straub - Risk-based optimal inspection strategies for
# structural systems using dynamic Bayesian networks
# Table 4, case 1
import numpy as np
class InspectionMaintenance:
"""
Inspection and Maintenance
==========================
Cost calculation for inspection and maintenance reliability analysis.
Parameters:
-----------
c_c : float
individual cost of campaign
c_i : float
individual cost of inspection
c_r : float
individual cost of repair
c_f : float
individual cost of failure
r : float
discount rate
"""
def __init__(self, c_c=5.0, c_i=1.0, c_r=10.0, c_f=10000, r=0.02):
self.c_c, self.c_i, self.c_r, self.c_c, self.c_f, self.r = c_c, c_i, c_r, c_c, c_f, r
def compute_cost_breakdown(self, system_model):
"""
Compute cost breakdown
======================
From simulated model, compute all lifetime costs:
- campaign : C_C
- inspection : C_I
- repair : C_R
- failure : C_F
Results are stored in the system atributes in dictionaries:
- system_obs
- system_action
- yearly_costs_breakdown
- cost_breakdown
"""
system_insp, system_repair = dict(), dict()
t, pf = np.vstack(system_model.system_pf).T
unique_mask = np.diff(t) == 1
delta_pf = np.diff(pf)[unique_mask]
abs_t = np.unique(t).astype(int) # t[1:][unique_mask]
C_C, C_I, C_R, R_F = np.zeros_like(abs_t, dtype=float), np.zeros_like(abs_t, dtype=float), np.zeros_like(abs_t, dtype=float), np.zeros_like(abs_t, dtype=float)
for component in system_model.components_list:
action, output = np.array(component.action), np.array(component.output)
y_t = (1 - self.r)**(np.array(component.t))
if any(action):
comp_t = np.array(component.t, dtype=int)
t_insp = comp_t[action == 'PoD']
t_repair = comp_t[action == 'PR']
C_I[t_insp] += self.c_i*(1 - self.r)**t_insp
C_R[t_repair] += self.c_r*(1 - self.r)**t_repair
system_insp[component.id]= t_insp
system_repair[component.id] = t_repair
else:
system_insp[component.id]= list()
system_repair[component.id] = list()
t_temp = np.unique(np.concatenate(list(system_insp.values()))).astype(int)
C_C[t_temp] += self.c_c*(1 - self.r)**(t_temp)
R_F[abs_t[1:]] = self.c_f*delta_pf*(1 - self.r)**abs_t[1:]
C_T = C_C + C_I + C_R + R_F
system_model.yearly_costs_breakdown = {'t' : abs_t, 'C_C' : C_C, 'C_I' : C_I, 'C_R' : C_R, 'R_F' : R_F, 'C_T': C_T}
system_model.cost_breakdown = {'C_C' : C_C.sum(), 'C_I' : C_I.sum(), 'C_R' : C_R.sum(), 'R_F' : R_F.sum(), 'C_T': C_T.sum()}
|
[
"numpy.unique",
"numpy.diff",
"numpy.array",
"numpy.vstack",
"numpy.zeros_like"
] |
[((1359, 1392), 'numpy.vstack', 'np.vstack', (['system_model.system_pf'], {}), '(system_model.system_pf)\n', (1368, 1392), True, 'import numpy as np\n'), ((1417, 1427), 'numpy.diff', 'np.diff', (['t'], {}), '(t)\n', (1424, 1427), True, 'import numpy as np\n'), ((1452, 1463), 'numpy.diff', 'np.diff', (['pf'], {}), '(pf)\n', (1459, 1463), True, 'import numpy as np\n'), ((1569, 1602), 'numpy.zeros_like', 'np.zeros_like', (['abs_t'], {'dtype': 'float'}), '(abs_t, dtype=float)\n', (1582, 1602), True, 'import numpy as np\n'), ((1604, 1637), 'numpy.zeros_like', 'np.zeros_like', (['abs_t'], {'dtype': 'float'}), '(abs_t, dtype=float)\n', (1617, 1637), True, 'import numpy as np\n'), ((1639, 1672), 'numpy.zeros_like', 'np.zeros_like', (['abs_t'], {'dtype': 'float'}), '(abs_t, dtype=float)\n', (1652, 1672), True, 'import numpy as np\n'), ((1674, 1707), 'numpy.zeros_like', 'np.zeros_like', (['abs_t'], {'dtype': 'float'}), '(abs_t, dtype=float)\n', (1687, 1707), True, 'import numpy as np\n'), ((1493, 1505), 'numpy.unique', 'np.unique', (['t'], {}), '(t)\n', (1502, 1505), True, 'import numpy as np\n'), ((1792, 1818), 'numpy.array', 'np.array', (['component.action'], {}), '(component.action)\n', (1800, 1818), True, 'import numpy as np\n'), ((1820, 1846), 'numpy.array', 'np.array', (['component.output'], {}), '(component.output)\n', (1828, 1846), True, 'import numpy as np\n'), ((1880, 1901), 'numpy.array', 'np.array', (['component.t'], {}), '(component.t)\n', (1888, 1901), True, 'import numpy as np\n'), ((1956, 1988), 'numpy.array', 'np.array', (['component.t'], {'dtype': 'int'}), '(component.t, dtype=int)\n', (1964, 1988), True, 'import numpy as np\n')]
|
from __future__ import absolute_import, division, print_function
import json
import os.path as op
import six
import numpy as np
import scipy.signal as sig
import scipy.io.wavfile as sciwav
MAXINT16 = 2**15 - 1
FS = 44100
COEFF_DIR = op.join(op.dirname(op.abspath(__file__)), 'coeffs')
def normalize(data, maxamp=1):
data *= maxamp / max(abs(data))
def load_coeffs(fname):
with open(op.join(COEFF_DIR, fname)) as f:
return json.load(f)
POTS_COEFFS = load_coeffs('pots.json')
def pots(data, snr=30, seed=None):
if seed is not None:
np.random.seed(seed)
# ensure mono
if data.ndim != 1:
data = data[:,0]
# convert to float, but simulate 16-bit quantization if needed
orig_dtype = data.dtype
data = data.astype('float')
if orig_dtype != 'int16':
normalize(data, maxamp=MAXINT16)
np.around(data, out=data)
normalize(data)
# pad start and end
#leader_len = np.random.randint(0.1 * FS, 0.4 * FS)
#trailer_len = 0.5 * FS - leader_len
#data = np.concatenate([np.zeros(leader_len), data, np.zeros(trailer_len)])
# do filtering
for b, a in POTS_COEFFS['signal']:
data = sig.lfilter(b, a, data)
# add band-limited noise (filtered white noise)
#np.random.seed(0)
noise = 10**(-snr/20) * ((np.random.random(size=data.shape) * 2) - 1)
for b, a in POTS_COEFFS['noiseband']:
noise = sig.lfilter(b, a, noise)
data += noise
# renormalize and convert to 16-bit integers
normalize(data, maxamp=MAXINT16)
data = data.astype('int16')
return data
class DigitalStreamFilter(object):
mimes = {
'wav': 'audio/vnd.wave',
'txt': 'text/plain',
'json': 'application/json',
}
output_suffix = 'filtered'
def __init__(self, data=None, stream=None, filename=None, dtype=None):
if dtype is None and filename is None:
try:
# werkzeug.FileStorage has 'filename', python files have 'name'
filename = getattr(stream, 'filename', getattr(stream, 'name'))
except AttributeError:
raise ValueError("Can't determine type from stream. "
"Provide dtype or filename to infer type.")
if dtype is None:
dtype = filename.split('.')[-1]
self.dtype = dtype
self.filename = filename
self.json_extra = {}
if data is not None:
self.data = np.array(data)
elif stream is not None:
self.load(stream)
else:
with open(filename, 'rb') as stream:
self.load(stream)
def load(self, stream):
dispatcher = {
'wav': self._load_wave,
'txt': self._load_text,
'json': self._load_json,
}
try:
data = dispatcher[self.dtype](stream)
except KeyError:
raise TypeError('Unsupported input type: {} (accepts {})'.format(
self.dtype, ', '.join(dispatcher.keys())))
self.data = np.array(data)
def process(self, *args, **kwargs):
raise NotImplementedError('abstract method')
def dump(self, stream, dtype=None):
if dtype is None:
dtype = self.dtype
{'wav': self._dump_wave,
'txt': self._dump_text,
'json': self._dump_json,
}[dtype](stream)
def suggested_name(self):
parts = self.filename.split('.')[:-1]
parts.extend([self.output_suffix, self.dtype])
return '.'.join(parts)
def mimetype(self):
return self.mimes[self.dtype]
def _load_wave(self, stream):
rate, data = sciwav.read(stream)
return data
def _load_text(self, stream):
return np.loadtxt(stream, dtype='int16')
def _load_json(self, stream):
return np.array(json.load(stream))
def _dump_wave(self, stream):
sciwav.write(stream, FS, self.data)
def _dump_text(self, stream):
np.savetxt(stream, self.data, fmt='%d')
def _dump_json(self, stream):
json.dump({'data': self.data.tolist(), 'rate': FS}, stream)
class POTSFilter(DigitalStreamFilter):
output_suffix = 'pots-filtered'
def process(self, *args, **kwargs):
self.data = pots(self.data, *args, **kwargs)
|
[
"numpy.random.random",
"os.path.join",
"json.load",
"numpy.array",
"scipy.signal.lfilter",
"scipy.io.wavfile.read",
"numpy.around",
"numpy.random.seed",
"scipy.io.wavfile.write",
"os.path.abspath",
"numpy.savetxt",
"numpy.loadtxt"
] |
[((255, 275), 'os.path.abspath', 'op.abspath', (['__file__'], {}), '(__file__)\n', (265, 275), True, 'import os.path as op\n'), ((443, 455), 'json.load', 'json.load', (['f'], {}), '(f)\n', (452, 455), False, 'import json\n'), ((565, 585), 'numpy.random.seed', 'np.random.seed', (['seed'], {}), '(seed)\n', (579, 585), True, 'import numpy as np\n'), ((860, 885), 'numpy.around', 'np.around', (['data'], {'out': 'data'}), '(data, out=data)\n', (869, 885), True, 'import numpy as np\n'), ((1182, 1205), 'scipy.signal.lfilter', 'sig.lfilter', (['b', 'a', 'data'], {}), '(b, a, data)\n', (1193, 1205), True, 'import scipy.signal as sig\n'), ((1414, 1438), 'scipy.signal.lfilter', 'sig.lfilter', (['b', 'a', 'noise'], {}), '(b, a, noise)\n', (1425, 1438), True, 'import scipy.signal as sig\n'), ((3071, 3085), 'numpy.array', 'np.array', (['data'], {}), '(data)\n', (3079, 3085), True, 'import numpy as np\n'), ((3686, 3705), 'scipy.io.wavfile.read', 'sciwav.read', (['stream'], {}), '(stream)\n', (3697, 3705), True, 'import scipy.io.wavfile as sciwav\n'), ((3776, 3809), 'numpy.loadtxt', 'np.loadtxt', (['stream'], {'dtype': '"""int16"""'}), "(stream, dtype='int16')\n", (3786, 3809), True, 'import numpy as np\n'), ((3931, 3966), 'scipy.io.wavfile.write', 'sciwav.write', (['stream', 'FS', 'self.data'], {}), '(stream, FS, self.data)\n', (3943, 3966), True, 'import scipy.io.wavfile as sciwav\n'), ((4010, 4049), 'numpy.savetxt', 'np.savetxt', (['stream', 'self.data'], {'fmt': '"""%d"""'}), "(stream, self.data, fmt='%d')\n", (4020, 4049), True, 'import numpy as np\n'), ((395, 420), 'os.path.join', 'op.join', (['COEFF_DIR', 'fname'], {}), '(COEFF_DIR, fname)\n', (402, 420), True, 'import os.path as op\n'), ((2467, 2481), 'numpy.array', 'np.array', (['data'], {}), '(data)\n', (2475, 2481), True, 'import numpy as np\n'), ((3869, 3886), 'json.load', 'json.load', (['stream'], {}), '(stream)\n', (3878, 3886), False, 'import json\n'), ((1312, 1345), 'numpy.random.random', 'np.random.random', ([], {'size': 'data.shape'}), '(size=data.shape)\n', (1328, 1345), True, 'import numpy as np\n')]
|
# Standard library
import atexit
import os
os.environ["OMP_NUM_THREADS"] = "1"
import sys
import traceback
# Third-party
from astropy.utils import iers
iers.conf.auto_download = False
import astropy.table as at
import numpy as np
# This project
from totoro.config import cache_path
from totoro.data import datasets, elem_names
from totoro.objective import TorusImagingObjective
def worker(task):
i, obj, x0, tmp_filename = task
res = None
try:
res = obj.minimize(x0=x0, method="nelder-mead",
options=dict(maxiter=250))
print(f"{i} finished optimizing: {res}")
except Exception as e:
print(f"{i} failed: {str(e)}")
traceback.print_exc()
if res is None or not res.success:
xopt = np.nan * np.array(x0)
else:
xopt = res.x
xopt = {
'zsun': [xopt[0]],
'vzsun': [xopt[1]],
'mdisk_f': [xopt[2]],
'disk_hz': [xopt[3]],
}
at.Table(xopt).write(tmp_filename, overwrite=True)
return tmp_filename
def combine_output(all_filename, this_cache_path, elem_name):
import glob
cache_glob_pattr = str(this_cache_path / f'tmp-*{elem_name}*.csv')
if os.path.exists(all_filename):
prev_table = at.Table.read(all_filename)
else:
prev_table = None
# combine the individual worker cache files
all_tables = []
remove_filenames = []
for filename in glob.glob(cache_glob_pattr):
all_tables.append(at.Table.read(filename))
remove_filenames.append(filename)
if all_tables:
all_table = at.vstack(all_tables)
else:
return
if prev_table:
all_table = at.vstack((prev_table, all_table))
all_table.write(all_filename, overwrite=True)
for filename in remove_filenames:
os.unlink(filename)
def main(pool, overwrite=False):
tree_K = 32 # MAGIC NUMBER: set heuristically in Objective-function.ipynb
bootstrap_K = 128 # MAGIC NUMBER
for data_name, d in datasets.items():
# TODO: make seed configurable?
rnd = np.random.default_rng(seed=42)
# loop over all elements
tasks = []
cache_paths = []
cache_filenames = []
for elem_name in elem_names[data_name]:
print(f"Running element: {elem_name}")
# TODO: if galah in data_name, filter on flag??
this_cache_path = cache_path / data_name
this_cache_filename = (this_cache_path /
f'optimize-results-{elem_name}.csv')
if this_cache_filename.exists() and not overwrite:
print(f"Cache file exists for {elem_name}: "
f"{this_cache_filename}")
continue
atexit.register(combine_output,
this_cache_filename,
this_cache_path,
elem_name)
cache_paths.append(this_cache_path)
cache_filenames.append(this_cache_filename)
# print("Optimizing with full sample to initialize bootstraps...")
# obj = TorusImagingObjective(d.t, d.c, elem_name, tree_K=tree_K)
# full_sample_res = obj.minimize(method="nelder-mead",
# options=dict(maxiter=1024))
# if not full_sample_res.success:
# print(f"FAILED TO CONVERGE: optimize for full sample failed "
# f"for {elem_name}")
# continue
# print(f"Finished optimizing full sample: {full_sample_res.x}")
# x0 = full_sample_res.x
x0 = np.array([20.8, 7.78, 1.1, 0.28]) # HACK: init from fiducial
for k in range(bootstrap_K):
idx = rnd.choice(len(d), len(d), replace=True)
obj = TorusImagingObjective(d[idx], elem_name,
tree_K=tree_K)
tmp_filename = (this_cache_path /
f'tmp-optimize-results-{elem_name}-{k}.csv')
tasks.append((k, obj, x0, tmp_filename))
print("Done setting up bootstrap samples - running pool.map() on "
f"{len(tasks)} tasks")
for _ in pool.map(worker, tasks):
pass
for this_cache_filename, this_cache_path, elem_name in zip(
cache_filenames,
cache_paths,
elem_names[data_name]):
combine_output(this_cache_filename, this_cache_path, elem_name)
sys.exit(0)
if __name__ == '__main__':
from argparse import ArgumentParser
# Define parser object
parser = ArgumentParser()
parser.add_argument("-o", "--overwrite", dest="overwrite",
action="store_true")
# vq_group = parser.add_mutually_exclusive_group()
# vq_group.add_argument('-v', '--verbose', action='count', default=0,
# dest='verbosity')
# vq_group.add_argument('-q', '--quiet', action='count', default=0,
# dest='quietness')
group = parser.add_mutually_exclusive_group()
group.add_argument("--procs", dest="n_procs", default=1,
type=int, help="Number of processes.")
group.add_argument("--mpi", dest="mpi", default=False,
action="store_true", help="Run with MPI.")
parsed = parser.parse_args()
# deal with multiproc:
if parsed.mpi:
from schwimmbad.mpi import MPIPool
Pool = MPIPool
kw = dict()
elif parsed.n_procs > 1:
from schwimmbad import MultiPool
Pool = MultiPool
kw = dict(processes=parsed.n_procs)
else:
from schwimmbad import SerialPool
Pool = SerialPool
kw = dict()
Pool = Pool
Pool_kwargs = kw
with Pool(**Pool_kwargs) as pool:
main(pool=pool, overwrite=parsed.overwrite)
sys.exit(0)
|
[
"os.path.exists",
"numpy.random.default_rng",
"argparse.ArgumentParser",
"astropy.table.Table",
"astropy.table.vstack",
"totoro.data.datasets.items",
"numpy.array",
"os.unlink",
"sys.exit",
"totoro.objective.TorusImagingObjective",
"traceback.print_exc",
"atexit.register",
"glob.glob",
"astropy.table.Table.read"
] |
[((1200, 1228), 'os.path.exists', 'os.path.exists', (['all_filename'], {}), '(all_filename)\n', (1214, 1228), False, 'import os\n'), ((1430, 1457), 'glob.glob', 'glob.glob', (['cache_glob_pattr'], {}), '(cache_glob_pattr)\n', (1439, 1457), False, 'import glob\n'), ((2009, 2025), 'totoro.data.datasets.items', 'datasets.items', ([], {}), '()\n', (2023, 2025), False, 'from totoro.data import datasets, elem_names\n'), ((4562, 4573), 'sys.exit', 'sys.exit', (['(0)'], {}), '(0)\n', (4570, 4573), False, 'import sys\n'), ((4684, 4700), 'argparse.ArgumentParser', 'ArgumentParser', ([], {}), '()\n', (4698, 4700), False, 'from argparse import ArgumentParser\n'), ((5940, 5951), 'sys.exit', 'sys.exit', (['(0)'], {}), '(0)\n', (5948, 5951), False, 'import sys\n'), ((1251, 1278), 'astropy.table.Table.read', 'at.Table.read', (['all_filename'], {}), '(all_filename)\n', (1264, 1278), True, 'import astropy.table as at\n'), ((1592, 1613), 'astropy.table.vstack', 'at.vstack', (['all_tables'], {}), '(all_tables)\n', (1601, 1613), True, 'import astropy.table as at\n'), ((1679, 1713), 'astropy.table.vstack', 'at.vstack', (['(prev_table, all_table)'], {}), '((prev_table, all_table))\n', (1688, 1713), True, 'import astropy.table as at\n'), ((1812, 1831), 'os.unlink', 'os.unlink', (['filename'], {}), '(filename)\n', (1821, 1831), False, 'import os\n'), ((2081, 2111), 'numpy.random.default_rng', 'np.random.default_rng', ([], {'seed': '(42)'}), '(seed=42)\n', (2102, 2111), True, 'import numpy as np\n'), ((694, 715), 'traceback.print_exc', 'traceback.print_exc', ([], {}), '()\n', (713, 715), False, 'import traceback\n'), ((780, 792), 'numpy.array', 'np.array', (['x0'], {}), '(x0)\n', (788, 792), True, 'import numpy as np\n'), ((964, 978), 'astropy.table.Table', 'at.Table', (['xopt'], {}), '(xopt)\n', (972, 978), True, 'import astropy.table as at\n'), ((1485, 1508), 'astropy.table.Table.read', 'at.Table.read', (['filename'], {}), '(filename)\n', (1498, 1508), True, 'import astropy.table as at\n'), ((2768, 2853), 'atexit.register', 'atexit.register', (['combine_output', 'this_cache_filename', 'this_cache_path', 'elem_name'], {}), '(combine_output, this_cache_filename, this_cache_path, elem_name\n )\n', (2783, 2853), False, 'import atexit\n'), ((3664, 3697), 'numpy.array', 'np.array', (['[20.8, 7.78, 1.1, 0.28]'], {}), '([20.8, 7.78, 1.1, 0.28])\n', (3672, 3697), True, 'import numpy as np\n'), ((3853, 3908), 'totoro.objective.TorusImagingObjective', 'TorusImagingObjective', (['d[idx]', 'elem_name'], {'tree_K': 'tree_K'}), '(d[idx], elem_name, tree_K=tree_K)\n', (3874, 3908), False, 'from totoro.objective import TorusImagingObjective\n')]
|
# Copyright 2019 Xilinx Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import numpy as np
import scipy.misc
import scipy.io
from matplotlib.patches import Rectangle
import datetime
import cv2
import sys
def nms(dets, thresh):
"""Pure Python NMS baseline."""
x1 = dets[:, 0]
y1 = dets[:, 1]
x2 = dets[:, 2]
y2 = dets[:, 3]
scores = dets[:, 4]
areas = (x2 - x1 + 1) * (y2 - y1 + 1)
order = scores.argsort()[::-1]
keep = []
while order.size > 0:
i = order[0]
keep.append(i)
xx1 = np.maximum(x1[i], x1[order[1:]])
yy1 = np.maximum(y1[i], y1[order[1:]])
xx2 = np.minimum(x2[i], x2[order[1:]])
yy2 = np.minimum(y2[i], y2[order[1:]])
w = np.maximum(0.0, xx2 - xx1 + 1)
h = np.maximum(0.0, yy2 - yy1 + 1)
inter = w * h
ovr = inter / (areas[i] + areas[order[1:]] - inter)
inds = np.where(ovr <= thresh)[0]
order = order[inds + 1]
return keep
class Detect(object):
def __init__(self):
self.expand_scale_=0.0
self.force_gray_=False
self.input_mean_value_=128.0
self.input_scale_=1.0
self.pixel_blob_name_='pixel-loss'
self.bb_blob_name_='bb-output-tiled'
self.res_stride_=4
self.det_threshold_=0.7
self.nms_threshold_=0.3
self.caffe_path_=""
self.input_channels_=3
def model_init(self,caffe_python_path,model_path,def_path):
sys.path.insert(0,caffe_python_path)
import caffe
self.caffe_path_=caffe_python_path
self.net_=caffe.Net(def_path,model_path,caffe.TEST)
def detect(self,image):
#sys.path.insert(0,self.caffe_path_)
import caffe
#caffe.set_mode_cpu()
#caffe.set_device(0)
self.transformer_=caffe.io.Transformer({'data': (1,self.input_channels_,image.shape[0],image.shape[1])})
if self.force_gray_:
image=cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)
self.input_channels_=1
else:
self.transformer_.set_transpose('data', (2,0,1))
transformed_image=self.transformer_.preprocess('data',image)
transformed_image=(transformed_image-self.input_mean_value_)*self.input_scale_
sz=image.shape
self.net_.blobs['data'].reshape(1, self.input_channels_, sz[0], sz[1])
self.net_.blobs['data'].data[0, ...] = transformed_image
output = self.net_.forward()
prob = output[self.pixel_blob_name_][0, 1, ...]
bb = output[self.bb_blob_name_][0, ...]
gy = np.arange(0, sz[0], self.res_stride_)
gx = np.arange(0, sz[1], self.res_stride_)
gy = gy[0 : bb.shape[1]]
gx = gx[0 : bb.shape[2]]
[x, y] = np.meshgrid(gx, gy)
#print bb.shape[1],len(gy),sz[0],sz[1]
bb[0, :, :] += x
bb[2, :, :] += x
bb[1, :, :] += y
bb[3, :, :] += y
bb = np.reshape(bb, (4, -1)).T
prob = np.reshape(prob, (-1, 1))
bb = bb[prob.ravel() > self.det_threshold_, :]
prob = prob[prob.ravel() > self.det_threshold_, :]
rects = np.hstack((bb, prob))
keep = nms(rects, self.nms_threshold_)
rects = rects[keep, :]
rects_expand=[]
for rect in rects:
rect_expand=[]
rect_w=rect[2]-rect[0]
rect_h=rect[3]-rect[1]
rect_expand.append(int(max(0,rect[0]-rect_w*self.expand_scale_)))
rect_expand.append(int(max(0,rect[1]-rect_h*self.expand_scale_)))
rect_expand.append(int(min(sz[1],rect[2]+rect_w*self.expand_scale_)))
rect_expand.append(int(min(sz[0],rect[3]+rect_h*self.expand_scale_)))
rects_expand.append(rect_expand)
return rects_expand
|
[
"sys.path.insert",
"numpy.reshape",
"numpy.minimum",
"numpy.hstack",
"caffe.io.Transformer",
"numpy.where",
"cv2.cvtColor",
"caffe.Net",
"numpy.meshgrid",
"numpy.maximum",
"numpy.arange"
] |
[((1052, 1084), 'numpy.maximum', 'np.maximum', (['x1[i]', 'x1[order[1:]]'], {}), '(x1[i], x1[order[1:]])\n', (1062, 1084), True, 'import numpy as np\n'), ((1099, 1131), 'numpy.maximum', 'np.maximum', (['y1[i]', 'y1[order[1:]]'], {}), '(y1[i], y1[order[1:]])\n', (1109, 1131), True, 'import numpy as np\n'), ((1146, 1178), 'numpy.minimum', 'np.minimum', (['x2[i]', 'x2[order[1:]]'], {}), '(x2[i], x2[order[1:]])\n', (1156, 1178), True, 'import numpy as np\n'), ((1193, 1225), 'numpy.minimum', 'np.minimum', (['y2[i]', 'y2[order[1:]]'], {}), '(y2[i], y2[order[1:]])\n', (1203, 1225), True, 'import numpy as np\n'), ((1239, 1269), 'numpy.maximum', 'np.maximum', (['(0.0)', '(xx2 - xx1 + 1)'], {}), '(0.0, xx2 - xx1 + 1)\n', (1249, 1269), True, 'import numpy as np\n'), ((1282, 1312), 'numpy.maximum', 'np.maximum', (['(0.0)', '(yy2 - yy1 + 1)'], {}), '(0.0, yy2 - yy1 + 1)\n', (1292, 1312), True, 'import numpy as np\n'), ((1926, 1963), 'sys.path.insert', 'sys.path.insert', (['(0)', 'caffe_python_path'], {}), '(0, caffe_python_path)\n', (1941, 1963), False, 'import sys\n'), ((2033, 2076), 'caffe.Net', 'caffe.Net', (['def_path', 'model_path', 'caffe.TEST'], {}), '(def_path, model_path, caffe.TEST)\n', (2042, 2076), False, 'import caffe\n'), ((2234, 2327), 'caffe.io.Transformer', 'caffe.io.Transformer', (["{'data': (1, self.input_channels_, image.shape[0], image.shape[1])}"], {}), "({'data': (1, self.input_channels_, image.shape[0],\n image.shape[1])})\n", (2254, 2327), False, 'import caffe\n'), ((2932, 2969), 'numpy.arange', 'np.arange', (['(0)', 'sz[0]', 'self.res_stride_'], {}), '(0, sz[0], self.res_stride_)\n', (2941, 2969), True, 'import numpy as np\n'), ((2979, 3016), 'numpy.arange', 'np.arange', (['(0)', 'sz[1]', 'self.res_stride_'], {}), '(0, sz[1], self.res_stride_)\n', (2988, 3016), True, 'import numpy as np\n'), ((3088, 3107), 'numpy.meshgrid', 'np.meshgrid', (['gx', 'gy'], {}), '(gx, gy)\n', (3099, 3107), True, 'import numpy as np\n'), ((3286, 3311), 'numpy.reshape', 'np.reshape', (['prob', '(-1, 1)'], {}), '(prob, (-1, 1))\n', (3296, 3311), True, 'import numpy as np\n'), ((3430, 3451), 'numpy.hstack', 'np.hstack', (['(bb, prob)'], {}), '((bb, prob))\n', (3439, 3451), True, 'import numpy as np\n'), ((1411, 1434), 'numpy.where', 'np.where', (['(ovr <= thresh)'], {}), '(ovr <= thresh)\n', (1419, 1434), True, 'import numpy as np\n'), ((2358, 2397), 'cv2.cvtColor', 'cv2.cvtColor', (['image', 'cv2.COLOR_BGR2GRAY'], {}), '(image, cv2.COLOR_BGR2GRAY)\n', (2370, 2397), False, 'import cv2\n'), ((3249, 3272), 'numpy.reshape', 'np.reshape', (['bb', '(4, -1)'], {}), '(bb, (4, -1))\n', (3259, 3272), True, 'import numpy as np\n')]
|
# =============================================================================
# Copyright 2020 NVIDIA. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# =============================================================================
import numpy as np
from nemo import logging
def analyze_confusion_matrix(cm, dict, max_pairs=10):
"""
Sort all confusions in the confusion matrix by value and display results.
Print results in a format: (name -> name, value)
Args:
cm: Confusion matrix
dict: Dictionary with key as a name and index as a value (Intents or Slots)
max_pairs: Max number of confusions to print
"""
threshold = 5 # just arbitrary value to take confusion with at least this number
confused_pairs = {}
size = cm.shape[0]
for i in range(size):
res = cm[i].argsort()
for j in range(size):
pos = res[size - j - 1]
# no confusion - same row and column
if pos == i:
continue
elif cm[i][pos] >= threshold:
str = f'{dict[i]} -> {dict[pos]}'
confused_pairs[str] = cm[i][pos]
else:
break
# sort by max confusions and print first max_pairs
sorted_confused_pairs = sorted(confused_pairs.items(), key=lambda x: x[1], reverse=True)
for i, pair_str in enumerate(sorted_confused_pairs):
if i >= max_pairs:
break
logging.info(pair_str)
def errors_per_class(cm, dict):
"""
Summarize confusions per each class in the confusion matrix.
It can be useful both for Intents and Slots.
It counts each confusion twice in both directions.
Args:
cm: Confusion matrix
dict: Dictionary with key as a name and index as a value (Intents or Slots)
"""
size = cm.shape[0]
confused_per_class = {}
total_errors = 0
for class_num in range(size):
sum = 0
for i in range(size):
if i != class_num:
sum += cm[class_num][i]
sum += cm[i][class_num]
confused_per_class[dict[class_num]] = sum
total_errors += sum
# logging.info(f'{dict[class_num]} - {sum}')
logging.info(f'Total errors (multiplied by 2): {total_errors}')
sorted_confused_per_class = sorted(confused_per_class.items(), key=lambda x: x[1], reverse=True)
for conf_str in sorted_confused_per_class:
logging.info(conf_str)
def log_misclassified_queries(intent_labels, intent_preds, queries, intent_dict, limit=50):
"""
Display examples of Intent mistakes.
In a format: Query, predicted and labeled intent names.
"""
logging.info(f'*** Misclassified intent queries (limit {limit}) ***')
cnt = 0
for i in range(len(intent_preds)):
if intent_labels[i] != intent_preds[i]:
query = queries[i].split('\t')[0]
logging.info(
f'{query} (predicted: {intent_dict[intent_preds[i]]} - labeled: {intent_dict[intent_labels[i]]})'
)
cnt = cnt + 1
if cnt >= limit:
break
def log_misclassified_slots(
intent_labels, intent_preds, slot_labels, slot_preds, subtokens_mask, queries, intent_dict, slot_dict, limit=50
):
"""
Display examples of Slot mistakes.
In a format: Query, predicted and labeled intent names and list of predicted and labeled slot numbers.
also prints dictionary of the slots at the start for easier reading.
"""
logging.info('')
logging.info(f'*** Misclassified slots queries (limit {limit}) ***')
# print slot dictionary
logging.info(f'Slot dictionary:')
str = ''
for i, slot in enumerate(slot_dict):
str += f'{i} - {slot}, '
if i % 5 == 4 or i == len(slot_dict) - 1:
logging.info(str)
str = ''
logging.info('----------------')
cnt = 0
for i in range(len(intent_preds)):
cur_slot_pred = slot_preds[i][subtokens_mask[i]]
cur_slot_label = slot_labels[i][subtokens_mask[i]]
if not np.all(cur_slot_pred == cur_slot_label):
query = queries[i].split('\t')[0]
logging.info(
f'{query} (predicted: {intent_dict[intent_preds[i]]} - labeled: {intent_dict[intent_labels[i]]})'
)
logging.info(f'p: {cur_slot_pred}')
logging.info(f'l: {cur_slot_label}')
cnt = cnt + 1
if cnt >= limit:
break
def check_problematic_slots(slot_preds_list, slot_dict):
""" Check non compliance of B- and I- slots for datasets that use such slot encoding. """
cnt = 0
# for sentence in slot_preds:
# slots = sentence.split(" ")
sentence = slot_preds_list
for i in range(len(sentence)):
slot_name = slot_dict[int(sentence[i])]
if slot_name.startswith("I-"):
prev_slot_name = slot_dict[int(sentence[i - 1])]
if slot_name[2:] != prev_slot_name[2:]:
print("Problem: " + slot_name + " - " + prev_slot_name)
cnt += 1
print("Total problematic slots: " + str(cnt))
|
[
"nemo.logging.info",
"numpy.all"
] |
[((2735, 2798), 'nemo.logging.info', 'logging.info', (['f"""Total errors (multiplied by 2): {total_errors}"""'], {}), "(f'Total errors (multiplied by 2): {total_errors}')\n", (2747, 2798), False, 'from nemo import logging\n'), ((3193, 3262), 'nemo.logging.info', 'logging.info', (['f"""*** Misclassified intent queries (limit {limit}) ***"""'], {}), "(f'*** Misclassified intent queries (limit {limit}) ***')\n", (3205, 3262), False, 'from nemo import logging\n'), ((4028, 4044), 'nemo.logging.info', 'logging.info', (['""""""'], {}), "('')\n", (4040, 4044), False, 'from nemo import logging\n'), ((4049, 4117), 'nemo.logging.info', 'logging.info', (['f"""*** Misclassified slots queries (limit {limit}) ***"""'], {}), "(f'*** Misclassified slots queries (limit {limit}) ***')\n", (4061, 4117), False, 'from nemo import logging\n'), ((4150, 4183), 'nemo.logging.info', 'logging.info', (['f"""Slot dictionary:"""'], {}), "(f'Slot dictionary:')\n", (4162, 4183), False, 'from nemo import logging\n'), ((4377, 4409), 'nemo.logging.info', 'logging.info', (['"""----------------"""'], {}), "('----------------')\n", (4389, 4409), False, 'from nemo import logging\n'), ((1971, 1993), 'nemo.logging.info', 'logging.info', (['pair_str'], {}), '(pair_str)\n', (1983, 1993), False, 'from nemo import logging\n'), ((2955, 2977), 'nemo.logging.info', 'logging.info', (['conf_str'], {}), '(conf_str)\n', (2967, 2977), False, 'from nemo import logging\n'), ((3420, 3541), 'nemo.logging.info', 'logging.info', (['f"""{query} (predicted: {intent_dict[intent_preds[i]]} - labeled: {intent_dict[intent_labels[i]]})"""'], {}), "(\n f'{query} (predicted: {intent_dict[intent_preds[i]]} - labeled: {intent_dict[intent_labels[i]]})'\n )\n", (3432, 3541), False, 'from nemo import logging\n'), ((4333, 4350), 'nemo.logging.info', 'logging.info', (['str'], {}), '(str)\n', (4345, 4350), False, 'from nemo import logging\n'), ((4592, 4631), 'numpy.all', 'np.all', (['(cur_slot_pred == cur_slot_label)'], {}), '(cur_slot_pred == cur_slot_label)\n', (4598, 4631), True, 'import numpy as np\n'), ((4691, 4812), 'nemo.logging.info', 'logging.info', (['f"""{query} (predicted: {intent_dict[intent_preds[i]]} - labeled: {intent_dict[intent_labels[i]]})"""'], {}), "(\n f'{query} (predicted: {intent_dict[intent_preds[i]]} - labeled: {intent_dict[intent_labels[i]]})'\n )\n", (4703, 4812), False, 'from nemo import logging\n'), ((4845, 4880), 'nemo.logging.info', 'logging.info', (['f"""p: {cur_slot_pred}"""'], {}), "(f'p: {cur_slot_pred}')\n", (4857, 4880), False, 'from nemo import logging\n'), ((4893, 4929), 'nemo.logging.info', 'logging.info', (['f"""l: {cur_slot_label}"""'], {}), "(f'l: {cur_slot_label}')\n", (4905, 4929), False, 'from nemo import logging\n')]
|
import numpy as np
import cv2
import glob
from matplotlib import pyplot as plt
class CameraCalibration():
def __init__(self):
pass
# ===========================================================
# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
@staticmethod
def find_chess(frame_input, chess_size=(6, 6)):
status = None
print("chess...")
# termination criteria
criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001)
# prepare object points, like (0,0,0), (1,0,0), (2,0,0) ....,(6,5,0)
objp = np.zeros((chess_size[0]*chess_size[1], 3), np.float32)
objp[:, :2] = np.mgrid[0:chess_size[0], 0:chess_size[1]].T.reshape(-1, 2)
# Arrays to store object points and image points from all the images.
objpoints = [] # 3d point in real world space
imgpoints = [] # 2d points in image plane.
frame_gray = cv2.cvtColor(frame_input, cv2.COLOR_BGR2GRAY)
# Find the chess board corners
ret, corners = cv2.findChessboardCorners(frame_gray, (chess_size[0], chess_size[1]), None)
# If found, add object points, image points (after refining them)
frame_output = None
if ret == True:
status = "checkmate!"
print(status)
objpoints.append(objp)
corners2 = cv2.cornerSubPix(frame_gray,
corners,
(11, 11),
(-1, -1),
criteria)
imgpoints.append(corners2)
# Draw and display the corners
frame_output = cv2.drawChessboardCorners(frame_input, (chess_size[0], chess_size[1]), corners2, ret)
plt.imshow(frame_output)
plt.show()
if frame_output is None:
frame_output = frame_input
return frame_output, objpoints, imgpoints, status
# ===========================================================
# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
@staticmethod
def calibrateCoefficients(frame_input, objpoints, imgpoints):
ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera(objpoints,
imgpoints,
frame_input.shape[::-1],
None,
None)
tot_error = 0
mean_error = 0
for i in range(len(objpoints)):
imgpoints2, _ = cv2.projectPoints(objpoints[i], rvecs[i], tvecs[i], mtx, dist)
error = cv2.norm(imgpoints[i],imgpoints2, cv2.NORM_L2)/len(imgpoints2)
tot_error += error
print("total error: ", mean_error/len(objpoints))
return ret, mtx, dist, rvecs, tvecs
# $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
@staticmethod
def testbench(video_source=2):
capture = cv2.VideoCapture(video_source)
count_frame = 0
while 1:
# ++++++++++++++++++++++++++++++++++++++++++++++++
print('calibrate state...')
status = None
while status is None:
status = None
ret, frame_input = capture.read()
print(count_frame)
count_frame += 1
frame_chess, objpoints, imgpoints, status = CameraCalibration.find_chess(frame_input)
plt.imshow(frame_chess)
plt.show()
# ++++++++++++++++++++++++++++++++++++++++++++++++
frame_gray = cv2.cvtColor(frame_input, cv2.COLOR_BGR2GRAY)
plt.imshow(frame_gray)
plt.show()
ret, mtx, dist, rvecs, tvecs = CameraCalibration.calibrateCoefficients(frame_gray, objpoints, imgpoints)
h, w = frame_gray.shape[:2]
newcameramtx, roi =cv2.getOptimalNewCameraMatrix(mtx, dist, (w, h), 1, (w, h))
# ++++++++++++++++++++++++++++++++++++++++++++++++
print('test state...')
while 1:
ret, frame_input = capture.read()
frame_gray = cv2.cvtColor(frame_input,cv2.COLOR_BGR2GRAY)
h, w = frame_gray.shape[:2]
newcameramtx, roi =cv2.getOptimalNewCameraMatrix(mtx, dist, (w, h), 1, (w, h))
frame_undist = cv2.undistort(frame_input, mtx, dist, None, newcameramtx)
x,y,w,h = roi
print(x,y,w,h)
# frame_undist = frame_undist[y:y+h, x:x+w]
frame_concat = np.concatenate((frame_undist, frame_input), axis=1)
plt.imshow(frame_concat)
plt.show()
# ----------------------------------------------------------
# Esc -> EXIT while
# while 1:
# k = cv2.waitKey(1) & 0xff
# if k ==13 or k==27:
# break
# if k == 27:
# break
# ----------------------------------------------------------
capture.release()
cv2.destroyAllWindows()
# $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
@staticmethod
def getPhoto(video_source=0):
capture = cv2.VideoCapture(video_source)
while 1:
ret, frame_input = capture.read()
frame_line = frame_input
frame_output = cv2.line(frame_line,
(0, frame_line.shape[0]//2),
(frame_line.shape[1], frame_line.shape[0]//2),
(255,0,0),
1)
frame_output = cv2.line(frame_line,
(frame_line.shape[1]//2, 0),
(frame_line.shape[1]//2, frame_line.shape[0]),
(255,0,0),
1)
cv2.imshow("Video", frame_line)
# ------------------------------------------------------------------------------------------------------------------
# Esc -> EXIT while
k = cv2.waitKey(30) & 0xff
if k == 27:
break
# ------------------------------------------------------------------------------------------------------------------
# ----------------------------------------------------------------------------------------------------------------------
ret, frame_input = capture.read()
frame_input = cv2.cvtColor(frame_input, cv2.COLOR_BGR2RGB)
plt.imshow(frame_input)
plt.xticks([])
plt.yticks([])
plt.show()
# ----------------------------------------------------------------------------------------------------------------------
capture.release()
cv2.destroyAllWindows()
# $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
# $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
# $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
# CameraCalibration.testbench(video_source=2)
|
[
"cv2.norm",
"cv2.projectPoints",
"cv2.imshow",
"cv2.destroyAllWindows",
"cv2.calibrateCamera",
"cv2.findChessboardCorners",
"cv2.cornerSubPix",
"matplotlib.pyplot.imshow",
"cv2.line",
"cv2.undistort",
"matplotlib.pyplot.yticks",
"numpy.concatenate",
"cv2.waitKey",
"matplotlib.pyplot.xticks",
"cv2.getOptimalNewCameraMatrix",
"cv2.cvtColor",
"matplotlib.pyplot.show",
"numpy.zeros",
"cv2.VideoCapture",
"cv2.drawChessboardCorners"
] |
[((604, 660), 'numpy.zeros', 'np.zeros', (['(chess_size[0] * chess_size[1], 3)', 'np.float32'], {}), '((chess_size[0] * chess_size[1], 3), np.float32)\n', (612, 660), True, 'import numpy as np\n'), ((947, 992), 'cv2.cvtColor', 'cv2.cvtColor', (['frame_input', 'cv2.COLOR_BGR2GRAY'], {}), '(frame_input, cv2.COLOR_BGR2GRAY)\n', (959, 992), False, 'import cv2\n'), ((1056, 1131), 'cv2.findChessboardCorners', 'cv2.findChessboardCorners', (['frame_gray', '(chess_size[0], chess_size[1])', 'None'], {}), '(frame_gray, (chess_size[0], chess_size[1]), None)\n', (1081, 1131), False, 'import cv2\n'), ((2254, 2332), 'cv2.calibrateCamera', 'cv2.calibrateCamera', (['objpoints', 'imgpoints', 'frame_input.shape[::-1]', 'None', 'None'], {}), '(objpoints, imgpoints, frame_input.shape[::-1], None, None)\n', (2273, 2332), False, 'import cv2\n'), ((3171, 3201), 'cv2.VideoCapture', 'cv2.VideoCapture', (['video_source'], {}), '(video_source)\n', (3187, 3201), False, 'import cv2\n'), ((5364, 5387), 'cv2.destroyAllWindows', 'cv2.destroyAllWindows', ([], {}), '()\n', (5385, 5387), False, 'import cv2\n'), ((5591, 5621), 'cv2.VideoCapture', 'cv2.VideoCapture', (['video_source'], {}), '(video_source)\n', (5607, 5621), False, 'import cv2\n'), ((6905, 6949), 'cv2.cvtColor', 'cv2.cvtColor', (['frame_input', 'cv2.COLOR_BGR2RGB'], {}), '(frame_input, cv2.COLOR_BGR2RGB)\n', (6917, 6949), False, 'import cv2\n'), ((6967, 6990), 'matplotlib.pyplot.imshow', 'plt.imshow', (['frame_input'], {}), '(frame_input)\n', (6977, 6990), True, 'from matplotlib import pyplot as plt\n'), ((6999, 7013), 'matplotlib.pyplot.xticks', 'plt.xticks', (['[]'], {}), '([])\n', (7009, 7013), True, 'from matplotlib import pyplot as plt\n'), ((7022, 7036), 'matplotlib.pyplot.yticks', 'plt.yticks', (['[]'], {}), '([])\n', (7032, 7036), True, 'from matplotlib import pyplot as plt\n'), ((7045, 7055), 'matplotlib.pyplot.show', 'plt.show', ([], {}), '()\n', (7053, 7055), True, 'from matplotlib import pyplot as plt\n'), ((7220, 7243), 'cv2.destroyAllWindows', 'cv2.destroyAllWindows', ([], {}), '()\n', (7241, 7243), False, 'import cv2\n'), ((1378, 1445), 'cv2.cornerSubPix', 'cv2.cornerSubPix', (['frame_gray', 'corners', '(11, 11)', '(-1, -1)', 'criteria'], {}), '(frame_gray, corners, (11, 11), (-1, -1), criteria)\n', (1394, 1445), False, 'import cv2\n'), ((1720, 1809), 'cv2.drawChessboardCorners', 'cv2.drawChessboardCorners', (['frame_input', '(chess_size[0], chess_size[1])', 'corners2', 'ret'], {}), '(frame_input, (chess_size[0], chess_size[1]),\n corners2, ret)\n', (1745, 1809), False, 'import cv2\n'), ((1818, 1842), 'matplotlib.pyplot.imshow', 'plt.imshow', (['frame_output'], {}), '(frame_output)\n', (1828, 1842), True, 'from matplotlib import pyplot as plt\n'), ((1855, 1865), 'matplotlib.pyplot.show', 'plt.show', ([], {}), '()\n', (1863, 1865), True, 'from matplotlib import pyplot as plt\n'), ((2686, 2748), 'cv2.projectPoints', 'cv2.projectPoints', (['objpoints[i]', 'rvecs[i]', 'tvecs[i]', 'mtx', 'dist'], {}), '(objpoints[i], rvecs[i], tvecs[i], mtx, dist)\n', (2703, 2748), False, 'import cv2\n'), ((3817, 3862), 'cv2.cvtColor', 'cv2.cvtColor', (['frame_input', 'cv2.COLOR_BGR2GRAY'], {}), '(frame_input, cv2.COLOR_BGR2GRAY)\n', (3829, 3862), False, 'import cv2\n'), ((3875, 3897), 'matplotlib.pyplot.imshow', 'plt.imshow', (['frame_gray'], {}), '(frame_gray)\n', (3885, 3897), True, 'from matplotlib import pyplot as plt\n'), ((3910, 3920), 'matplotlib.pyplot.show', 'plt.show', ([], {}), '()\n', (3918, 3920), True, 'from matplotlib import pyplot as plt\n'), ((4112, 4171), 'cv2.getOptimalNewCameraMatrix', 'cv2.getOptimalNewCameraMatrix', (['mtx', 'dist', '(w, h)', '(1)', '(w, h)'], {}), '(mtx, dist, (w, h), 1, (w, h))\n', (4141, 4171), False, 'import cv2\n'), ((5752, 5873), 'cv2.line', 'cv2.line', (['frame_line', '(0, frame_line.shape[0] // 2)', '(frame_line.shape[1], frame_line.shape[0] // 2)', '(255, 0, 0)', '(1)'], {}), '(frame_line, (0, frame_line.shape[0] // 2), (frame_line.shape[1], \n frame_line.shape[0] // 2), (255, 0, 0), 1)\n', (5760, 5873), False, 'import cv2\n'), ((6035, 6155), 'cv2.line', 'cv2.line', (['frame_line', '(frame_line.shape[1] // 2, 0)', '(frame_line.shape[1] // 2, frame_line.shape[0])', '(255, 0, 0)', '(1)'], {}), '(frame_line, (frame_line.shape[1] // 2, 0), (frame_line.shape[1] //\n 2, frame_line.shape[0]), (255, 0, 0), 1)\n', (6043, 6155), False, 'import cv2\n'), ((6303, 6334), 'cv2.imshow', 'cv2.imshow', (['"""Video"""', 'frame_line'], {}), "('Video', frame_line)\n", (6313, 6334), False, 'import cv2\n'), ((2769, 2816), 'cv2.norm', 'cv2.norm', (['imgpoints[i]', 'imgpoints2', 'cv2.NORM_L2'], {}), '(imgpoints[i], imgpoints2, cv2.NORM_L2)\n', (2777, 2816), False, 'import cv2\n'), ((3676, 3699), 'matplotlib.pyplot.imshow', 'plt.imshow', (['frame_chess'], {}), '(frame_chess)\n', (3686, 3699), True, 'from matplotlib import pyplot as plt\n'), ((3716, 3726), 'matplotlib.pyplot.show', 'plt.show', ([], {}), '()\n', (3724, 3726), True, 'from matplotlib import pyplot as plt\n'), ((4373, 4418), 'cv2.cvtColor', 'cv2.cvtColor', (['frame_input', 'cv2.COLOR_BGR2GRAY'], {}), '(frame_input, cv2.COLOR_BGR2GRAY)\n', (4385, 4418), False, 'import cv2\n'), ((4498, 4557), 'cv2.getOptimalNewCameraMatrix', 'cv2.getOptimalNewCameraMatrix', (['mtx', 'dist', '(w, h)', '(1)', '(w, h)'], {}), '(mtx, dist, (w, h), 1, (w, h))\n', (4527, 4557), False, 'import cv2\n'), ((4590, 4647), 'cv2.undistort', 'cv2.undistort', (['frame_input', 'mtx', 'dist', 'None', 'newcameramtx'], {}), '(frame_input, mtx, dist, None, newcameramtx)\n', (4603, 4647), False, 'import cv2\n'), ((4801, 4852), 'numpy.concatenate', 'np.concatenate', (['(frame_undist, frame_input)'], {'axis': '(1)'}), '((frame_undist, frame_input), axis=1)\n', (4815, 4852), True, 'import numpy as np\n'), ((4870, 4894), 'matplotlib.pyplot.imshow', 'plt.imshow', (['frame_concat'], {}), '(frame_concat)\n', (4880, 4894), True, 'from matplotlib import pyplot as plt\n'), ((4911, 4921), 'matplotlib.pyplot.show', 'plt.show', ([], {}), '()\n', (4919, 4921), True, 'from matplotlib import pyplot as plt\n'), ((6513, 6528), 'cv2.waitKey', 'cv2.waitKey', (['(30)'], {}), '(30)\n', (6524, 6528), False, 'import cv2\n')]
|
# -*- coding: utf-8 -*-
"""
Utilities for reading and writing USID datasets that are highly model-dependent (with or without N-dimensional form)
Created on Tue Nov 3 21:14:25 2015
@author: <NAME>, <NAME>
"""
from __future__ import division, print_function, absolute_import, unicode_literals
from warnings import warn
import sys
import h5py
import numpy as np
from dask import array as da
from sidpy.hdf.hdf_utils import get_attr, write_simple_attrs, is_editable_h5, \
copy_dataset, lazy_load_array
from sidpy.base.num_utils import contains_integers
from sidpy.base.dict_utils import flatten_dict
from sidpy.base.string_utils import validate_single_string_arg, \
validate_list_of_strings, validate_string_args
from sidpy.hdf.dtype_utils import validate_dtype
from sidpy import sid
from .base import write_book_keeping_attrs
from .simple import link_as_main, check_if_main, write_ind_val_dsets, validate_dims_against_main, validate_anc_h5_dsets
from ..dimension import Dimension, validate_dimensions
from ..anc_build_utils import INDICES_DTYPE, make_indices_matrix
if sys.version_info.major == 3:
unicode = str
def reshape_to_n_dims(h5_main, h5_pos=None, h5_spec=None, get_labels=False, verbose=False, sort_dims=False,
lazy=False):
"""
Reshape the input 2D matrix to be N-dimensions based on the
position and spectroscopic datasets.
Parameters
----------
h5_main : HDF5 Dataset
2D data to be reshaped
h5_pos : HDF5 Dataset, optional
Position indices corresponding to rows in `h5_main`
h5_spec : HDF5 Dataset, optional
Spectroscopic indices corresponding to columns in `h5_main`
get_labels : bool, optional
Whether or not to return the dimension labels. Default False
verbose : bool, optional
Whether or not to print debugging statements
sort_dims : bool
If True, the data is sorted so that the dimensions are in order from slowest to fastest
If False, the data is kept in the original order
If `get_labels` is also True, the labels are sorted as well.
lazy : bool, optional. Default = False
If False, ds_Nd will be a numpy.ndarray object - this is suitable if the HDF5 dataset fits into memory
If True, ds_Nd will be a dask.array object - This is suitable if the HDF5 dataset is too large to fit into
memory. Note that this will bea lazy computation meaning that the returned object just contains the instructions
. In order to get the actual value or content in numpy arrays, call ds_Nd.compute()
Returns
-------
ds_Nd : N-D numpy array or dask.array object
N dimensional array arranged as [positions slowest to fastest, spectroscopic slowest to fastest]
success : boolean or string
True if full reshape was successful
"Positions" if it was only possible to reshape by
the position dimensions
False if no reshape was possible
ds_labels : list of str
List of the labels of each dimension of `ds_Nd`
Notes
-----
If either `h5_pos` or `h5_spec` are not provided, the function will first
attempt to find them as attributes of `h5_main`. If that fails, it will
generate dummy values for them.
"""
# TODO: automatically switch on lazy if the data is larger than memory
# TODO: sort_dims does not appear to do much. Functions as though it was always True
if h5_pos is None and h5_spec is None:
if not check_if_main(h5_main):
raise ValueError('if h5_main is a h5py.Dataset it should be a Main dataset')
else:
if not isinstance(h5_main, (h5py.Dataset, np.ndarray, da.core.Array)):
raise TypeError('h5_main should either be a h5py.Dataset or numpy array')
if h5_pos is not None:
if not isinstance(h5_pos, (h5py.Dataset, np.ndarray, da.core.Array)):
raise TypeError('h5_pos should either be a h5py.Dataset or numpy array')
if h5_pos.shape[0] != h5_main.shape[0]:
raise ValueError('The size of h5_pos: {} does not match with h5_main: {}'.format(h5_pos.shape,
h5_main.shape))
if h5_spec is not None:
if not isinstance(h5_spec, (h5py.Dataset, np.ndarray, da.core.Array)):
raise TypeError('h5_spec should either be a h5py.Dataset or numpy array')
if h5_spec.shape[1] != h5_main.shape[1]:
raise ValueError('The size of h5_spec: {} does not match with h5_main: {}'.format(h5_spec.shape,
h5_main.shape))
pos_labs = np.array(['Positions'])
spec_labs = np.array(['Spectral_Step'])
if h5_pos is None:
"""
Get the Position datasets from the references if possible
"""
if isinstance(h5_main, h5py.Dataset):
try:
h5_pos = h5_main.file[h5_main.attrs['Position_Indices']]
ds_pos = h5_pos[()]
pos_labs = get_attr(h5_pos, 'labels')
except KeyError:
print('No position datasets found as attributes of {}'.format(h5_main.name))
if len(h5_main.shape) > 1:
ds_pos = np.arange(h5_main.shape[0], dtype=INDICES_DTYPE).reshape(-1, 1)
pos_labs = np.array(['Position Dimension {}'.format(ipos) for ipos in range(ds_pos.shape[1])])
else:
ds_pos = np.array(0, dtype=INDICES_DTYPE).reshape(-1, 1)
else:
ds_pos = np.arange(h5_main.shape[0], dtype=INDICES_DTYPE).reshape(-1, 1)
pos_labs = np.array(['Position Dimension {}'.format(ipos) for ipos in range(ds_pos.shape[1])])
elif isinstance(h5_pos, h5py.Dataset):
"""
Position Indices dataset was provided
"""
ds_pos = h5_pos[()]
pos_labs = get_attr(h5_pos, 'labels')
elif isinstance(h5_pos, (np.ndarray, da.core.Array)):
ds_pos = np.atleast_2d(h5_pos)
pos_labs = np.array(['Position Dimension {}'.format(ipos) for ipos in range(ds_pos.shape[1])])
else:
raise TypeError('Position Indices must be either h5py.Dataset or None')
if h5_spec is None:
"""
Get the Spectroscopic datasets from the references if possible
"""
if isinstance(h5_main, h5py.Dataset):
try:
h5_spec = h5_main.file[h5_main.attrs['Spectroscopic_Indices']]
ds_spec = h5_spec[()]
spec_labs = get_attr(h5_spec, 'labels')
except KeyError:
print('No spectroscopic datasets found as attributes of {}'.format(h5_main.name))
if len(h5_main.shape) > 1:
ds_spec = np.arange(h5_main.shape[1], dtype=INDICES_DTYPE).reshape([1, -1])
spec_labs = np.array(['Spectral Dimension {}'.format(ispec) for ispec in range(ds_spec.shape[0])])
else:
ds_spec = np.array(0, dtype=INDICES_DTYPE).reshape([1, 1])
else:
ds_spec = np.arange(h5_main.shape[1], dtype=INDICES_DTYPE).reshape([1, -1])
spec_labs = np.array(['Spectral Dimension {}'.format(ispec) for ispec in range(ds_spec.shape[0])])
elif isinstance(h5_spec, h5py.Dataset):
"""
Spectroscopic Indices dataset was provided
"""
ds_spec = h5_spec[()]
spec_labs = get_attr(h5_spec, 'labels')
elif isinstance(h5_spec, (np.ndarray, da.core.Array)):
ds_spec = h5_spec
spec_labs = np.array(['Spectral Dimension {}'.format(ispec) for ispec in range(ds_spec.shape[0])])
else:
raise TypeError('Spectroscopic Indices must be either h5py.Dataset or None')
'''
Sort the indices from fastest to slowest
'''
pos_sort = get_sort_order(np.transpose(ds_pos))
spec_sort = get_sort_order(ds_spec)
if verbose:
print('Position dimensions:', pos_labs)
print('Position sort order:', pos_sort)
print('Spectroscopic Dimensions:', spec_labs)
print('Spectroscopic sort order:', spec_sort)
'''
Get the size of each dimension in the sorted order
'''
pos_dims = get_dimensionality(np.transpose(ds_pos), pos_sort)
spec_dims = get_dimensionality(ds_spec, spec_sort)
if np.prod(pos_dims) != h5_main.shape[0]:
mesg = 'Product of position dimension sizes: {} = {} not matching ' \
'with size of first axis of main dataset: {}. One or more ' \
'dimensions are dependent dimensions and not marked as such' \
'.'.format(pos_dims, np.prod(pos_dims), h5_main.shape[0])
raise ValueError(mesg)
if np.prod(spec_dims) != h5_main.shape[1]:
mesg = 'Product of spectroscopic dimension sizes: {} = {} not matching ' \
'with size of second axis of main dataset: {}. One or more ' \
'dimensions are dependent dimensions and not marked as such' \
'.'.format(spec_dims, np.prod(spec_dims), h5_main.shape[1])
raise ValueError(mesg)
if verbose:
print('\nPosition dimensions (sort applied):', pos_labs[pos_sort])
print('Position dimensionality (sort applied):', pos_dims)
print('Spectroscopic dimensions (sort applied):', spec_labs[spec_sort])
print('Spectroscopic dimensionality (sort applied):', spec_dims)
if lazy:
ds_main = lazy_load_array(h5_main)
else:
ds_main = h5_main[()]
"""
Now we reshape the dataset based on those dimensions
numpy reshapes correctly when the dimensions are arranged from slowest to fastest.
Since the sort orders we have are from fastest to slowest, we need to reverse the orders
for both the position and spectroscopic dimensions
"""
if verbose:
print('Will attempt to reshape main dataset from:\n{} to {}'.format(ds_main.shape, pos_dims[::-1] + spec_dims[::-1]))
try:
ds_Nd = ds_main.reshape(pos_dims[::-1] + spec_dims[::-1])
except ValueError:
warn('Could not reshape dataset to full N-dimensional form. Attempting reshape based on position only.')
try:
ds_Nd = ds_main.reshape(pos_dims[::-1] + [-1])
except ValueError:
warn('Reshape by position only also failed. Will keep dataset in 2d form.')
if get_labels:
return ds_main, False, ['Position', 'Spectral Step']
else:
return ds_main, False
# No exception
else:
if get_labels:
return ds_Nd, 'Positions', ['Position'] + spec_labs
else:
return ds_Nd, 'Positions'
all_labels = np.hstack((pos_labs[pos_sort][::-1],
spec_labs[spec_sort][::-1]))
if verbose:
print('\nAfter reshaping, labels are', all_labels)
print('Data shape is', ds_Nd.shape)
"""
At this point, the data is arranged from slowest to fastest dimension in both pos and spec
"""
if sort_dims:
results = [ds_Nd, True]
if get_labels:
results.append(all_labels)
return results
if verbose:
print('\nGoing to put dimensions back in the same order as in the file:')
swap_axes = list()
# Compare the original order of the pos / spec labels with where these dimensions occur in the sorted labels
for lab in pos_labs:
swap_axes.append(np.argwhere(all_labels == lab).squeeze())
for lab in spec_labs:
swap_axes.append(np.argwhere(all_labels == lab).squeeze())
swap_axes = np.array(swap_axes)
if verbose:
print('Axes will permuted in this order:', swap_axes)
print('New labels ordering:', all_labels[swap_axes])
ds_Nd = ds_Nd.transpose(tuple(swap_axes))
results = [ds_Nd, True]
if verbose:
print('Dataset now of shape:', ds_Nd.shape)
if get_labels:
'''
Get the labels in the proper order
'''
results.append(all_labels[swap_axes])
return results
def reshape_from_n_dims(data_n_dim, h5_pos=None, h5_spec=None, verbose=False):
"""
Reshape the input 2D matrix to be N-dimensions based on the
position and spectroscopic datasets.
Parameters
----------
data_n_dim : numpy.array or dask.array.core.Array
N dimensional array arranged as [positions dimensions..., spectroscopic dimensions]
If h5_pos and h5_spec are not provided, this function will have to assume that the dimensions
are arranged as [positions slowest to fastest, spectroscopic slowest to fastest].
This restriction is removed if h5_pos and h5_spec are provided
h5_pos : HDF5 Dataset, numpy.array or dask.array.core.Array
Position indices corresponding to rows in the final 2d array
The dimensions should be arranged in terms of rate of change corresponding to data_n_dim.
In other words if data_n_dim had two position dimensions arranged as [pos_fast, pos_slow, spec_dim_1....],
h5_pos should be arranged as [pos_fast, pos_slow]
h5_spec : HDF5 Dataset, numpy. array or dask.array.core.Array
Spectroscopic indices corresponding to columns in the final 2d array
The dimensions should be arranged in terms of rate of change corresponding to data_n_dim.
In other words if data_n_dim had two spectral dimensions arranged as [pos_dim_1,..., spec_fast, spec_slow],
h5_spec should be arranged as [pos_slow, pos_fast]
verbose : bool, optional. Default = False
Whether or not to print log statements
Returns
-------
ds_2d : numpy.array
2 dimensional numpy array arranged as [positions, spectroscopic]
success : boolean or string
True if full reshape was successful
"Positions" if it was only possible to reshape by
the position dimensions
False if no reshape was possible
Notes
-----
If either `h5_pos` or `h5_spec` are not provided, the function will
assume the first dimension is position and the remaining are spectroscopic already
in order from fastest to slowest.
"""
if not isinstance(data_n_dim, (np.ndarray, da.core.Array)):
raise TypeError('data_n_dim is not a numpy or dask array')
if h5_spec is None and h5_pos is None:
raise ValueError('at least one of h5_pos or h5_spec must be specified for an attempt to reshape to 2D')
if data_n_dim.ndim < 2:
return data_n_dim, True
if h5_pos is None:
pass
elif isinstance(h5_pos, h5py.Dataset):
'''
Position Indices dataset was provided
'''
ds_pos = h5_pos[()]
elif isinstance(h5_pos, da.core.Array):
ds_pos = h5_pos.compute()
elif isinstance(h5_pos, np.ndarray):
ds_pos = h5_pos
else:
raise TypeError('Position Indices must be either h5py.Dataset or None')
if h5_spec is None:
pass
elif isinstance(h5_spec, h5py.Dataset):
'''
Spectroscopic Indices dataset was provided
'''
ds_spec = h5_spec[()]
elif isinstance(h5_spec, da.core.Array):
ds_spec = h5_spec.compute()
elif isinstance(h5_spec, np.ndarray):
ds_spec = h5_spec
else:
raise TypeError('Spectroscopic Indices must be either h5py.Dataset or None')
if h5_spec is None and h5_pos is not None:
if verbose:
print('Spectral indices not provided but position indices provided.\n'
'Building spectral indices assuming that dimensions are arranged as slow -> fast')
pos_dims = get_dimensionality(ds_pos, index_sort=get_sort_order(ds_pos))
if not np.all([x in data_n_dim.shape for x in pos_dims]):
raise ValueError('Dimension sizes in pos_dims: {} do not exist in data_n_dim shape: '
'{}'.format(pos_dims, data_n_dim.shape))
spec_dims = [col for col in list(data_n_dim.shape[len(pos_dims):])]
if verbose:
print('data has dimensions: {}. Provided position indices had dimensions of size: {}. Spectral dimensions '
'will built with dimensions: {}'.format(data_n_dim.shape, pos_dims, spec_dims))
ds_spec = make_indices_matrix(spec_dims, is_position=False)
elif h5_pos is None and h5_spec is not None:
if verbose:
print('Position indices not provided but spectral indices provided.\n'
'Building position indices assuming that dimensions are arranged as slow -> fast')
spec_dims = get_dimensionality(ds_spec, index_sort=get_sort_order(ds_spec))
if not np.all([x in data_n_dim.shape for x in spec_dims]):
raise ValueError('Dimension sizes in spec_dims: {} do not exist in data_n_dim shape: '
'{}'.format(spec_dims, data_n_dim.shape))
pos_dims = [col for col in list(data_n_dim.shape[:data_n_dim.ndim-len(spec_dims)])]
if verbose:
print('data has dimensions: {}. Spectroscopic position indices had dimensions of size: {}. Position '
'dimensions will built with dimensions: {}'.format(data_n_dim.shape, spec_dims, pos_dims))
ds_pos = make_indices_matrix(pos_dims, is_position=True)
elif h5_spec is not None and h5_pos is not None:
if ds_pos.shape[0] * ds_spec.shape[1] != np.product(data_n_dim.shape):
raise ValueError('The product ({}) of the number of positions ({}) and spectroscopic ({}) observations is '
'not equal to the product ({}) of the data shape ({})'
'.'.format(ds_pos.shape[0] * ds_spec.shape[1], ds_pos.shape[0], ds_spec.shape[1],
np.product(data_n_dim.shape), data_n_dim.shape))
if ds_pos.shape[1] + ds_spec.shape[0] != data_n_dim.ndim:
# This may mean that the dummy position or spectroscopic axes has been squeezed out!
# Dask does NOT allow singular dimensions apparently. So cannot do expand_dims. Handle later
if ds_pos.size == 1 or ds_spec.size == 1:
if verbose:
print('ALL Position dimensions squeezed: {}. ALL Spectroscopic dimensions squeezed: {}'
'.'.format(ds_pos.size == 1, ds_spec.size == 1))
else:
raise ValueError('The number of position ({}) and spectroscopic ({}) dimensions do not match with the '
'dimensionality of the N-dimensional dataset: {}'
'.'.format(ds_pos.shape[1], ds_spec.shape[0], data_n_dim.ndim))
'''
Sort the indices from fastest to slowest
'''
if ds_pos.size == 1:
# Position dimension squeezed out:
pos_sort = []
else:
pos_sort = get_sort_order(np.transpose(ds_pos))
if ds_spec.size == 1:
# Spectroscopic axis squeezed out:
spec_sort = []
else:
spec_sort = get_sort_order(ds_spec)
if h5_spec is None:
spec_sort = spec_sort[::-1]
if h5_pos is None:
pos_sort = pos_sort[::-1]
if verbose:
print('Position sort order: {}'.format(pos_sort))
print('Spectroscopic sort order: {}'.format(spec_sort))
'''
Now we transpose the axes associated with the spectroscopic dimensions
so that they are in the same order as in the index array
'''
swap_axes = np.uint16(np.append(pos_sort[::-1], spec_sort[::-1] + len(pos_sort)))
if verbose:
print('swap axes: {} to be applied to N dimensional data of shape {}'.format(swap_axes, data_n_dim.shape))
data_n_dim_2 = data_n_dim.transpose(tuple(swap_axes))
if verbose:
print('N dimensional data shape after axes swap: {}'.format(data_n_dim_2.shape))
'''
Now we reshape the dataset based on those dimensions
We must use the spectroscopic dimensions in reverse order
'''
try:
ds_2d = data_n_dim_2.reshape([ds_pos.shape[0], ds_spec.shape[1]])
except ValueError:
raise ValueError('Could not reshape dataset to full N-dimensional form')
return ds_2d, True
def get_dimensionality(ds_index, index_sort=None):
"""
Get the size of each index dimension in a specified sort order
Parameters
----------
ds_index : 2D HDF5 Dataset or numpy array
Row matrix of indices
index_sort : Iterable of unsigned integers (Optional)
Sort that can be applied to dimensionality.
For example - Order of rows sorted from fastest to slowest
Returns
-------
sorted_dims : list of unsigned integers
Dimensionality of each row in ds_index. If index_sort is supplied, it will be in the sorted order
"""
if isinstance(ds_index, da.core.Array):
ds_index = ds_index.compute()
if not isinstance(ds_index, (np.ndarray, h5py.Dataset)):
raise TypeError('ds_index should either be a numpy array or h5py.Dataset')
if ds_index.shape[0] > ds_index.shape[1]:
# must be spectroscopic like in shape (few rows, more cols)
ds_index = np.transpose(ds_index)
if index_sort is None:
index_sort = np.arange(ds_index.shape[0])
else:
if not contains_integers(index_sort, min_val=0):
raise ValueError('index_sort should contain integers > 0')
index_sort = np.array(index_sort)
if index_sort.ndim != 1:
raise ValueError('index_sort should be a 1D array')
if len(np.unique(index_sort)) > ds_index.shape[0]:
raise ValueError('length of index_sort ({}) should be smaller than number of dimensions in provided dataset'
' ({}'.format(len(np.unique(index_sort)), ds_index.shape[0]))
if set(np.arange(ds_index.shape[0])) != set(index_sort):
raise ValueError('Sort order of dimensions ({}) not matching with number of dimensions ({})'
''.format(index_sort, ds_index.shape[0]))
sorted_dims = [len(np.unique(row)) for row in np.array(ds_index, ndmin=2)[index_sort]]
return sorted_dims
def get_sort_order(ds_spec):
"""
Find how quickly the spectroscopic values are changing in each row
and the order of rows from fastest changing to slowest.
Parameters
----------
ds_spec : 2D HDF5 dataset or numpy array
Rows of indices to be sorted from fastest changing to slowest
Returns
-------
change_sort : List of unsigned integers
Order of rows sorted from fastest changing to slowest
"""
if isinstance(ds_spec, da.core.Array):
ds_spec = ds_spec.compute()
if not isinstance(ds_spec, (np.ndarray, h5py.Dataset)):
raise TypeError('ds_spec should either be a numpy array or h5py.Dataset')
if ds_spec.shape[0] > ds_spec.shape[1]:
# must be spectroscopic like in shape (few rows, more cols)
ds_spec = np.transpose(ds_spec)
change_count = [len(np.where([row[i] != row[i - 1] for i in range(len(row))])[0]) for row in ds_spec]
change_sort = np.argsort(change_count)[::-1]
return change_sort
def get_unit_values(ds_inds, ds_vals, dim_names=None, all_dim_names=None, is_spec=None, verbose=False):
"""
Gets the unit arrays of values that describe the spectroscopic dimensions
Parameters
----------
ds_inds : h5py.Dataset or numpy.ndarray
Spectroscopic or Position Indices dataset
ds_vals : h5py.Dataset or numpy.ndarray
Spectroscopic or Position Values dataset
dim_names : str, or list of str, Optional
Names of the dimensions of interest. Default = all
all_dim_names : list of str, Optional
Names of all the dimensions in these datasets. Use this if supplying numpy arrays instead of h5py.Dataset
objects for h5_inds, h5_vals since there is no other way of getting the dimension names.
is_spec : bool, optional
Whether or not the provided ancillary datasets are position or spectroscopic
The user is recommended to supply this parameter whenever it is known
By default, this function will attempt to recognize the answer based on the shape of the datasets.
verbose : bool, optional
Whether or not to print debugging statements. Default - off
Note - this function can be extended / modified for ancillary position dimensions as well
Returns
-------
unit_values : dict
Dictionary containing the unit array for each dimension. The name of the dimensions are the keys.
"""
if all_dim_names is None:
allowed_types = h5py.Dataset
else:
all_dim_names = validate_list_of_strings(all_dim_names, 'all_dim_names')
all_dim_names = np.array(all_dim_names)
allowed_types = (h5py.Dataset, np.ndarray)
for dset, dset_name in zip([ds_inds, ds_vals], ['ds_inds', 'ds_vals']):
if not isinstance(dset, allowed_types):
raise TypeError(dset_name + ' should be of type: {}'.format(allowed_types))
# For now, we will throw an error if even a single dimension is listed as an incomplete dimension:
if isinstance(ds_inds, h5py.Dataset):
if np.any(['incomplete_dimensions' in dset.attrs.keys() for dset in [ds_inds, ds_vals]]):
try:
incomp_dims_inds = get_attr(ds_inds, 'incomplete_dimensions')
except KeyError:
incomp_dims_inds = None
try:
incomp_dims_vals = get_attr(ds_vals, 'incomplete_dimensions')
except KeyError:
incomp_dims_vals = None
if incomp_dims_inds is None and incomp_dims_vals is not None:
incomp_dims = incomp_dims_vals
elif incomp_dims_inds is not None and incomp_dims_vals is None:
incomp_dims = incomp_dims_inds
else:
# ensure that both attributes are the same
if incomp_dims_vals != incomp_dims_inds:
raise ValueError('Provided indices ({}) and values ({}) datasets were marked with different values '
'for incomplete_datasets.'.format(incomp_dims_inds, incomp_dims_vals))
incomp_dims = incomp_dims_vals
all_dim_names = get_attr(ds_inds, 'labels')
raise ValueError('Among all dimensions: {}, These dimensions were marked as incomplete dimensions: {}'
'. You are recommended to find unit values manually'.format(all_dim_names, incomp_dims))
# Do we need to check that the provided inds and vals correspond to the same main dataset?
if ds_inds.shape != ds_vals.shape:
raise ValueError('h5_inds: {} and h5_vals: {} should have the same shapes'.format(ds_inds.shape, ds_vals.shape))
if all_dim_names is None:
all_dim_names = get_attr(ds_inds, 'labels')
if verbose:
print('All dimensions: {}'.format(all_dim_names))
# First load to memory
inds_mat = ds_inds[()]
vals_mat = ds_vals[()]
if is_spec is None:
# Attempt to recognize the type automatically
is_spec = False
if inds_mat.shape[0] < inds_mat.shape[1]:
is_spec = True
else:
if not isinstance(is_spec, bool):
raise TypeError('is_spec should be a boolean. Provided object is of type: {}'.format(type(is_spec)))
if verbose:
print(
'Ancillary matrices of shape: {}, hence determined to be Spectroscopic:{}'.format(inds_mat.shape, is_spec))
if not is_spec:
# Convert to spectral shape
inds_mat = np.transpose(inds_mat)
vals_mat = np.transpose(vals_mat)
if len(all_dim_names) != inds_mat.shape[0]:
raise ValueError('Length of dimension names list: {} not matching with shape of dataset: {}'
'.'.format(len(all_dim_names), inds_mat.shape[0]))
if dim_names is None:
dim_names = all_dim_names
if verbose:
print('Going to return unit values for all dimensions: {}'.format(all_dim_names))
else:
dim_names = validate_list_of_strings(dim_names, 'dim_names')
if verbose:
print('Checking to make sure that the target dimension names: {} exist in the datasets attributes: {}'
'.'.format(dim_names, all_dim_names))
# check to make sure that the dimension names exist in the datasets:
for dim_name in dim_names:
if dim_name not in all_dim_names:
raise KeyError('Dimension {} does not exist in the provided ancillary datasets'.format(dim_name))
unit_values = dict()
for dim_name in all_dim_names:
# Find the row in the spectroscopic indices that corresponds to the dimensions we want to slice:
if verbose:
print('Looking for dimension: {} in {}'.format(dim_name, dim_names))
desired_row_ind = np.where(all_dim_names == dim_name)[0][0]
inds_for_dim = inds_mat[desired_row_ind]
# Wherever this dimension goes to 0 - start of a new tile
starts = np.where(inds_for_dim == np.min(inds_for_dim))[0]
if starts[0] != 0:
raise ValueError('Spectroscopic Indices for dimension: "{}" not '
'starting with 0. Please fix this and try again'
'.'.format(dim_name))
# There may be repetitions in addition to tiling. Find how the the positions increase.
# 1 = repetition, > 1 = new tile
step_sizes = np.hstack(([1], np.diff(starts)))
# This array is of the same length as the full indices array
# We should expect only two values of step sizes for a regular dimension (tiles of the same size):
# 1 for same value repeating and a big jump in indices when the next tile starts
# If the repeats / tiles are of different lengths, then this is not a regular dimension.
# What does a Unit Values vector even mean in this case? Just raise an error for now
if np.where(np.unique(step_sizes) - 1)[0].size > 1:
raise ValueError('Non constant step sizes')
# Finding Start of a new tile
tile_starts = np.where(step_sizes > 1)[0]
# converting these indices to correct indices that can be mapped straight to
if len(tile_starts) < 1:
# Dimension(s) with no tiling at all
# Make it look as though the next tile starts at the end of the whole indices vector
tile_starts = np.array([0, len(inds_for_dim)])
else:
# Dimension with some form of repetition
tile_starts = np.hstack(([0], starts[tile_starts]))
# Verify that each tile is identical here
# Last tile will not be checked unless we add the length of the indices vector as the start of next tile
tile_starts = np.hstack((tile_starts, [len(inds_for_dim)]))
subsections = [inds_for_dim[tile_starts[ind]: tile_starts[ind + 1]] for ind in range(len(tile_starts) - 1)]
if np.max(np.diff(subsections, axis=0)) != 0:
# Should get unit values for ALL dimensions regardless of expectations to catch such scenarios.
raise ValueError('Values in each tile of dimension: {} are different'.format(dim_name))
# Now looking within the first tile:
subsection = inds_for_dim[tile_starts[0]:tile_starts[1]]
# remove all repetitions. ie - take indices only where jump == 1
step_inds = np.hstack(([0], np.where(np.hstack(([0], np.diff(subsection))))[0]))
# Finally, use these indices to get the values
if dim_name in dim_names:
# Only add this dimension to dictionary if requwested.
unit_values[dim_name] = vals_mat[desired_row_ind, step_inds]
return unit_values
def write_main_dataset(h5_parent_group, main_data, main_data_name, quantity, units, pos_dims, spec_dims,
main_dset_attrs=None, h5_pos_inds=None, h5_pos_vals=None, h5_spec_inds=None, h5_spec_vals=None,
aux_spec_prefix='Spectroscopic_', aux_pos_prefix='Position_', verbose=False,
slow_to_fast=False, **kwargs):
"""
Writes the provided data as a 'Main' dataset with all appropriate linking.
By default, the instructions for generating the ancillary datasets should be specified using the pos_dims and
spec_dims arguments as dictionary objects. Alternatively, if both the indices and values datasets are already
available for either/or the positions / spectroscopic, they can be specified using the keyword arguments. In this
case, fresh datasets will not be generated.
Parameters
----------
h5_parent_group : :class:`h5py.Group`
Parent group under which the datasets will be created
main_data : numpy.ndarray, dask.array.core.Array, list or tuple
2D matrix formatted as [position, spectral] or a list / tuple with the shape for an empty dataset.
If creating an empty dataset - the dtype must be specified via a kwarg.
main_data_name : String / Unicode
Name to give to the main dataset. This cannot contain the '-' character.
quantity : String / Unicode
Name of the physical quantity stored in the dataset. Example - 'Current'
units : String / Unicode
Name of units for the quantity stored in the dataset. Example - 'A' for amperes
pos_dims : Dimension or array-like of Dimension objects
Sequence of Dimension objects that provides all necessary instructions for constructing the indices and values
datasets
Object specifying the instructions necessary for building the Position indices and values datasets
spec_dims : Dimension or array-like of Dimension objects
Sequence of Dimension objects that provides all necessary instructions for constructing the indices and values
datasets
Object specifying the instructions necessary for building the Spectroscopic indices and values datasets
main_dset_attrs : dictionary, Optional
Dictionary of parameters that will be written to the main dataset. Do NOT include region references here.
h5_pos_inds : h5py.Dataset, Optional
Dataset that will be linked with the name "Position_Indices"
h5_pos_vals : h5py.Dataset, Optional
Dataset that will be linked with the name "Position_Values"
h5_spec_inds : h5py.Dataset, Optional
Dataset that will be linked with the name "Spectroscopic_Indices"
h5_spec_vals : h5py.Dataset, Optional
Dataset that will be linked with the name "Spectroscopic_Values"
aux_spec_prefix : str or unicode, Optional
Default prefix for Spectroscopic datasets. Default = "Spectroscopic"
aux_pos_prefix : str or unicode, Optional
Default prefix for Position datasets. Default = "Position"
verbose : bool, Optional, default=False
If set to true - prints debugging logs
slow_to_fast : bool, Optional. Default=False
Set to True if the dimensions are arranged from slowest varying to fastest varying.
Set to False otherwise.
kwargs will be passed onto the creation of the dataset. Please pass chunking, compression, dtype, and other
arguments this way
Returns
-------
h5_main : USIDataset
Reference to the main dataset
"""
def __check_anc_before_creation(aux_prefix, dim_type='pos'):
aux_prefix = validate_single_string_arg(aux_prefix, 'aux_' + dim_type + '_prefix')
if not aux_prefix.endswith('_'):
aux_prefix += '_'
if '-' in aux_prefix:
warn('aux_' + dim_type + ' should not contain the "-" character. Reformatted name from:{} to '
'{}'.format(aux_prefix, aux_prefix.replace('-', '_')))
aux_prefix = aux_prefix.replace('-', '_')
for dset_name in [aux_prefix + 'Indices', aux_prefix + 'Values']:
if dset_name in h5_parent_group.keys():
# TODO: What if the contained data was correct?
raise KeyError('Dataset named: ' + dset_name + ' already exists in group: '
'{}. Consider passing these datasets using kwargs (if they are correct) instead of providing the pos_dims and spec_dims arguments'.format(h5_parent_group.name))
return aux_prefix
def __ensure_anc_in_correct_file(h5_inds, h5_vals, prefix):
if h5_inds.file != h5_vals.file:
raise ValueError('Provided ' + prefix + ' datasets are present in different HDF5 files!')
if h5_inds.file != h5_parent_group.file:
# Need to copy over the anc datasets to the new group
if verbose:
print('Need to copy over ancillary datasets: {} and {} to '
'destination group: {} which is in a different HDF5 '
'file'.format(h5_inds, h5_vals, h5_parent_group))
ret_vals = [copy_dataset(x, h5_parent_group, verbose=verbose) for x in [h5_inds, h5_vals]]
else:
ret_vals = [h5_inds, h5_vals]
return tuple(ret_vals)
if not isinstance(h5_parent_group, (h5py.Group, h5py.File)):
raise TypeError('h5_parent_group should be a h5py.File or h5py.Group object')
if not is_editable_h5(h5_parent_group):
raise ValueError('The provided file is not editable')
if verbose:
print('h5 group and file OK')
quantity, units, main_data_name = validate_string_args([quantity, units, main_data_name],
['quantity', 'units', 'main_data_name'])
if verbose:
print('quantity, units, main_data_name all OK')
quantity = quantity.strip()
units = units.strip()
main_data_name = main_data_name.strip()
if '-' in main_data_name:
warn('main_data_name should not contain the "-" character. Reformatted name from:{} to '
'{}'.format(main_data_name, main_data_name.replace('-', '_')))
main_data_name = main_data_name.replace('-', '_')
if isinstance(main_data, (list, tuple)):
if not contains_integers(main_data, min_val=1):
raise ValueError('main_data if specified as a shape should be a list / tuple of integers >= 1')
if len(main_data) != 2:
raise ValueError('main_data if specified as a shape should contain 2 numbers')
if 'dtype' not in kwargs:
raise ValueError('dtype must be included as a kwarg when creating an empty dataset')
_ = validate_dtype(kwargs.get('dtype'))
main_shape = main_data
if verbose:
print('Selected empty dataset creation. OK so far')
elif isinstance(main_data, (np.ndarray, da.core.Array)):
if main_data.ndim != 2:
raise ValueError('main_data should be a 2D array')
main_shape = main_data.shape
if verbose:
print('Provided numpy or Dask array for main_data OK so far')
else:
raise TypeError('main_data should either be a numpy array or a tuple / list with the shape of the data')
if h5_pos_inds is not None and h5_pos_vals is not None:
# The provided datasets override fresh building instructions.
validate_anc_h5_dsets(h5_pos_inds, h5_pos_vals, main_shape, is_spectroscopic=False)
if verbose:
print('The shapes of the provided h5 position indices and values are OK')
h5_pos_inds, h5_pos_vals = __ensure_anc_in_correct_file(h5_pos_inds, h5_pos_vals, 'Position')
else:
aux_pos_prefix = __check_anc_before_creation(aux_pos_prefix, dim_type='pos')
pos_dims = validate_dimensions(pos_dims, dim_type='Position')
validate_dims_against_main(main_shape, pos_dims, is_spectroscopic=False)
if verbose:
print('Passed all pre-tests for creating position datasets')
h5_pos_inds, h5_pos_vals = write_ind_val_dsets(h5_parent_group, pos_dims, is_spectral=False, verbose=verbose,
slow_to_fast=slow_to_fast, base_name=aux_pos_prefix)
if verbose:
print('Created position datasets!')
if h5_spec_inds is not None and h5_spec_vals is not None:
# The provided datasets override fresh building instructions.
validate_anc_h5_dsets(h5_spec_inds, h5_spec_vals, main_shape, is_spectroscopic=True)
if verbose:
print('The shapes of the provided h5 position indices and values '
'are OK')
h5_spec_inds, h5_spec_vals = __ensure_anc_in_correct_file(h5_spec_inds, h5_spec_vals,
'Spectroscopic')
else:
aux_spec_prefix = __check_anc_before_creation(aux_spec_prefix, dim_type='spec')
spec_dims = validate_dimensions(spec_dims, dim_type='Spectroscopic')
validate_dims_against_main(main_shape, spec_dims, is_spectroscopic=True)
if verbose:
print('Passed all pre-tests for creating spectroscopic datasets')
h5_spec_inds, h5_spec_vals = write_ind_val_dsets(h5_parent_group, spec_dims, is_spectral=True, verbose=verbose,
slow_to_fast=slow_to_fast, base_name=aux_spec_prefix)
if verbose:
print('Created Spectroscopic datasets')
if h5_parent_group.file.driver == 'mpio':
if kwargs.pop('compression', None) is not None:
warn('This HDF5 file has been opened wth the "mpio" communicator. '
'mpi4py does not allow creation of compressed datasets. Compression kwarg has been removed')
if isinstance(main_data, np.ndarray):
# Case 1 - simple small dataset
h5_main = h5_parent_group.create_dataset(main_data_name, data=main_data, **kwargs)
if verbose:
print('Created main dataset with provided data')
elif isinstance(main_data, da.core.Array):
# Case 2 - Dask dataset
# step 0 - get rid of any automated dtype specification:
_ = kwargs.pop('dtype', None)
# step 1 - create the empty dataset:
h5_main = h5_parent_group.create_dataset(main_data_name, shape=main_data.shape, dtype=main_data.dtype,
**kwargs)
if verbose:
print('Created empty dataset: {} for writing Dask dataset: {}'.format(h5_main, main_data))
print('Dask array will be written to HDF5 dataset: "{}" in file: "{}"'.format(h5_main.name,
h5_main.file.filename))
# Step 2 - now ask Dask to dump data to disk
da.to_hdf5(h5_main.file.filename, {h5_main.name: main_data})
# main_data.to_hdf5(h5_main.file.filename, h5_main.name) # Does not work with python 2 for some reason
else:
# Case 3 - large empty dataset
h5_main = h5_parent_group.create_dataset(main_data_name, main_data, **kwargs)
if verbose:
print('Created empty dataset for Main')
write_simple_attrs(h5_main, {'quantity': quantity, 'units': units})
if verbose:
print('Wrote quantity and units attributes to main dataset')
if isinstance(main_dset_attrs, dict):
write_simple_attrs(h5_main, main_dset_attrs)
if verbose:
print('Wrote provided attributes to main dataset')
write_book_keeping_attrs(h5_main)
# make it main
link_as_main(h5_main, h5_pos_inds, h5_pos_vals, h5_spec_inds, h5_spec_vals)
if verbose:
print('Successfully linked datasets - dataset should be main now')
from ..usi_data import USIDataset
return USIDataset(h5_main)
def map_grid_to_cartesian(h5_main, grid_shape, mode='histogram', **kwargs):
"""
Map an incomplete measurement, such as a spiral scan, to a cartesian grid.
Parameters
----------
h5_main : :class:`pyUSID.USIDataset`
Dataset containing the sparse measurement
grid_shape : int or [int, int]
Shape of the output :class:`numpy.ndarray`.
mode : str, optional. Default = 'histogram'
Method used for building a cartesian grid.
Available methods = 'histogram', 'linear', 'nearest', 'cubic'
Use kwargs to pass onto each of the techniques
Note
----
UNDER DEVELOPMENT!
Currently only valid for 2 position dimensions
@author: <NAME>
Returns
-------
:class:`numpy.ndarray` but could be a h5py.Dataset or dask.array.core.Array object
"""
try:
from scipy.interpolate import griddata
except ImportError as expn:
griddata = None
warn('map_grid_to_cartesian() requires scipy')
raise expn
from ..usi_data import USIDataset
if not isinstance(h5_main, USIDataset):
raise TypeError('Provided object is not a pyUSID.USIDataset object')
if mode not in ['histogram', 'linear', 'nearest', 'cubic']:
raise ValueError('mode must be a string among["histogram", "cubic"]')
ds_main = h5_main[()].squeeze()
ds_pos_vals = h5_main.h5_pos_vals[()]
if ds_pos_vals.shape[1] != 2:
raise TypeError("Only working for 2 position dimensions.")
# Transform to row, col image format
rotation = np.array([[0, 1], [-1, 0]])
ds_pos_vals = np.dot(ds_pos_vals, rotation)
try:
grid_n = len(grid_shape)
except TypeError:
grid_n = 1
if grid_n != 1 and grid_n != 2:
raise ValueError("grid_shape must be of type int or [int, int].")
if grid_n == 1:
grid_shape = 2 * [grid_shape]
def interpolate(points, values, grid_shape, method):
grid_shape = list(map((1j).__mul__, grid_shape))
grid_x, grid_y = np.mgrid[
np.amin(points[:, 0]):np.amax(points[:, 0]):grid_shape[0],
np.amin(points[:, 1]):np.amax(points[:, 1]):grid_shape[1]
]
ndim_data = griddata(points, values, (grid_x, grid_y), method=method)
return ndim_data
if mode == "histogram":
histogram_weighted, _, _ = np.histogram2d(*ds_pos_vals.T, bins=grid_shape, weights=ds_main)
histogram, _, _ = np.histogram2d(*ds_pos_vals.T, bins=grid_shape)
cart_data = np.divide(histogram_weighted, histogram)
else:
cart_data = interpolate(ds_pos_vals, ds_main, grid_shape, method=mode)
return cart_data
def write_sidpy_dataset(si_dset, h5_parent_group, verbose=False,
**kwargs):
"""
Writes a sidpy.Dataset as a USID dataset in the provided HDF5 Group.
Please see notes about dimension types
Parameters
----------
si_dset: sidpy.Dataset
Dataset to be written to HDF5 in NSID format
h5_parent_group : class:`h5py.Group`
Parent group under which the datasets will be created
verbose : bool, Optional. Default = False
Whether or not to write logs to standard out
kwargs: dict
additional keyword arguments passed on to h5py when writing data
Returns
------
h5_main : USIDataset
Reference to the main dataset
Notes
-----
USID only has two dimension types - Position and Spectroscopic.
Consider changing the types of dimensions of all other dimensions to either
"SPATIAL" or "SPECTRAL".
"""
if not isinstance(si_dset, sid.Dataset):
raise TypeError('Data to write is not a sidpy dataset')
if not isinstance(h5_parent_group, (h5py.File, h5py.Group)):
raise TypeError('h5_parent_group is not a h5py.File or '
'h5py.Group object')
spatial_dims, spectral_dims, spatial_size, spectral_size = [], [], 1, 1
for dim_ind, dime in si_dset._axes.items():
if dime._dimension_type == sid.DimensionType.SPATIAL:
spatial_dims.append(Dimension(dime._name,
dime._units,
dime.values,
dime._quantity,
dime._dimension_type))
spatial_size *= np.size(dime.values)
else:
if not dime._dimension_type == sid.DimensionType.SPECTRAL:
warn('Will consider dimension: {} of type: {} as a '
'spectroscopic dimension'.format(dime._name,
dime._dimension_type))
spectral_dims.append(Dimension(dime._name,
dime._units,
dime.values,
dime._quantity,
dime._dimension_type))
spectral_size *= np.size(dime.values)
main_dataset = da.reshape(si_dset, [spatial_size, spectral_size])
# TODO : Consider writing this out as a separate group
main_dset_attr = {}
for attr_name in dir(si_dset):
attr_val = getattr(si_dset, attr_name)
if isinstance(attr_val, dict):
main_dset_attr.update(attr_val)
h5_main = write_main_dataset(h5_parent_group=h5_parent_group,
main_data=main_dataset,
main_data_name=si_dset.name,
quantity=si_dset.quantity,
units=si_dset.units,
pos_dims=spatial_dims,
spec_dims=spectral_dims,
main_dset_attrs=flatten_dict(main_dset_attr),
slow_to_fast=True,
verbose=verbose,
**kwargs)
return h5_main
|
[
"numpy.product",
"numpy.prod",
"sidpy.base.string_utils.validate_list_of_strings",
"numpy.hstack",
"numpy.argsort",
"numpy.array",
"numpy.divide",
"numpy.arange",
"numpy.atleast_2d",
"dask.array.reshape",
"sidpy.hdf.hdf_utils.copy_dataset",
"numpy.where",
"sidpy.hdf.hdf_utils.lazy_load_array",
"numpy.diff",
"numpy.dot",
"numpy.min",
"numpy.histogram2d",
"warnings.warn",
"sidpy.base.num_utils.contains_integers",
"numpy.amin",
"sidpy.base.dict_utils.flatten_dict",
"numpy.size",
"sidpy.hdf.hdf_utils.write_simple_attrs",
"dask.array.to_hdf5",
"numpy.transpose",
"sidpy.base.string_utils.validate_single_string_arg",
"sidpy.base.string_utils.validate_string_args",
"numpy.unique",
"scipy.interpolate.griddata",
"sidpy.hdf.hdf_utils.is_editable_h5",
"numpy.argwhere",
"sidpy.hdf.hdf_utils.get_attr",
"numpy.all",
"numpy.amax"
] |
[((4720, 4743), 'numpy.array', 'np.array', (["['Positions']"], {}), "(['Positions'])\n", (4728, 4743), True, 'import numpy as np\n'), ((4760, 4787), 'numpy.array', 'np.array', (["['Spectral_Step']"], {}), "(['Spectral_Step'])\n", (4768, 4787), True, 'import numpy as np\n'), ((10784, 10849), 'numpy.hstack', 'np.hstack', (['(pos_labs[pos_sort][::-1], spec_labs[spec_sort][::-1])'], {}), '((pos_labs[pos_sort][::-1], spec_labs[spec_sort][::-1]))\n', (10793, 10849), True, 'import numpy as np\n'), ((11683, 11702), 'numpy.array', 'np.array', (['swap_axes'], {}), '(swap_axes)\n', (11691, 11702), True, 'import numpy as np\n'), ((37647, 37747), 'sidpy.base.string_utils.validate_string_args', 'validate_string_args', (['[quantity, units, main_data_name]', "['quantity', 'units', 'main_data_name']"], {}), "([quantity, units, main_data_name], ['quantity',\n 'units', 'main_data_name'])\n", (37667, 37747), False, 'from sidpy.base.string_utils import validate_single_string_arg, validate_list_of_strings, validate_string_args\n'), ((43230, 43297), 'sidpy.hdf.hdf_utils.write_simple_attrs', 'write_simple_attrs', (['h5_main', "{'quantity': quantity, 'units': units}"], {}), "(h5_main, {'quantity': quantity, 'units': units})\n", (43248, 43297), False, 'from sidpy.hdf.hdf_utils import get_attr, write_simple_attrs, is_editable_h5, copy_dataset, lazy_load_array\n'), ((45420, 45447), 'numpy.array', 'np.array', (['[[0, 1], [-1, 0]]'], {}), '([[0, 1], [-1, 0]])\n', (45428, 45447), True, 'import numpy as np\n'), ((45466, 45495), 'numpy.dot', 'np.dot', (['ds_pos_vals', 'rotation'], {}), '(ds_pos_vals, rotation)\n', (45472, 45495), True, 'import numpy as np\n'), ((48943, 48993), 'dask.array.reshape', 'da.reshape', (['si_dset', '[spatial_size, spectral_size]'], {}), '(si_dset, [spatial_size, spectral_size])\n', (48953, 48993), True, 'from dask import array as da\n'), ((7906, 7926), 'numpy.transpose', 'np.transpose', (['ds_pos'], {}), '(ds_pos)\n', (7918, 7926), True, 'import numpy as np\n'), ((8295, 8315), 'numpy.transpose', 'np.transpose', (['ds_pos'], {}), '(ds_pos)\n', (8307, 8315), True, 'import numpy as np\n'), ((8390, 8407), 'numpy.prod', 'np.prod', (['pos_dims'], {}), '(pos_dims)\n', (8397, 8407), True, 'import numpy as np\n'), ((8773, 8791), 'numpy.prod', 'np.prod', (['spec_dims'], {}), '(spec_dims)\n', (8780, 8791), True, 'import numpy as np\n'), ((9502, 9526), 'sidpy.hdf.hdf_utils.lazy_load_array', 'lazy_load_array', (['h5_main'], {}), '(h5_main)\n', (9517, 9526), False, 'from sidpy.hdf.hdf_utils import get_attr, write_simple_attrs, is_editable_h5, copy_dataset, lazy_load_array\n'), ((21212, 21234), 'numpy.transpose', 'np.transpose', (['ds_index'], {}), '(ds_index)\n', (21224, 21234), True, 'import numpy as np\n'), ((21284, 21312), 'numpy.arange', 'np.arange', (['ds_index.shape[0]'], {}), '(ds_index.shape[0])\n', (21293, 21312), True, 'import numpy as np\n'), ((21472, 21492), 'numpy.array', 'np.array', (['index_sort'], {}), '(index_sort)\n', (21480, 21492), True, 'import numpy as np\n'), ((23028, 23049), 'numpy.transpose', 'np.transpose', (['ds_spec'], {}), '(ds_spec)\n', (23040, 23049), True, 'import numpy as np\n'), ((23175, 23199), 'numpy.argsort', 'np.argsort', (['change_count'], {}), '(change_count)\n', (23185, 23199), True, 'import numpy as np\n'), ((24753, 24809), 'sidpy.base.string_utils.validate_list_of_strings', 'validate_list_of_strings', (['all_dim_names', '"""all_dim_names"""'], {}), "(all_dim_names, 'all_dim_names')\n", (24777, 24809), False, 'from sidpy.base.string_utils import validate_single_string_arg, validate_list_of_strings, validate_string_args\n'), ((24834, 24857), 'numpy.array', 'np.array', (['all_dim_names'], {}), '(all_dim_names)\n', (24842, 24857), True, 'import numpy as np\n'), ((26949, 26976), 'sidpy.hdf.hdf_utils.get_attr', 'get_attr', (['ds_inds', '"""labels"""'], {}), "(ds_inds, 'labels')\n", (26957, 26976), False, 'from sidpy.hdf.hdf_utils import get_attr, write_simple_attrs, is_editable_h5, copy_dataset, lazy_load_array\n'), ((27706, 27728), 'numpy.transpose', 'np.transpose', (['inds_mat'], {}), '(inds_mat)\n', (27718, 27728), True, 'import numpy as np\n'), ((27748, 27770), 'numpy.transpose', 'np.transpose', (['vals_mat'], {}), '(vals_mat)\n', (27760, 27770), True, 'import numpy as np\n'), ((28202, 28250), 'sidpy.base.string_utils.validate_list_of_strings', 'validate_list_of_strings', (['dim_names', '"""dim_names"""'], {}), "(dim_names, 'dim_names')\n", (28226, 28250), False, 'from sidpy.base.string_utils import validate_single_string_arg, validate_list_of_strings, validate_string_args\n'), ((35582, 35651), 'sidpy.base.string_utils.validate_single_string_arg', 'validate_single_string_arg', (['aux_prefix', "('aux_' + dim_type + '_prefix')"], {}), "(aux_prefix, 'aux_' + dim_type + '_prefix')\n", (35608, 35651), False, 'from sidpy.base.string_utils import validate_single_string_arg, validate_list_of_strings, validate_string_args\n'), ((37459, 37490), 'sidpy.hdf.hdf_utils.is_editable_h5', 'is_editable_h5', (['h5_parent_group'], {}), '(h5_parent_group)\n', (37473, 37490), False, 'from sidpy.hdf.hdf_utils import get_attr, write_simple_attrs, is_editable_h5, copy_dataset, lazy_load_array\n'), ((43434, 43478), 'sidpy.hdf.hdf_utils.write_simple_attrs', 'write_simple_attrs', (['h5_main', 'main_dset_attrs'], {}), '(h5_main, main_dset_attrs)\n', (43452, 43478), False, 'from sidpy.hdf.hdf_utils import get_attr, write_simple_attrs, is_editable_h5, copy_dataset, lazy_load_array\n'), ((46071, 46128), 'scipy.interpolate.griddata', 'griddata', (['points', 'values', '(grid_x, grid_y)'], {'method': 'method'}), '(points, values, (grid_x, grid_y), method=method)\n', (46079, 46128), False, 'from scipy.interpolate import griddata\n'), ((46219, 46283), 'numpy.histogram2d', 'np.histogram2d', (['*ds_pos_vals.T'], {'bins': 'grid_shape', 'weights': 'ds_main'}), '(*ds_pos_vals.T, bins=grid_shape, weights=ds_main)\n', (46233, 46283), True, 'import numpy as np\n'), ((46310, 46357), 'numpy.histogram2d', 'np.histogram2d', (['*ds_pos_vals.T'], {'bins': 'grid_shape'}), '(*ds_pos_vals.T, bins=grid_shape)\n', (46324, 46357), True, 'import numpy as np\n'), ((46378, 46418), 'numpy.divide', 'np.divide', (['histogram_weighted', 'histogram'], {}), '(histogram_weighted, histogram)\n', (46387, 46418), True, 'import numpy as np\n'), ((5961, 5987), 'sidpy.hdf.hdf_utils.get_attr', 'get_attr', (['h5_pos', '"""labels"""'], {}), "(h5_pos, 'labels')\n", (5969, 5987), False, 'from sidpy.hdf.hdf_utils import get_attr, write_simple_attrs, is_editable_h5, copy_dataset, lazy_load_array\n'), ((7499, 7526), 'sidpy.hdf.hdf_utils.get_attr', 'get_attr', (['h5_spec', '"""labels"""'], {}), "(h5_spec, 'labels')\n", (7507, 7526), False, 'from sidpy.hdf.hdf_utils import get_attr, write_simple_attrs, is_editable_h5, copy_dataset, lazy_load_array\n'), ((8698, 8715), 'numpy.prod', 'np.prod', (['pos_dims'], {}), '(pos_dims)\n', (8705, 8715), True, 'import numpy as np\n'), ((9089, 9107), 'numpy.prod', 'np.prod', (['spec_dims'], {}), '(spec_dims)\n', (9096, 9107), True, 'import numpy as np\n'), ((10126, 10241), 'warnings.warn', 'warn', (['"""Could not reshape dataset to full N-dimensional form. Attempting reshape based on position only."""'], {}), "(\n 'Could not reshape dataset to full N-dimensional form. Attempting reshape based on position only.'\n )\n", (10130, 10241), False, 'from warnings import warn\n'), ((15784, 15835), 'numpy.all', 'np.all', (['[(x in data_n_dim.shape) for x in pos_dims]'], {}), '([(x in data_n_dim.shape) for x in pos_dims])\n', (15790, 15835), True, 'import numpy as np\n'), ((18946, 18966), 'numpy.transpose', 'np.transpose', (['ds_pos'], {}), '(ds_pos)\n', (18958, 18966), True, 'import numpy as np\n'), ((21338, 21378), 'sidpy.base.num_utils.contains_integers', 'contains_integers', (['index_sort'], {'min_val': '(0)'}), '(index_sort, min_val=0)\n', (21355, 21378), False, 'from sidpy.base.num_utils import contains_integers\n'), ((22129, 22143), 'numpy.unique', 'np.unique', (['row'], {}), '(row)\n', (22138, 22143), True, 'import numpy as np\n'), ((26377, 26404), 'sidpy.hdf.hdf_utils.get_attr', 'get_attr', (['ds_inds', '"""labels"""'], {}), "(ds_inds, 'labels')\n", (26385, 26404), False, 'from sidpy.hdf.hdf_utils import get_attr, write_simple_attrs, is_editable_h5, copy_dataset, lazy_load_array\n'), ((30293, 30317), 'numpy.where', 'np.where', (['(step_sizes > 1)'], {}), '(step_sizes > 1)\n', (30301, 30317), True, 'import numpy as np\n'), ((30738, 30775), 'numpy.hstack', 'np.hstack', (['([0], starts[tile_starts])'], {}), '(([0], starts[tile_starts]))\n', (30747, 30775), True, 'import numpy as np\n'), ((38296, 38335), 'sidpy.base.num_utils.contains_integers', 'contains_integers', (['main_data'], {'min_val': '(1)'}), '(main_data, min_val=1)\n', (38313, 38335), False, 'from sidpy.base.num_utils import contains_integers\n'), ((41613, 41780), 'warnings.warn', 'warn', (['"""This HDF5 file has been opened wth the "mpio" communicator. mpi4py does not allow creation of compressed datasets. Compression kwarg has been removed"""'], {}), '(\n \'This HDF5 file has been opened wth the "mpio" communicator. mpi4py does not allow creation of compressed datasets. Compression kwarg has been removed\'\n )\n', (41617, 41780), False, 'from warnings import warn\n'), ((42845, 42905), 'dask.array.to_hdf5', 'da.to_hdf5', (['h5_main.file.filename', '{h5_main.name: main_data}'], {}), '(h5_main.file.filename, {h5_main.name: main_data})\n', (42855, 42905), True, 'from dask import array as da\n'), ((44812, 44858), 'warnings.warn', 'warn', (['"""map_grid_to_cartesian() requires scipy"""'], {}), "('map_grid_to_cartesian() requires scipy')\n", (44816, 44858), False, 'from warnings import warn\n'), ((48253, 48273), 'numpy.size', 'np.size', (['dime.values'], {}), '(dime.values)\n', (48260, 48273), True, 'import numpy as np\n'), ((48902, 48922), 'numpy.size', 'np.size', (['dime.values'], {}), '(dime.values)\n', (48909, 48922), True, 'import numpy as np\n'), ((49706, 49734), 'sidpy.base.dict_utils.flatten_dict', 'flatten_dict', (['main_dset_attr'], {}), '(main_dset_attr)\n', (49718, 49734), False, 'from sidpy.base.dict_utils import flatten_dict\n'), ((5100, 5126), 'sidpy.hdf.hdf_utils.get_attr', 'get_attr', (['h5_pos', '"""labels"""'], {}), "(h5_pos, 'labels')\n", (5108, 5126), False, 'from sidpy.hdf.hdf_utils import get_attr, write_simple_attrs, is_editable_h5, copy_dataset, lazy_load_array\n'), ((6063, 6084), 'numpy.atleast_2d', 'np.atleast_2d', (['h5_pos'], {}), '(h5_pos)\n', (6076, 6084), True, 'import numpy as np\n'), ((6606, 6633), 'sidpy.hdf.hdf_utils.get_attr', 'get_attr', (['h5_spec', '"""labels"""'], {}), "(h5_spec, 'labels')\n", (6614, 6633), False, 'from sidpy.hdf.hdf_utils import get_attr, write_simple_attrs, is_editable_h5, copy_dataset, lazy_load_array\n'), ((16738, 16790), 'numpy.all', 'np.all', (['[(x in data_n_dim.shape) for x in spec_dims]'], {}), '([(x in data_n_dim.shape) for x in spec_dims])\n', (16744, 16790), True, 'import numpy as np\n'), ((21605, 21626), 'numpy.unique', 'np.unique', (['index_sort'], {}), '(index_sort)\n', (21614, 21626), True, 'import numpy as np\n'), ((21876, 21904), 'numpy.arange', 'np.arange', (['ds_index.shape[0]'], {}), '(ds_index.shape[0])\n', (21885, 21904), True, 'import numpy as np\n'), ((22156, 22183), 'numpy.array', 'np.array', (['ds_index'], {'ndmin': '(2)'}), '(ds_index, ndmin=2)\n', (22164, 22183), True, 'import numpy as np\n'), ((25418, 25460), 'sidpy.hdf.hdf_utils.get_attr', 'get_attr', (['ds_inds', '"""incomplete_dimensions"""'], {}), "(ds_inds, 'incomplete_dimensions')\n", (25426, 25460), False, 'from sidpy.hdf.hdf_utils import get_attr, write_simple_attrs, is_editable_h5, copy_dataset, lazy_load_array\n'), ((25582, 25624), 'sidpy.hdf.hdf_utils.get_attr', 'get_attr', (['ds_vals', '"""incomplete_dimensions"""'], {}), "(ds_vals, 'incomplete_dimensions')\n", (25590, 25624), False, 'from sidpy.hdf.hdf_utils import get_attr, write_simple_attrs, is_editable_h5, copy_dataset, lazy_load_array\n'), ((29009, 29044), 'numpy.where', 'np.where', (['(all_dim_names == dim_name)'], {}), '(all_dim_names == dim_name)\n', (29017, 29044), True, 'import numpy as np\n'), ((29642, 29657), 'numpy.diff', 'np.diff', (['starts'], {}), '(starts)\n', (29649, 29657), True, 'import numpy as np\n'), ((37130, 37179), 'sidpy.hdf.hdf_utils.copy_dataset', 'copy_dataset', (['x', 'h5_parent_group'], {'verbose': 'verbose'}), '(x, h5_parent_group, verbose=verbose)\n', (37142, 37179), False, 'from sidpy.hdf.hdf_utils import get_attr, write_simple_attrs, is_editable_h5, copy_dataset, lazy_load_array\n'), ((5634, 5682), 'numpy.arange', 'np.arange', (['h5_main.shape[0]'], {'dtype': 'INDICES_DTYPE'}), '(h5_main.shape[0], dtype=INDICES_DTYPE)\n', (5643, 5682), True, 'import numpy as np\n'), ((7156, 7204), 'numpy.arange', 'np.arange', (['h5_main.shape[1]'], {'dtype': 'INDICES_DTYPE'}), '(h5_main.shape[1], dtype=INDICES_DTYPE)\n', (7165, 7204), True, 'import numpy as np\n'), ((10344, 10420), 'warnings.warn', 'warn', (['"""Reshape by position only also failed. Will keep dataset in 2d form."""'], {}), "('Reshape by position only also failed. Will keep dataset in 2d form.')\n", (10348, 10420), False, 'from warnings import warn\n'), ((11531, 11561), 'numpy.argwhere', 'np.argwhere', (['(all_labels == lab)'], {}), '(all_labels == lab)\n', (11542, 11561), True, 'import numpy as np\n'), ((11624, 11654), 'numpy.argwhere', 'np.argwhere', (['(all_labels == lab)'], {}), '(all_labels == lab)\n', (11635, 11654), True, 'import numpy as np\n'), ((17463, 17491), 'numpy.product', 'np.product', (['data_n_dim.shape'], {}), '(data_n_dim.shape)\n', (17473, 17491), True, 'import numpy as np\n'), ((29209, 29229), 'numpy.min', 'np.min', (['inds_for_dim'], {}), '(inds_for_dim)\n', (29215, 29229), True, 'import numpy as np\n'), ((31162, 31190), 'numpy.diff', 'np.diff', (['subsections'], {'axis': '(0)'}), '(subsections, axis=0)\n', (31169, 31190), True, 'import numpy as np\n'), ((45912, 45933), 'numpy.amin', 'np.amin', (['points[:, 0]'], {}), '(points[:, 0])\n', (45919, 45933), True, 'import numpy as np\n'), ((45934, 45955), 'numpy.amax', 'np.amax', (['points[:, 0]'], {}), '(points[:, 0])\n', (45941, 45955), True, 'import numpy as np\n'), ((45983, 46004), 'numpy.amin', 'np.amin', (['points[:, 1]'], {}), '(points[:, 1])\n', (45990, 46004), True, 'import numpy as np\n'), ((46005, 46026), 'numpy.amax', 'np.amax', (['points[:, 1]'], {}), '(points[:, 1])\n', (46012, 46026), True, 'import numpy as np\n'), ((21817, 21838), 'numpy.unique', 'np.unique', (['index_sort'], {}), '(index_sort)\n', (21826, 21838), True, 'import numpy as np\n'), ((17848, 17876), 'numpy.product', 'np.product', (['data_n_dim.shape'], {}), '(data_n_dim.shape)\n', (17858, 17876), True, 'import numpy as np\n'), ((30136, 30157), 'numpy.unique', 'np.unique', (['step_sizes'], {}), '(step_sizes)\n', (30145, 30157), True, 'import numpy as np\n'), ((5321, 5369), 'numpy.arange', 'np.arange', (['h5_main.shape[0]'], {'dtype': 'INDICES_DTYPE'}), '(h5_main.shape[0], dtype=INDICES_DTYPE)\n', (5330, 5369), True, 'import numpy as np\n'), ((5551, 5583), 'numpy.array', 'np.array', (['(0)'], {'dtype': 'INDICES_DTYPE'}), '(0, dtype=INDICES_DTYPE)\n', (5559, 5583), True, 'import numpy as np\n'), ((6834, 6882), 'numpy.arange', 'np.arange', (['h5_main.shape[1]'], {'dtype': 'INDICES_DTYPE'}), '(h5_main.shape[1], dtype=INDICES_DTYPE)\n', (6843, 6882), True, 'import numpy as np\n'), ((7071, 7103), 'numpy.array', 'np.array', (['(0)'], {'dtype': 'INDICES_DTYPE'}), '(0, dtype=INDICES_DTYPE)\n', (7079, 7103), True, 'import numpy as np\n'), ((31659, 31678), 'numpy.diff', 'np.diff', (['subsection'], {}), '(subsection)\n', (31666, 31678), True, 'import numpy as np\n')]
|
import numpy as np
import scipy
import scipy.linalg as linalg
import scipy.spatial
import scipy.special
import scipy.optimize
import sklearn
def bases(name):
if name == 'linear':
f = lambda x: x
elif name == 'cubic':
f = lambda x: x**3
elif name == 'multiquadric':
f = lambda x, s: np.sqrt((1.0/s*x)**2 + 1)
elif name == 'thin_plate':
f = lambda x: scipy.special.xlogy(x**2, x)
elif name == 'gaussian':
f = lambda x, s: np.exp(-(1.0/s*x)**2)
elif name == 'inverse_multiquadric':
f = lambda x, s: 1.0/np.sqrt((1.0/s*x)**2 + 1)
else:
raise ValueError('Basis not recognised.')
return f
class RbfInterpolator:
"""
Standard RBF interpolation / kernel smoothing.
Written to replace Scipy's Rbf class, which has a silly interface and is difficult to modify
Also includes optional optimization of the "smooth" parameter
Author: <NAME> -- 2018
"""
def __init__(self, norm='euclidean', rbf=lambda r: r, smooth=0.0, optimize_smoothing=False):
self.norm = norm
self.rbf = rbf
self.smooth = smooth
self.optimize_smoothing = optimize_smoothing
def _opt_smooth(self):
# We're just using cross-validation and retraining the whole model.
# Likely a lot of improvements possible
def obj(x):
ss = sklearn.model_selection.ShuffleSplit(n_splits=5, test_size=.3)
for tri, tei in ss.split(self._X_train):
K = scipy.spatial.distance.squareform(scipy.spatial.distance.pdist(self._X_train[tri,:], self.norm))
K = self.rbf(K)
K -= np.eye(K.shape[0]) * x
nodes = None
rcond = 1/np.linalg.cond(K)
if rcond > 1e-10: # If the matrix is not singular, (i.e. most of the time)
try:
nodes = linalg.solve(K, self._y_train[tri], sym_pos=True)
except linalg.LinAlgError: pass
if nodes is None:
nodes = linalg.lstsq(K, self._y_train[tri])[0]
K = scipy.spatial.distance.cdist(self._X_train[tei,:], self._X_train[tri,:], self.norm)
K = self.rbf(K)
return np.sum((self._y_train[tei] - np.dot(K, nodes))**2)
opt_param = scipy.optimize.minimize_scalar(obj, bounds=[.0001,100], bracket=[0.0001,100])
self.smooth = opt_param.x
def _make_kernel(self, new_X=None):
if new_X is None:
K = scipy.spatial.distance.squareform(scipy.spatial.distance.pdist(self._X_train, self.norm))
else:
K = scipy.spatial.distance.cdist(new_X, self._X_train, self.norm)
K = self.rbf(K)
if new_X is None and self.smooth != 0:
K -= np.eye(K.shape[0])*self.smooth
return K
def fit(self, X, y):
self._X_train = X
self._y_train = y
if len(self._X_train.shape) == 1:
self._X_train = self._X_train[:,np.newaxis]
if self.optimize_smoothing:
self._opt_smooth()
self.K = self._make_kernel()
nodes = None
rcond = 1/np.linalg.cond(self.K)
if rcond > 1e-10:
try:
self.nodes = linalg.solve(self.K, self._y_train, sym_pos=True)
except linalg.LinAlgError: pass
if nodes is None:
self.nodes = linalg.lstsq(self.K, self._y_train)[0]
def predict(self, X):
if len(X.shape) == 1:
X = X[:,np.newaxis]
K = self._make_kernel(X)
return np.dot(K, self.nodes)
class RBFConsensus:
def __init__(self,
sample_frac=.6,
subsample_rounds=32,
radial_basis_function=lambda x:x,
norm='euclidean',
copy_data=True,
categorical_features=None):
self.sample_frac = sample_frac # What fraction of data to sample for each subsampling round
self.subsample_rounds = subsample_rounds # How many rounds
self.radial_basis_function = radial_basis_function # which interpolator ("linear" with euclidean norm is linear interpolation)
self.norm = norm # Which distance function is appropriate?
self.copy_data = copy_data # Should input data be copied, or refed?
self.N = None
self.trained_smooth_param = None
self.categorical_features = categorical_features
def _fit_one(self, X, y, optimize_smoothing=False):
self.rbfis_by_dim = []
for dim in range(y.shape[1]):
# Use previously optimized smoothing unless optimize_smoothing == True
if self.trained_smooth_param is None:
rbfi = RbfInterpolator(rbf=self.radial_basis_function, norm=self.norm, optimize_smoothing=optimize_smoothing)
else:
rbfi = RbfInterpolator(smooth=self.trained_smooth_param[dim], rbf=self.radial_basis_function, norm=self.norm, optimize_smoothing=optimize_smoothing)
rbfi.fit(X,y[:,dim])
self.rbfis_by_dim.append(rbfi)
if optimize_smoothing: # This means we have optimized params available
self.trained_smooth_param = [self.rbfis_by_dim[dim].smooth for dim in range(y.shape[1])]
return self
def _predict_one(self, X):
if len(X.shape) == 1:
Xp = X[:,np.newaxis]
else:
Xp = X
pred = np.empty([Xp.shape[0], self._y_train.shape[1]])
for dim in range(len(self.rbfis_by_dim)):
pred[:,dim] = self.rbfis_by_dim[dim].predict(X).squeeze()
return pred
def fit(self, X, y):
self._y_train = y.copy() if self.copy_data else y
self._X_train = X.copy() if self.copy_data else X
if len(self._y_train.shape) == 1:
self._y_train = self._y_train[:,np.newaxis]
if len(self._X_train.shape) == 1:
self._X_train = self._X_train[:,np.newaxis]
self.N = X.shape[0]
def predict(self, X, return_std=False):
if self.N is None:
raise RuntimeError('`.fit` must be called before `.predict`')
N_samp = int(np.ceil(self.N * self.sample_frac))
y_pred = np.empty([X.shape[0], self._y_train.shape[1], self.subsample_rounds])
# np.random.seed(7)
for i in range(self.subsample_rounds):
r = np.random.permutation(self.N)[:N_samp]
y_sub = self._y_train[r,:]
X_sub = self._X_train[r,:]
self._fit_one(X_sub, y_sub)
y_pred[:,:,i] = self._predict_one(X)
y_out = y_pred.mean(axis=2)
if return_std:
y_std = np.sqrt(y_pred.var(axis=2).sum(axis=1))
return y_out, y_std
else:
return y_out
def RBF_unit_test():
import matplotlib.pyplot as plt
import time
# Generate synthetic 1-d data
N = 300
lo = -10.0
hi = 10.0
t = np.linspace(lo,hi,N)
y = np.sin(t*.5) - .08*t**2 + np.random.randn(t.shape[0])*.05*(t-lo)
# Messy fitting
model = RBFConsensus(radial_basis_function=lambda x:bases('inverse_multiquadric')(x,.2))
t0 = time.time()
model.fit(t,y)
y_pred, y_std = model.predict(t, return_std=True)
print(time.time()-t0)
y_pred = y_pred.squeeze()
y_std = y_std.squeeze()
plt.fill_between(t, y_pred - 5*y_std, y_pred + 5*y_std, alpha=0.15, color='k')
plt.scatter(t,y)
plt.plot(t, y_pred, color='red')
plt.show()
|
[
"scipy.special.xlogy",
"numpy.sqrt",
"numpy.linalg.cond",
"matplotlib.pyplot.fill_between",
"numpy.sin",
"scipy.linalg.lstsq",
"matplotlib.pyplot.plot",
"sklearn.model_selection.ShuffleSplit",
"numpy.exp",
"numpy.linspace",
"numpy.dot",
"numpy.empty",
"scipy.optimize.minimize_scalar",
"matplotlib.pyplot.scatter",
"numpy.random.permutation",
"numpy.ceil",
"numpy.eye",
"scipy.spatial.distance.pdist",
"time.time",
"numpy.random.randn",
"matplotlib.pyplot.show",
"scipy.spatial.distance.cdist",
"scipy.linalg.solve"
] |
[((7360, 7382), 'numpy.linspace', 'np.linspace', (['lo', 'hi', 'N'], {}), '(lo, hi, N)\n', (7371, 7382), True, 'import numpy as np\n'), ((7582, 7593), 'time.time', 'time.time', ([], {}), '()\n', (7591, 7593), False, 'import time\n'), ((7757, 7843), 'matplotlib.pyplot.fill_between', 'plt.fill_between', (['t', '(y_pred - 5 * y_std)', '(y_pred + 5 * y_std)'], {'alpha': '(0.15)', 'color': '"""k"""'}), "(t, y_pred - 5 * y_std, y_pred + 5 * y_std, alpha=0.15,\n color='k')\n", (7773, 7843), True, 'import matplotlib.pyplot as plt\n'), ((7840, 7857), 'matplotlib.pyplot.scatter', 'plt.scatter', (['t', 'y'], {}), '(t, y)\n', (7851, 7857), True, 'import matplotlib.pyplot as plt\n'), ((7861, 7893), 'matplotlib.pyplot.plot', 'plt.plot', (['t', 'y_pred'], {'color': '"""red"""'}), "(t, y_pred, color='red')\n", (7869, 7893), True, 'import matplotlib.pyplot as plt\n'), ((7899, 7909), 'matplotlib.pyplot.show', 'plt.show', ([], {}), '()\n', (7907, 7909), True, 'import matplotlib.pyplot as plt\n'), ((2392, 2477), 'scipy.optimize.minimize_scalar', 'scipy.optimize.minimize_scalar', (['obj'], {'bounds': '[0.0001, 100]', 'bracket': '[0.0001, 100]'}), '(obj, bounds=[0.0001, 100], bracket=[0.0001, 100]\n )\n', (2422, 2477), False, 'import scipy\n'), ((3729, 3750), 'numpy.dot', 'np.dot', (['K', 'self.nodes'], {}), '(K, self.nodes)\n', (3735, 3750), True, 'import numpy as np\n'), ((5721, 5768), 'numpy.empty', 'np.empty', (['[Xp.shape[0], self._y_train.shape[1]]'], {}), '([Xp.shape[0], self._y_train.shape[1]])\n', (5729, 5768), True, 'import numpy as np\n'), ((6582, 6651), 'numpy.empty', 'np.empty', (['[X.shape[0], self._y_train.shape[1], self.subsample_rounds]'], {}), '([X.shape[0], self._y_train.shape[1], self.subsample_rounds])\n', (6590, 6651), True, 'import numpy as np\n'), ((1385, 1448), 'sklearn.model_selection.ShuffleSplit', 'sklearn.model_selection.ShuffleSplit', ([], {'n_splits': '(5)', 'test_size': '(0.3)'}), '(n_splits=5, test_size=0.3)\n', (1421, 1448), False, 'import sklearn\n'), ((2711, 2772), 'scipy.spatial.distance.cdist', 'scipy.spatial.distance.cdist', (['new_X', 'self._X_train', 'self.norm'], {}), '(new_X, self._X_train, self.norm)\n', (2739, 2772), False, 'import scipy\n'), ((3295, 3317), 'numpy.linalg.cond', 'np.linalg.cond', (['self.K'], {}), '(self.K)\n', (3309, 3317), True, 'import numpy as np\n'), ((6528, 6562), 'numpy.ceil', 'np.ceil', (['(self.N * self.sample_frac)'], {}), '(self.N * self.sample_frac)\n', (6535, 6562), True, 'import numpy as np\n'), ((7389, 7404), 'numpy.sin', 'np.sin', (['(t * 0.5)'], {}), '(t * 0.5)\n', (7395, 7404), True, 'import numpy as np\n'), ((7677, 7688), 'time.time', 'time.time', ([], {}), '()\n', (7686, 7688), False, 'import time\n'), ((2172, 2261), 'scipy.spatial.distance.cdist', 'scipy.spatial.distance.cdist', (['self._X_train[tei, :]', 'self._X_train[tri, :]', 'self.norm'], {}), '(self._X_train[tei, :], self._X_train[tri, :],\n self.norm)\n', (2200, 2261), False, 'import scipy\n'), ((2625, 2679), 'scipy.spatial.distance.pdist', 'scipy.spatial.distance.pdist', (['self._X_train', 'self.norm'], {}), '(self._X_train, self.norm)\n', (2653, 2679), False, 'import scipy\n'), ((2883, 2901), 'numpy.eye', 'np.eye', (['K.shape[0]'], {}), '(K.shape[0])\n', (2889, 2901), True, 'import numpy as np\n'), ((3390, 3439), 'scipy.linalg.solve', 'linalg.solve', (['self.K', 'self._y_train'], {'sym_pos': '(True)'}), '(self.K, self._y_train, sym_pos=True)\n', (3402, 3439), True, 'import scipy.linalg as linalg\n'), ((3535, 3570), 'scipy.linalg.lstsq', 'linalg.lstsq', (['self.K', 'self._y_train'], {}), '(self.K, self._y_train)\n', (3547, 3570), True, 'import scipy.linalg as linalg\n'), ((6753, 6782), 'numpy.random.permutation', 'np.random.permutation', (['self.N'], {}), '(self.N)\n', (6774, 6782), True, 'import numpy as np\n'), ((7415, 7442), 'numpy.random.randn', 'np.random.randn', (['t.shape[0]'], {}), '(t.shape[0])\n', (7430, 7442), True, 'import numpy as np\n'), ((320, 351), 'numpy.sqrt', 'np.sqrt', (['((1.0 / s * x) ** 2 + 1)'], {}), '((1.0 / s * x) ** 2 + 1)\n', (327, 351), True, 'import numpy as np\n'), ((1555, 1617), 'scipy.spatial.distance.pdist', 'scipy.spatial.distance.pdist', (['self._X_train[tri, :]', 'self.norm'], {}), '(self._X_train[tri, :], self.norm)\n', (1583, 1617), False, 'import scipy\n'), ((1671, 1689), 'numpy.eye', 'np.eye', (['K.shape[0]'], {}), '(K.shape[0])\n', (1677, 1689), True, 'import numpy as np\n'), ((1766, 1783), 'numpy.linalg.cond', 'np.linalg.cond', (['K'], {}), '(K)\n', (1780, 1783), True, 'import numpy as np\n'), ((399, 429), 'scipy.special.xlogy', 'scipy.special.xlogy', (['(x ** 2)', 'x'], {}), '(x ** 2, x)\n', (418, 429), False, 'import scipy\n'), ((1932, 1981), 'scipy.linalg.solve', 'linalg.solve', (['K', 'self._y_train[tri]'], {'sym_pos': '(True)'}), '(K, self._y_train[tri], sym_pos=True)\n', (1944, 1981), True, 'import scipy.linalg as linalg\n'), ((2096, 2131), 'scipy.linalg.lstsq', 'linalg.lstsq', (['K', 'self._y_train[tri]'], {}), '(K, self._y_train[tri])\n', (2108, 2131), True, 'import scipy.linalg as linalg\n'), ((2341, 2357), 'numpy.dot', 'np.dot', (['K', 'nodes'], {}), '(K, nodes)\n', (2347, 2357), True, 'import numpy as np\n'), ((482, 509), 'numpy.exp', 'np.exp', (['(-(1.0 / s * x) ** 2)'], {}), '(-(1.0 / s * x) ** 2)\n', (488, 509), True, 'import numpy as np\n'), ((574, 605), 'numpy.sqrt', 'np.sqrt', (['((1.0 / s * x) ** 2 + 1)'], {}), '((1.0 / s * x) ** 2 + 1)\n', (581, 605), True, 'import numpy as np\n')]
|
"""Tests for qr.py."""
from jax import lax
import jax.numpy as jnp
import numpy as np
import pytest
import tempfile
from distla_core.linalg.utils import testutils
from distla_core.linalg.qr import qr_ooc
from distla_core.utils import pops
DTYPE = jnp.float32
seeds = [0, 1]
flags = [True, False]
def _dephase_qr(R, Q=None):
""" Maps the Q and R factor from an arbitrary QR decomposition to the unique
with non-negative diagonal entries.
"""
phases_data = np.sign(np.diagonal(R))
m, n = R.shape
if m > n:
phases = np.ones(m)
phases[:n] = phases_data
else:
phases = phases_data
R = phases.conj()[:, None] * R
if Q is not None:
Q = Q * phases
return Q, R
@pytest.mark.parametrize("N", [8, 32, 128])
@pytest.mark.parametrize("aspect_ratio", [1, 2, 10])
@pytest.mark.parametrize("panel_size", [1, 2])
@pytest.mark.parametrize("seed", [0, 1])
def test_qr_ooc(N, aspect_ratio, panel_size, seed):
dtype = np.float32
M = N * aspect_ratio
np.random.seed(seed)
A = np.random.randn(M, N).astype(dtype)
_, expected = np.linalg.qr(A)
_, expected = _dephase_qr(expected)
with tempfile.NamedTemporaryFile(delete=False) as f:
np.save(f, A)
f.close() # Explicit close needed to open again as a memmap.
# The file is still deleted when the context goes out of scope.
result = qr_ooc.qr_ooc(f.name, caqr_panel_size=panel_size)
result = pops.undistribute(result)
_, result = _dephase_qr(result)
atol = testutils.eps(lax.Precision.HIGHEST, dtype=dtype)
atol *= np.linalg.norm(A) ** 2
testutils.assert_allclose(result, expected, atol=atol)
@pytest.mark.parametrize("N", [8, 32, 128])
@pytest.mark.parametrize("aspect_ratio", [1, 2, 10])
@pytest.mark.parametrize("panel_size", [1, 2])
@pytest.mark.parametrize("seed", [0, 1])
def test_fake_cholesky(N, aspect_ratio, panel_size, seed):
fname = "fake_cholesky_test_matrix"
dtype = np.float32
M = N * aspect_ratio
np.random.seed(seed)
A = np.random.randn(M, N).astype(dtype)
cond = np.linalg.cond(A)
expected_gram = np.dot(A.T, A)
expected_chol = np.linalg.cholesky(expected_gram).T
_, expected_chol = _dephase_qr(expected_chol)
np.save(fname, A)
fread = fname + ".npy"
chol_fname = "cholesky_transpose"
gram_fname = "gram_matrix"
qr_ooc.fake_cholesky(fread, caqr_panel_size=panel_size,
chol_fname=chol_fname, gram_fname=gram_fname)
result_gram = np.load(gram_fname + ".npy")
result_chol = np.load(chol_fname + ".npy")
_, result_chol = _dephase_qr(result_chol)
atol = testutils.eps(lax.Precision.HIGHEST, dtype=dtype)
atol *= cond * np.linalg.norm(expected_gram) ** 2
testutils.assert_allclose(result_chol, expected_chol, atol=10 * atol)
testutils.assert_allclose(result_gram, expected_gram, atol=atol)
|
[
"distla_core.linalg.utils.testutils.eps",
"distla_core.linalg.utils.testutils.assert_allclose",
"numpy.diagonal",
"numpy.linalg.qr",
"numpy.ones",
"distla_core.linalg.qr.qr_ooc.qr_ooc",
"numpy.linalg.cond",
"numpy.linalg.norm",
"pytest.mark.parametrize",
"distla_core.utils.pops.undistribute",
"numpy.dot",
"distla_core.linalg.qr.qr_ooc.fake_cholesky",
"numpy.random.seed",
"tempfile.NamedTemporaryFile",
"numpy.linalg.cholesky",
"numpy.load",
"numpy.random.randn",
"numpy.save"
] |
[((697, 739), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""N"""', '[8, 32, 128]'], {}), "('N', [8, 32, 128])\n", (720, 739), False, 'import pytest\n'), ((741, 792), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""aspect_ratio"""', '[1, 2, 10]'], {}), "('aspect_ratio', [1, 2, 10])\n", (764, 792), False, 'import pytest\n'), ((794, 839), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""panel_size"""', '[1, 2]'], {}), "('panel_size', [1, 2])\n", (817, 839), False, 'import pytest\n'), ((841, 880), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""seed"""', '[0, 1]'], {}), "('seed', [0, 1])\n", (864, 880), False, 'import pytest\n'), ((1618, 1660), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""N"""', '[8, 32, 128]'], {}), "('N', [8, 32, 128])\n", (1641, 1660), False, 'import pytest\n'), ((1662, 1713), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""aspect_ratio"""', '[1, 2, 10]'], {}), "('aspect_ratio', [1, 2, 10])\n", (1685, 1713), False, 'import pytest\n'), ((1715, 1760), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""panel_size"""', '[1, 2]'], {}), "('panel_size', [1, 2])\n", (1738, 1760), False, 'import pytest\n'), ((1762, 1801), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""seed"""', '[0, 1]'], {}), "('seed', [0, 1])\n", (1785, 1801), False, 'import pytest\n'), ((979, 999), 'numpy.random.seed', 'np.random.seed', (['seed'], {}), '(seed)\n', (993, 999), True, 'import numpy as np\n'), ((1058, 1073), 'numpy.linalg.qr', 'np.linalg.qr', (['A'], {}), '(A)\n', (1070, 1073), True, 'import numpy as np\n'), ((1404, 1429), 'distla_core.utils.pops.undistribute', 'pops.undistribute', (['result'], {}), '(result)\n', (1421, 1429), False, 'from distla_core.utils import pops\n'), ((1474, 1523), 'distla_core.linalg.utils.testutils.eps', 'testutils.eps', (['lax.Precision.HIGHEST'], {'dtype': 'dtype'}), '(lax.Precision.HIGHEST, dtype=dtype)\n', (1487, 1523), False, 'from distla_core.linalg.utils import testutils\n'), ((1560, 1614), 'distla_core.linalg.utils.testutils.assert_allclose', 'testutils.assert_allclose', (['result', 'expected'], {'atol': 'atol'}), '(result, expected, atol=atol)\n', (1585, 1614), False, 'from distla_core.linalg.utils import testutils\n'), ((1945, 1965), 'numpy.random.seed', 'np.random.seed', (['seed'], {}), '(seed)\n', (1959, 1965), True, 'import numpy as np\n'), ((2017, 2034), 'numpy.linalg.cond', 'np.linalg.cond', (['A'], {}), '(A)\n', (2031, 2034), True, 'import numpy as np\n'), ((2053, 2067), 'numpy.dot', 'np.dot', (['A.T', 'A'], {}), '(A.T, A)\n', (2059, 2067), True, 'import numpy as np\n'), ((2173, 2190), 'numpy.save', 'np.save', (['fname', 'A'], {}), '(fname, A)\n', (2180, 2190), True, 'import numpy as np\n'), ((2284, 2390), 'distla_core.linalg.qr.qr_ooc.fake_cholesky', 'qr_ooc.fake_cholesky', (['fread'], {'caqr_panel_size': 'panel_size', 'chol_fname': 'chol_fname', 'gram_fname': 'gram_fname'}), '(fread, caqr_panel_size=panel_size, chol_fname=\n chol_fname, gram_fname=gram_fname)\n', (2304, 2390), False, 'from distla_core.linalg.qr import qr_ooc\n'), ((2425, 2453), 'numpy.load', 'np.load', (["(gram_fname + '.npy')"], {}), "(gram_fname + '.npy')\n", (2432, 2453), True, 'import numpy as np\n'), ((2470, 2498), 'numpy.load', 'np.load', (["(chol_fname + '.npy')"], {}), "(chol_fname + '.npy')\n", (2477, 2498), True, 'import numpy as np\n'), ((2553, 2602), 'distla_core.linalg.utils.testutils.eps', 'testutils.eps', (['lax.Precision.HIGHEST'], {'dtype': 'dtype'}), '(lax.Precision.HIGHEST, dtype=dtype)\n', (2566, 2602), False, 'from distla_core.linalg.utils import testutils\n'), ((2657, 2726), 'distla_core.linalg.utils.testutils.assert_allclose', 'testutils.assert_allclose', (['result_chol', 'expected_chol'], {'atol': '(10 * atol)'}), '(result_chol, expected_chol, atol=10 * atol)\n', (2682, 2726), False, 'from distla_core.linalg.utils import testutils\n'), ((2729, 2793), 'distla_core.linalg.utils.testutils.assert_allclose', 'testutils.assert_allclose', (['result_gram', 'expected_gram'], {'atol': 'atol'}), '(result_gram, expected_gram, atol=atol)\n', (2754, 2793), False, 'from distla_core.linalg.utils import testutils\n'), ((477, 491), 'numpy.diagonal', 'np.diagonal', (['R'], {}), '(R)\n', (488, 491), True, 'import numpy as np\n'), ((535, 545), 'numpy.ones', 'np.ones', (['m'], {}), '(m)\n', (542, 545), True, 'import numpy as np\n'), ((1119, 1160), 'tempfile.NamedTemporaryFile', 'tempfile.NamedTemporaryFile', ([], {'delete': '(False)'}), '(delete=False)\n', (1146, 1160), False, 'import tempfile\n'), ((1171, 1184), 'numpy.save', 'np.save', (['f', 'A'], {}), '(f, A)\n', (1178, 1184), True, 'import numpy as np\n'), ((1343, 1392), 'distla_core.linalg.qr.qr_ooc.qr_ooc', 'qr_ooc.qr_ooc', (['f.name'], {'caqr_panel_size': 'panel_size'}), '(f.name, caqr_panel_size=panel_size)\n', (1356, 1392), False, 'from distla_core.linalg.qr import qr_ooc\n'), ((1534, 1551), 'numpy.linalg.norm', 'np.linalg.norm', (['A'], {}), '(A)\n', (1548, 1551), True, 'import numpy as np\n'), ((2086, 2119), 'numpy.linalg.cholesky', 'np.linalg.cholesky', (['expected_gram'], {}), '(expected_gram)\n', (2104, 2119), True, 'import numpy as np\n'), ((1006, 1027), 'numpy.random.randn', 'np.random.randn', (['M', 'N'], {}), '(M, N)\n', (1021, 1027), True, 'import numpy as np\n'), ((1972, 1993), 'numpy.random.randn', 'np.random.randn', (['M', 'N'], {}), '(M, N)\n', (1987, 1993), True, 'import numpy as np\n'), ((2620, 2649), 'numpy.linalg.norm', 'np.linalg.norm', (['expected_gram'], {}), '(expected_gram)\n', (2634, 2649), True, 'import numpy as np\n')]
|
import os
import logging
import argparse
import numpy as np
import tensorflow as tf
from keras_preprocessing.text import Tokenizer
from tqdm import tqdm
from data import DataLoader
class EmbeddingsBuilder:
def __init__(self, args):
logging.info('initializing...')
self.args = args
self.dataset = DataLoader(self.args)
self.embeddings_path = args.embeddings_path
self.small_embeddings_path = os.path.splitext(self.embeddings_path)[0] + '_small.vec'
logging.info('initializing...[ok]')
def build_embedding(self, vocab_dict):
"""
Load embedding vectors from a .txt file.
Optionally limit the vocabulary to save memory. `vocab` should be a set.
"""
num_words = len(vocab_dict)
num_found = 0
with open(self.small_embeddings_path, 'w') as out_file:
with tf.gfile.GFile(self.embeddings_path) as f:
header =next(f)
num_embeddings, embeddings_dim = header.split(' ')
num_embeddings = int(num_embeddings)
out_file.write(header)
for _, line in tqdm(enumerate(f), 'loading embeddings', total=num_embeddings):
tokens = line.rstrip().split(" ")
word = tokens[0]
if word in vocab_dict:
num_found += 1
out_file.write(line)
tf.logging.info("Found embeddings for {} out of {} words in vocabulary".format(num_found, num_words))
def run(self):
self.dataset.load()
X = self.dataset.X_train_labeled['moment'].values
X = np.append(X, self.dataset.X_train_unlabeled['moment'].values, axis=0)
X = np.append(X, self.dataset.X_test['moment'].values, axis=0)
tokenizer = Tokenizer()
tokenizer.fit_on_texts(X)
self.build_embedding(tokenizer.word_index)
if __name__ == '__main__':
logging.basicConfig(format='%(asctime)s %(message)s', level=logging.DEBUG)
logging.info('initializing task...')
parser = argparse.ArgumentParser()
parser.add_argument('--data-dir', default='data/claff-happydb')
parser.add_argument('--embeddings-path', type=str, default=None)
parser.add_argument('--num-unlabeled', type=int, default=1000)
parser.add_argument('--use-allfeats', action='store_true', default=False)
parser.add_argument('--predict', action='store_true', default=True)
builder = EmbeddingsBuilder(args=parser.parse_args())
builder.run()
logging.info('task finished...[ok]')
|
[
"logging.basicConfig",
"keras_preprocessing.text.Tokenizer",
"argparse.ArgumentParser",
"os.path.splitext",
"numpy.append",
"tensorflow.gfile.GFile",
"logging.info",
"data.DataLoader"
] |
[((1951, 2025), 'logging.basicConfig', 'logging.basicConfig', ([], {'format': '"""%(asctime)s %(message)s"""', 'level': 'logging.DEBUG'}), "(format='%(asctime)s %(message)s', level=logging.DEBUG)\n", (1970, 2025), False, 'import logging\n'), ((2030, 2066), 'logging.info', 'logging.info', (['"""initializing task..."""'], {}), "('initializing task...')\n", (2042, 2066), False, 'import logging\n'), ((2080, 2105), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (2103, 2105), False, 'import argparse\n'), ((2540, 2576), 'logging.info', 'logging.info', (['"""task finished...[ok]"""'], {}), "('task finished...[ok]')\n", (2552, 2576), False, 'import logging\n'), ((248, 279), 'logging.info', 'logging.info', (['"""initializing..."""'], {}), "('initializing...')\n", (260, 279), False, 'import logging\n'), ((328, 349), 'data.DataLoader', 'DataLoader', (['self.args'], {}), '(self.args)\n', (338, 349), False, 'from data import DataLoader\n'), ((504, 539), 'logging.info', 'logging.info', (['"""initializing...[ok]"""'], {}), "('initializing...[ok]')\n", (516, 539), False, 'import logging\n'), ((1655, 1724), 'numpy.append', 'np.append', (['X', "self.dataset.X_train_unlabeled['moment'].values"], {'axis': '(0)'}), "(X, self.dataset.X_train_unlabeled['moment'].values, axis=0)\n", (1664, 1724), True, 'import numpy as np\n'), ((1737, 1795), 'numpy.append', 'np.append', (['X', "self.dataset.X_test['moment'].values"], {'axis': '(0)'}), "(X, self.dataset.X_test['moment'].values, axis=0)\n", (1746, 1795), True, 'import numpy as np\n'), ((1817, 1828), 'keras_preprocessing.text.Tokenizer', 'Tokenizer', ([], {}), '()\n', (1826, 1828), False, 'from keras_preprocessing.text import Tokenizer\n'), ((439, 477), 'os.path.splitext', 'os.path.splitext', (['self.embeddings_path'], {}), '(self.embeddings_path)\n', (455, 477), False, 'import os\n'), ((878, 914), 'tensorflow.gfile.GFile', 'tf.gfile.GFile', (['self.embeddings_path'], {}), '(self.embeddings_path)\n', (892, 914), True, 'import tensorflow as tf\n')]
|
import pytest
import json
import numpy as np
@pytest.mark.parametrize("candidate, expected", [
(1.345, True),
(-4.554, True),
('9999', True)
])
def test_number_please(candidate, expected):
from hrm_code import number_please
assert number_please(candidate) == expected
def test_import_data():
from hrm_code import import_data
[time, voltage] = import_data("test_data/test_data2.csv")
assert time[0] == 0
assert voltage[0] == -0.345
def test_calc_duration():
from hrm_code import calc_duration
fake_time = [0, 1, 2, 3, 4.3, 5, 6, 7.2]
dur = calc_duration(fake_time)
assert dur == 7.2
def test_find_min_max_volt():
from hrm_code import find_max_min_volt
fake_voltage = [1.2, -0.3, 4.8, 0, -3]
both = find_max_min_volt(fake_voltage)
assert both == [-3, 4.8]
def test_calc_freq():
from hrm_code import calc_sample_freq
fake_time = [0, 0.5, 1, 1.5, 2]
fs = calc_sample_freq(fake_time)
assert fs == 2
def test_detect_peak():
from hrm_code import detect_peak
# Peaks should occur every 60 sec
fs = 60
t = np.arange(0, 5, 1/fs)
wave = abs(np.sin(t*np.pi)**20)
peaks = detect_peak(wave, fs, hrw=0.1)
assert peaks == [27, 87, 147, 207, 267]
def test_num_beat():
from hrm_code import num_beat
fake_peaklist = [1, 3, 4]
fake_time = [0, 0.5, 1, 1.5, 2, 2.5, 3]
[num_beats, beats] = num_beat(fake_time, fake_peaklist)
assert num_beats == 3
assert beats == [0.5, 1.5, 2]
def test_calc_bpm():
from hrm_code import calc_bpm
fake_num_beats = 20
fake_dur = 40
bpm = calc_bpm(fake_num_beats, fake_dur)
assert bpm == 30
def test_create_metrics():
from hrm_code import create_metrics
bpm = 70
both = [-1.4, 5.6]
dur = 30
num_beats = 80
beats = [0.5, 0.75, 0.8]
metrics = create_metrics(bpm, beats, both, dur, num_beats)
assert metrics == {
"mean_hr_bpm": 70,
"voltage extremes": [-1.4, 5.6],
"duration": 30,
"num_beats": 80,
"beats": [0.5, 0.75, 0.8]
}
def test_create_jason():
from hrm_code import create_jason
metrics = {"Favorite Ice Cream Flavor": "Chocolate",
"Favorite Book": "A Tree Grows in Brooklyn",
"Favorite Number": 8}
filename = "test_output.csv"
create_jason(filename, metrics)
read_file = json.load(open('test_output.json'))
assert read_file == {"Favorite Ice Cream Flavor": "Chocolate",
"Favorite Book": "A Tree Grows in Brooklyn",
"Favorite Number": 8}
|
[
"hrm_code.num_beat",
"hrm_code.detect_peak",
"hrm_code.number_please",
"pytest.mark.parametrize",
"hrm_code.import_data",
"hrm_code.calc_bpm",
"hrm_code.create_jason",
"hrm_code.find_max_min_volt",
"hrm_code.calc_sample_freq",
"numpy.sin",
"hrm_code.create_metrics",
"numpy.arange",
"hrm_code.calc_duration"
] |
[((48, 148), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""candidate, expected"""', "[(1.345, True), (-4.554, True), ('9999', True)]"], {}), "('candidate, expected', [(1.345, True), (-4.554, \n True), ('9999', True)])\n", (71, 148), False, 'import pytest\n'), ((375, 414), 'hrm_code.import_data', 'import_data', (['"""test_data/test_data2.csv"""'], {}), "('test_data/test_data2.csv')\n", (386, 414), False, 'from hrm_code import import_data\n'), ((593, 617), 'hrm_code.calc_duration', 'calc_duration', (['fake_time'], {}), '(fake_time)\n', (606, 617), False, 'from hrm_code import calc_duration\n'), ((769, 800), 'hrm_code.find_max_min_volt', 'find_max_min_volt', (['fake_voltage'], {}), '(fake_voltage)\n', (786, 800), False, 'from hrm_code import find_max_min_volt\n'), ((941, 968), 'hrm_code.calc_sample_freq', 'calc_sample_freq', (['fake_time'], {}), '(fake_time)\n', (957, 968), False, 'from hrm_code import calc_sample_freq\n'), ((1109, 1132), 'numpy.arange', 'np.arange', (['(0)', '(5)', '(1 / fs)'], {}), '(0, 5, 1 / fs)\n', (1118, 1132), True, 'import numpy as np\n'), ((1179, 1209), 'hrm_code.detect_peak', 'detect_peak', (['wave', 'fs'], {'hrw': '(0.1)'}), '(wave, fs, hrw=0.1)\n', (1190, 1209), False, 'from hrm_code import detect_peak\n'), ((1410, 1444), 'hrm_code.num_beat', 'num_beat', (['fake_time', 'fake_peaklist'], {}), '(fake_time, fake_peaklist)\n', (1418, 1444), False, 'from hrm_code import num_beat\n'), ((1614, 1648), 'hrm_code.calc_bpm', 'calc_bpm', (['fake_num_beats', 'fake_dur'], {}), '(fake_num_beats, fake_dur)\n', (1622, 1648), False, 'from hrm_code import calc_bpm\n'), ((1850, 1898), 'hrm_code.create_metrics', 'create_metrics', (['bpm', 'beats', 'both', 'dur', 'num_beats'], {}), '(bpm, beats, both, dur, num_beats)\n', (1864, 1898), False, 'from hrm_code import create_metrics\n'), ((2336, 2367), 'hrm_code.create_jason', 'create_jason', (['filename', 'metrics'], {}), '(filename, metrics)\n', (2348, 2367), False, 'from hrm_code import create_jason\n'), ((253, 277), 'hrm_code.number_please', 'number_please', (['candidate'], {}), '(candidate)\n', (266, 277), False, 'from hrm_code import number_please\n'), ((1146, 1163), 'numpy.sin', 'np.sin', (['(t * np.pi)'], {}), '(t * np.pi)\n', (1152, 1163), True, 'import numpy as np\n')]
|
import numpy as np
from math import sqrt
def robot_distance_incorrect(robot_actual_location, hexagon_pixel_values):
distance_to_get_back = []
distances = []
pixel_distance = []
for i in range(0, len(hexagon_pixel_values)):
dist = sqrt((robot_actual_location[0] - hexagon_pixel_values[i][0]) ** 2 +
(robot_actual_location[1] - hexagon_pixel_values[i][1]) ** 2)
distances += [dist]
index_min = np.argmin(distances)
correct_position = hexagon_pixel_values[index_min]
# find the distance that needs to be traveled to get to the correct location
pixel_distance = (correct_position[0] - robot_actual_location[0], correct_position[1]-robot_actual_location[1])
# print(correct_position, robot_actual_location, pixel_distance)
# convert to actual distance
distance_to_get_back = (pixel_distance[0]/1.79, pixel_distance[1]/1.749)
return distance_to_get_back
|
[
"numpy.argmin",
"math.sqrt"
] |
[((450, 470), 'numpy.argmin', 'np.argmin', (['distances'], {}), '(distances)\n', (459, 470), True, 'import numpy as np\n'), ((256, 390), 'math.sqrt', 'sqrt', (['((robot_actual_location[0] - hexagon_pixel_values[i][0]) ** 2 + (\n robot_actual_location[1] - hexagon_pixel_values[i][1]) ** 2)'], {}), '((robot_actual_location[0] - hexagon_pixel_values[i][0]) ** 2 + (\n robot_actual_location[1] - hexagon_pixel_values[i][1]) ** 2)\n', (260, 390), False, 'from math import sqrt\n')]
|
"""Largest prime factor
The prime factors of 13195 are 5, 7, 13 and 29.
What is the largest prime factor of the number 600851475143?
"""
import math
import numpy as np
def largest_prime_factor_naive(number):
"""
Let the given number be n and let k = 2, 3, 4, 5, ... .
For each k, if it is a factor of n then we divide n by k and completely divide out each k before moving to the next k.
It can be seen that when k is a factor it will necessarily be prime, as all smaller factors have been removed,
and the final result of this process will be n = 1.
"""
factor = 2
factors = []
while number > 1:
if number % factor == 0:
factors.append(factor)
number = number // factor # Remainder guarenteed to be zero
while number % factor == 0:
number = number // factor # Remainder guarenteed to be zero
factor += 1
return factors
def largest_prime_factor_even_optimized(number):
"""
We know that, excluding 2, there are no even prime numbers.
So we can increase factor by 2 per iteration after having found the
"""
factors = []
factor = 2
if number % factor == 0:
number = number // factor
factors.append(factor)
while number % factor == 0:
number = number // factor
factor = 3
while number > 1:
if number % factor == 0:
factors.append(factor)
number = number // factor # Remainder guarenteed to be zero
while number % factor == 0:
number = number // factor # Remainder guarenteed to be zero
factor += 2
return factors
def largest_prime_factor_square_optimized(number):
"""
Every number n can at most have one prime factor greater than n.
If we, after dividing out some prime factor, calculate the square root of the remaining number
we can use that square root as upper limit for factor.
If factor exceeds this square root we know the remaining number is prime.
"""
factors = []
factor = 2
if number % factor == 0:
number = number // factor
factors.append(factor)
while number % factor == 0:
number = number // factor
factor = 3
max_factor = math.sqrt(number)
while number > 1 and factor <= max_factor:
if number % factor == 0:
factors.append(factor)
number = number // factor
while number % factor == 0:
number = number // factor
max_factor = math.sqrt(number)
factor += 2
return factors
def idx_sieve(length):
"""Static length sieve-based prime generator"""
primes = []
is_prime = np.array([True]*length)
i = 2
while i < length:
if is_prime[i]:
is_prime[np.arange(i, length, i)] = False
primes.append(i)
else:
i += 1
return primes
def prime_factor(n, primes):
i = 0
factors = []
while n != 1:
while (n % primes[i]) != 0:
i += 1
factors.append(primes[i])
n = n / primes[i]
return factors
if __name__ == '__main__':
number = 600851475143
print(largest_prime_factor_naive(number))
print(largest_prime_factor_even_optimized(number))
print(largest_prime_factor_square_optimized(number))
number = 600851475143
primes = idx_sieve(20000)
print(max(prime_factor(number, primes)))
|
[
"numpy.array",
"math.sqrt",
"numpy.arange"
] |
[((2287, 2304), 'math.sqrt', 'math.sqrt', (['number'], {}), '(number)\n', (2296, 2304), False, 'import math\n'), ((2735, 2760), 'numpy.array', 'np.array', (['([True] * length)'], {}), '([True] * length)\n', (2743, 2760), True, 'import numpy as np\n'), ((2569, 2586), 'math.sqrt', 'math.sqrt', (['number'], {}), '(number)\n', (2578, 2586), False, 'import math\n'), ((2836, 2859), 'numpy.arange', 'np.arange', (['i', 'length', 'i'], {}), '(i, length, i)\n', (2845, 2859), True, 'import numpy as np\n')]
|
# encoding: utf-8
'''
@author: <NAME>
@contact: <EMAIL>
@software: basenef
@file: doc_generator.py
@date: 4/13/2019
@desc:
'''
import os
import sys
import time
from getpass import getuser
import matplotlib
import numpy as np
import json
from srfnef import Image, MlemFull
matplotlib.use('Agg')
author = getuser()
def title_block_gen():
timestamp = time.time()
datetime = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(int(timestamp)))
title_block = f'''
# NEF AutoDoc {datetime}
- Author: {author}
- Generation time: {datetime}
- Operation system: {sys.platform}
- OS language: {os.environ['LANG']}
- Duration: 0.0 sec
- Total errors: 0
- Total warning: 0
- Description:
'''
return title_block
def _text_gen_as_table(dct: dict = {}):
out_text = ['|key|values|\n|:---|:---|\n']
for key, val in dct.items():
if key == 'data':
out_text.append(f"| {key} | Ignored |\n")
elif not isinstance(val, dict):
if isinstance(val, str) and len(val) > 30:
out_text.append(f"| {key} | Ignored |\n")
else:
out_text.append(f"| {key} | {val} |\n")
else:
out_text.append(f"| {key} | {'Ignored'} |\n")
return out_text
def json_block_gen(dct: dict = {}):
if isinstance(dct, str):
dct = json.loads(dct)
dct['image_config']['size'] = np.round(dct['image_config']['size'], decimals = 3).tolist()
if dct['emap'] is not None:
dct['emap']['size'] = np.round(dct['emap']['size'], decimals = 3).tolist()
json_str = json.dumps(dct, indent = 4)
out_text = "## RECON JSON\n"
out_text += "```javascript\n"
out_text += json_str + '\n'
out_text += "```\n"
return out_text
def image_block_gen(img: Image, path: str):
print('Generating text blocks...')
from matplotlib import pyplot as plt
vmax = np.percentile(img.data, 99.99)
midind = [int(img.shape[i] / 2) for i in range(3)]
plt.figure(figsize = (30, 10))
plt.subplot(231)
plt.imshow(img.data[midind[0], :, :], vmax = vmax)
plt.subplot(232)
plt.imshow(img.data[:, midind[1], :].transpose(), vmax = vmax)
plt.subplot(233)
plt.imshow(img.data[:, :, midind[2]].transpose(), vmax = vmax)
plt.subplot(234)
plt.plot(img.data[midind[0], midind[1], :])
plt.subplot(235)
plt.plot(img.data[midind[0], :, midind[2]])
plt.subplot(236)
plt.plot(img.data[:, midind[1], midind[2]])
timestamp = time.time()
datetime_str = time.strftime("%Y-%m-%d-%H-%M-%S", time.localtime(int(timestamp)))
plt.savefig(path + f'/out_img{datetime_str}.png')
out_text = f'\n'
return out_text
def statistic_block_gen(dct: dict = {}):
out_text = []
key_set = set()
for name, sub_dct in dct.items():
for key, val in sub_dct.items():
if isinstance(val, str) and len(val) < 30:
key_set.add(key)
col_names = ['|name ', '|:---']
for key in key_set:
col_names[0] += '|' + key + ''
else:
col_names[0] += '|\n'
for _ in key_set:
col_names[1] += '|:---'
else:
col_names[1] += '|\n'
out_text += col_names
for name, sub_dct in dct.items():
row = '| ' + name + ' '
for key in key_set:
if key in sub_dct:
row += '|' + str(sub_dct[key]) + ''
else:
row += '|-'
else:
row += '|\n'
out_text += [row]
return out_text
def metric_block_gen(mask: np.ndarray, img: Image):
from srfnef import image_metric as metric
dct = {}
# contrast hot
dct.update(
contrast_hot = {str(ind_): float(val_) for ind_, val_ in metric.contrast_hot(mask, img)})
dct.update(
contrast_cold = {str(ind_): float(val_) for ind_, val_ in metric.contrast_cold(mask, img)})
dct.update(contrast_noise_ratio1 = metric.cnr1(mask, img))
dct.update(contrast_noise_ratio2 = metric.cnr2(mask, img))
dct.update(contrast_recovery_coefficiency1 = metric.crc1(mask, img))
dct.update(contrast_recovery_coefficiency2 = metric.crc2(mask, img))
dct.update(standard_error = metric.standard_error(mask, img))
dct.update(normalized_standard_error = metric.nsd(mask, img))
dct.update(standard_deviation = metric.sd(mask, img))
dct.update(background_visibility = metric.bg_visibility(mask, img))
dct.update(noise1 = metric.noise1(mask, img))
dct.update(noise2 = metric.noise2(mask, img))
dct.update(signal_noise_ratio1 = metric.snr1(mask, img))
dct.update(signal_noise_ratio2 = metric.snr2(mask, img))
dct.update(positive_deviation = metric.pos_dev(mask, img))
for ind, val in dct.items():
if not isinstance(val, dict):
dct[ind] = float(val)
json_str = json.dumps(dct, indent = 4)
out_text = "## IMAGE METRIC JSON\n"
out_text += "```javascript\n"
out_text += json_str + '\n'
out_text += "```\n"
return out_text
def doc_gen(mlem_obj: MlemFull, img: Image, path: str, filename: str = None,
mask: np.ndarray = None):
timestamp = time.time()
datetime_str = time.strftime("%Y-%m-%d-%H-%M-%S", time.localtime(int(timestamp)))
if filename is None:
filename = 'doc_gen-' + datetime_str + '.md'
out_text = title_block_gen()
out_text += image_block_gen(img, path)
out_text += json_block_gen(mlem_obj.asdict(recurse = True))
if mask is not None:
if isinstance(mask, str):
mask = np.load(mask)
out_text += metric_block_gen(mask, img)
# out_text += statistic_block_gen(dct)
with open(filename, 'w') as fout:
fout.writelines(out_text)
# print('Converting MD to PDF...')
# import pypandoc
# print(filename)
# pypandoc.convert_file(filename, 'pdf', outputfile = filename + '.pdf')
return filename
|
[
"srfnef.image_metric.nsd",
"getpass.getuser",
"matplotlib.pyplot.imshow",
"srfnef.image_metric.noise2",
"json.dumps",
"matplotlib.pyplot.plot",
"srfnef.image_metric.pos_dev",
"srfnef.image_metric.bg_visibility",
"srfnef.image_metric.crc2",
"numpy.round",
"srfnef.image_metric.standard_error",
"json.loads",
"srfnef.image_metric.sd",
"matplotlib.pyplot.savefig",
"srfnef.image_metric.contrast_cold",
"matplotlib.use",
"srfnef.image_metric.snr1",
"srfnef.image_metric.cnr2",
"time.time",
"srfnef.image_metric.noise1",
"srfnef.image_metric.snr2",
"srfnef.image_metric.crc1",
"matplotlib.pyplot.figure",
"srfnef.image_metric.cnr1",
"srfnef.image_metric.contrast_hot",
"numpy.percentile",
"numpy.load",
"matplotlib.pyplot.subplot"
] |
[((274, 295), 'matplotlib.use', 'matplotlib.use', (['"""Agg"""'], {}), "('Agg')\n", (288, 295), False, 'import matplotlib\n'), ((306, 315), 'getpass.getuser', 'getuser', ([], {}), '()\n', (313, 315), False, 'from getpass import getuser\n'), ((357, 368), 'time.time', 'time.time', ([], {}), '()\n', (366, 368), False, 'import time\n'), ((1567, 1592), 'json.dumps', 'json.dumps', (['dct'], {'indent': '(4)'}), '(dct, indent=4)\n', (1577, 1592), False, 'import json\n'), ((1875, 1905), 'numpy.percentile', 'np.percentile', (['img.data', '(99.99)'], {}), '(img.data, 99.99)\n', (1888, 1905), True, 'import numpy as np\n'), ((1965, 1993), 'matplotlib.pyplot.figure', 'plt.figure', ([], {'figsize': '(30, 10)'}), '(figsize=(30, 10))\n', (1975, 1993), True, 'from matplotlib import pyplot as plt\n'), ((2000, 2016), 'matplotlib.pyplot.subplot', 'plt.subplot', (['(231)'], {}), '(231)\n', (2011, 2016), True, 'from matplotlib import pyplot as plt\n'), ((2021, 2069), 'matplotlib.pyplot.imshow', 'plt.imshow', (['img.data[midind[0], :, :]'], {'vmax': 'vmax'}), '(img.data[midind[0], :, :], vmax=vmax)\n', (2031, 2069), True, 'from matplotlib import pyplot as plt\n'), ((2076, 2092), 'matplotlib.pyplot.subplot', 'plt.subplot', (['(232)'], {}), '(232)\n', (2087, 2092), True, 'from matplotlib import pyplot as plt\n'), ((2164, 2180), 'matplotlib.pyplot.subplot', 'plt.subplot', (['(233)'], {}), '(233)\n', (2175, 2180), True, 'from matplotlib import pyplot as plt\n'), ((2253, 2269), 'matplotlib.pyplot.subplot', 'plt.subplot', (['(234)'], {}), '(234)\n', (2264, 2269), True, 'from matplotlib import pyplot as plt\n'), ((2274, 2317), 'matplotlib.pyplot.plot', 'plt.plot', (['img.data[midind[0], midind[1], :]'], {}), '(img.data[midind[0], midind[1], :])\n', (2282, 2317), True, 'from matplotlib import pyplot as plt\n'), ((2322, 2338), 'matplotlib.pyplot.subplot', 'plt.subplot', (['(235)'], {}), '(235)\n', (2333, 2338), True, 'from matplotlib import pyplot as plt\n'), ((2343, 2386), 'matplotlib.pyplot.plot', 'plt.plot', (['img.data[midind[0], :, midind[2]]'], {}), '(img.data[midind[0], :, midind[2]])\n', (2351, 2386), True, 'from matplotlib import pyplot as plt\n'), ((2391, 2407), 'matplotlib.pyplot.subplot', 'plt.subplot', (['(236)'], {}), '(236)\n', (2402, 2407), True, 'from matplotlib import pyplot as plt\n'), ((2412, 2455), 'matplotlib.pyplot.plot', 'plt.plot', (['img.data[:, midind[1], midind[2]]'], {}), '(img.data[:, midind[1], midind[2]])\n', (2420, 2455), True, 'from matplotlib import pyplot as plt\n'), ((2472, 2483), 'time.time', 'time.time', ([], {}), '()\n', (2481, 2483), False, 'import time\n'), ((2574, 2623), 'matplotlib.pyplot.savefig', 'plt.savefig', (["(path + f'/out_img{datetime_str}.png')"], {}), "(path + f'/out_img{datetime_str}.png')\n", (2585, 2623), True, 'from matplotlib import pyplot as plt\n'), ((4830, 4855), 'json.dumps', 'json.dumps', (['dct'], {'indent': '(4)'}), '(dct, indent=4)\n', (4840, 4855), False, 'import json\n'), ((5141, 5152), 'time.time', 'time.time', ([], {}), '()\n', (5150, 5152), False, 'import time\n'), ((1324, 1339), 'json.loads', 'json.loads', (['dct'], {}), '(dct)\n', (1334, 1339), False, 'import json\n'), ((1375, 1424), 'numpy.round', 'np.round', (["dct['image_config']['size']"], {'decimals': '(3)'}), "(dct['image_config']['size'], decimals=3)\n", (1383, 1424), True, 'import numpy as np\n'), ((3930, 3952), 'srfnef.image_metric.cnr1', 'metric.cnr1', (['mask', 'img'], {}), '(mask, img)\n', (3941, 3952), True, 'from srfnef import image_metric as metric\n'), ((3993, 4015), 'srfnef.image_metric.cnr2', 'metric.cnr2', (['mask', 'img'], {}), '(mask, img)\n', (4004, 4015), True, 'from srfnef import image_metric as metric\n'), ((4066, 4088), 'srfnef.image_metric.crc1', 'metric.crc1', (['mask', 'img'], {}), '(mask, img)\n', (4077, 4088), True, 'from srfnef import image_metric as metric\n'), ((4139, 4161), 'srfnef.image_metric.crc2', 'metric.crc2', (['mask', 'img'], {}), '(mask, img)\n', (4150, 4161), True, 'from srfnef import image_metric as metric\n'), ((4195, 4227), 'srfnef.image_metric.standard_error', 'metric.standard_error', (['mask', 'img'], {}), '(mask, img)\n', (4216, 4227), True, 'from srfnef import image_metric as metric\n'), ((4272, 4293), 'srfnef.image_metric.nsd', 'metric.nsd', (['mask', 'img'], {}), '(mask, img)\n', (4282, 4293), True, 'from srfnef import image_metric as metric\n'), ((4331, 4351), 'srfnef.image_metric.sd', 'metric.sd', (['mask', 'img'], {}), '(mask, img)\n', (4340, 4351), True, 'from srfnef import image_metric as metric\n'), ((4392, 4423), 'srfnef.image_metric.bg_visibility', 'metric.bg_visibility', (['mask', 'img'], {}), '(mask, img)\n', (4412, 4423), True, 'from srfnef import image_metric as metric\n'), ((4449, 4473), 'srfnef.image_metric.noise1', 'metric.noise1', (['mask', 'img'], {}), '(mask, img)\n', (4462, 4473), True, 'from srfnef import image_metric as metric\n'), ((4499, 4523), 'srfnef.image_metric.noise2', 'metric.noise2', (['mask', 'img'], {}), '(mask, img)\n', (4512, 4523), True, 'from srfnef import image_metric as metric\n'), ((4562, 4584), 'srfnef.image_metric.snr1', 'metric.snr1', (['mask', 'img'], {}), '(mask, img)\n', (4573, 4584), True, 'from srfnef import image_metric as metric\n'), ((4623, 4645), 'srfnef.image_metric.snr2', 'metric.snr2', (['mask', 'img'], {}), '(mask, img)\n', (4634, 4645), True, 'from srfnef import image_metric as metric\n'), ((4683, 4708), 'srfnef.image_metric.pos_dev', 'metric.pos_dev', (['mask', 'img'], {}), '(mask, img)\n', (4697, 4708), True, 'from srfnef import image_metric as metric\n'), ((5536, 5549), 'numpy.load', 'np.load', (['mask'], {}), '(mask)\n', (5543, 5549), True, 'import numpy as np\n'), ((1498, 1539), 'numpy.round', 'np.round', (["dct['emap']['size']"], {'decimals': '(3)'}), "(dct['emap']['size'], decimals=3)\n", (1506, 1539), True, 'import numpy as np\n'), ((3742, 3772), 'srfnef.image_metric.contrast_hot', 'metric.contrast_hot', (['mask', 'img'], {}), '(mask, img)\n', (3761, 3772), True, 'from srfnef import image_metric as metric\n'), ((3857, 3888), 'srfnef.image_metric.contrast_cold', 'metric.contrast_cold', (['mask', 'img'], {}), '(mask, img)\n', (3877, 3888), True, 'from srfnef import image_metric as metric\n')]
|
import math
import numpy as np
from matplotlib.patches import FancyArrowPatch
def home_has_possession(row):
if row.possessionTeam == row.homeTeamAbbr:
return True
return False
def calculate_team_sitation(row):
ball_string = 'football'
if row.team == ball_string:
return ball_string
if row.team == 'home' and row.homeHasPossession:
return 'attacking'
elif row.team == 'away' and not row.homeHasPossession:
return 'attacking'
return 'defending'
def convert_speed_to_marker_size(speed: float) -> int:
if 0 < speed <= 1.5:
return 10
elif 1.5 < speed <= 3:
return 15
elif 3 < speed <= 4.5:
return 20
elif 4.5 < speed <= 6:
return 25
return 30
def arrow(x, y, s, ax, color):
"""
Function to draw the arrow of the movement
:param x: position on x-axis
:param y: position on y-axis
:param s: speed in yards/s
:param ax: plot's configuration
:param color: color of the arrows
:return: arrows on the specific positions
"""
# distance between the arrows
distance = 5
ind = range(1, len(x), distance)
# computing of the arrows
for i in ind:
ar = FancyArrowPatch(
(x[i - 1], y[i - 1]), (x[i], y[i]),
arrowstyle='->',
mutation_scale=convert_speed_to_marker_size(s[i]),
color=color,
)
ax.add_patch(ar)
def calculate_arrow_xy(x, y, o):
o = o % 360
delta = 0.1
if o == 0:
y_delta = delta
x_delta = 0
return x + x_delta, y + y_delta
elif o == 90:
y_delta = 0
x_delta = delta
return x + x_delta, y + y_delta
elif o == 180:
y_delta = -delta
x_delta = 0
print(f'F {y_delta}')
return x + x_delta, y + y_delta
elif o == 270:
y_delta = 0
x_delta = -delta
return x + x_delta, y + y_delta
elif 0 < o < 90:
y_delta = math.sin(math.radians(90 - o)) * delta
x_delta = math.sqrt(delta ** 2 - y_delta ** 2)
return x + x_delta, y + y_delta
elif 90 < o < 180:
y_delta = math.sin(math.radians(o - 90)) * delta
x_delta = math.sqrt(delta ** 2 - y_delta ** 2)
return x + x_delta, y - y_delta
elif 180 < o < 270:
x_delta = math.sin(math.radians(o - 180)) * delta
y_delta = math.sqrt(delta ** 2 - x_delta ** 2)
return x - x_delta, y - y_delta
else:
y_delta = math.sin(math.radians(o - 270)) * delta
x_delta = math.sqrt(delta ** 2 - y_delta ** 2)
return x - x_delta, y + y_delta
def arrow_o(x, y, o, s, ax, color):
"""
Function to draw the arrow of the movement
:param x: position on x-axis
:param y: position on y-axis
:param o: orientation in degrees 0-360
:param s: speed in yards/s
:param ax: plot's configuration
:param color: color of the arrows
:return: arrows on the specific positions
"""
# distance between the arrows
distance = 3
ind = range(5, len(x), distance)
# computing of the arrows
for i in ind:
x2, y2 = calculate_arrow_xy(x[i], y[i], o[i])
ar = FancyArrowPatch(
(x[i], y[i]), (x2, y2),
arrowstyle='-|>',
mutation_scale=convert_speed_to_marker_size(s[i]),
alpha=0.6,
color=color,
)
ax.add_patch(ar)
def calculate_distance_v4(x1: np.array, y1: np.array, x2: np.array, y2: np.array) -> np.array:
return np.round(np.sqrt(np.square(x1 - x2) + np.square(y1 - y2)), 2)
|
[
"math.radians",
"math.sqrt",
"numpy.square"
] |
[((3550, 3568), 'numpy.square', 'np.square', (['(x1 - x2)'], {}), '(x1 - x2)\n', (3559, 3568), True, 'import numpy as np\n'), ((3571, 3589), 'numpy.square', 'np.square', (['(y1 - y2)'], {}), '(y1 - y2)\n', (3580, 3589), True, 'import numpy as np\n'), ((2039, 2075), 'math.sqrt', 'math.sqrt', (['(delta ** 2 - y_delta ** 2)'], {}), '(delta ** 2 - y_delta ** 2)\n', (2048, 2075), False, 'import math\n'), ((2214, 2250), 'math.sqrt', 'math.sqrt', (['(delta ** 2 - y_delta ** 2)'], {}), '(delta ** 2 - y_delta ** 2)\n', (2223, 2250), False, 'import math\n'), ((1991, 2011), 'math.radians', 'math.radians', (['(90 - o)'], {}), '(90 - o)\n', (2003, 2011), False, 'import math\n'), ((2391, 2427), 'math.sqrt', 'math.sqrt', (['(delta ** 2 - x_delta ** 2)'], {}), '(delta ** 2 - x_delta ** 2)\n', (2400, 2427), False, 'import math\n'), ((2554, 2590), 'math.sqrt', 'math.sqrt', (['(delta ** 2 - y_delta ** 2)'], {}), '(delta ** 2 - y_delta ** 2)\n', (2563, 2590), False, 'import math\n'), ((2166, 2186), 'math.radians', 'math.radians', (['(o - 90)'], {}), '(o - 90)\n', (2178, 2186), False, 'import math\n'), ((2342, 2363), 'math.radians', 'math.radians', (['(o - 180)'], {}), '(o - 180)\n', (2354, 2363), False, 'import math\n'), ((2505, 2526), 'math.radians', 'math.radians', (['(o - 270)'], {}), '(o - 270)\n', (2517, 2526), False, 'import math\n')]
|
"""
Automatic speech recognition scenario
"""
import logging
from typing import Optional
from tqdm import tqdm
import numpy as np
from art.preprocessing.audio import LFilter, LFilterPyTorch
from armory.utils.config_loading import (
load_dataset,
load_model,
load_attack,
load_adversarial_dataset,
load_defense_wrapper,
load_defense_internal,
load_label_targeter,
)
from armory.utils import metrics
from armory.scenarios.base import Scenario
from armory.utils.export import SampleExporter
logger = logging.getLogger(__name__)
def load_audio_channel(delay, attenuation, pytorch=True):
"""
Return an art LFilter object for a simple delay (multipath) channel
If attenuation == 0 or delay == 0, return an identity channel
Otherwise, return a channel with length equal to delay + 1
NOTE: lfilter truncates the end of the echo, so output length equals input length
"""
delay = int(delay)
attenuation = float(attenuation)
if delay < 0:
raise ValueError(f"delay {delay} must be a nonnegative number (of samples)")
if delay == 0 or attenuation == 0:
logger.warning("Using an identity channel")
numerator_coef = np.array([1.0])
denominator_coef = np.array([1.0])
else:
if not (-1 <= attenuation <= 1):
logger.warning(f"filter attenuation {attenuation} not in [-1, 1]")
# Simple FIR filter with a single multipath delay
numerator_coef = np.zeros(delay + 1)
numerator_coef[0] = 1.0
numerator_coef[delay] = attenuation
denominator_coef = np.zeros_like(numerator_coef)
denominator_coef[0] = 1.0
if pytorch:
try:
return LFilterPyTorch(
numerator_coef=numerator_coef, denominator_coef=denominator_coef
)
except ImportError:
logger.exception("PyTorch not available. Resorting to scipy filter")
logger.warning("Scipy LFilter does not currently implement proper gradients")
return LFilter(numerator_coef=numerator_coef, denominator_coef=denominator_coef)
class AutomaticSpeechRecognition(Scenario):
def _evaluate(
self,
config: dict,
num_eval_batches: Optional[int],
skip_benign: Optional[bool],
skip_attack: Optional[bool],
skip_misclassified: Optional[bool],
) -> dict:
"""
Evaluate the config and return a results dict
"""
if skip_misclassified:
raise ValueError("skip_misclassified shouldn't be set for ASR scenario")
model_config = config["model"]
estimator, fit_preprocessing_fn = load_model(model_config)
audio_channel_config = config.get("adhoc", {}).get("audio_channel")
if audio_channel_config is not None:
logger.info("loading audio channel")
for k in "delay", "attenuation":
if k not in audio_channel_config:
raise ValueError(f"audio_channel must have key {k}")
audio_channel = load_audio_channel(**audio_channel_config)
if estimator.preprocessing_defences:
estimator.preprocessing_defences.insert(0, audio_channel)
else:
estimator.preprocessing_defences = [audio_channel]
estimator._update_preprocessing_operations()
defense_config = config.get("defense") or {}
defense_type = defense_config.get("type")
if defense_type in ["Preprocessor", "Postprocessor"]:
logger.info(f"Applying internal {defense_type} defense to estimator")
estimator = load_defense_internal(config["defense"], estimator)
if model_config["fit"]:
logger.info(
f"Fitting model {model_config['module']}.{model_config['name']}..."
)
fit_kwargs = model_config["fit_kwargs"]
logger.info(f"Loading train dataset {config['dataset']['name']}...")
batch_size = config["dataset"].pop("batch_size")
config["dataset"]["batch_size"] = fit_kwargs.get(
"fit_batch_size", batch_size
)
train_data = load_dataset(
config["dataset"],
epochs=fit_kwargs["nb_epochs"],
split=config["dataset"].get("train_split", "train_clean100"),
preprocessing_fn=fit_preprocessing_fn,
shuffle_files=True,
)
config["dataset"]["batch_size"] = batch_size
if defense_type == "Trainer":
logger.info(f"Training with {defense_type} defense...")
defense = load_defense_wrapper(config["defense"], estimator)
defense.fit_generator(train_data, **fit_kwargs)
else:
logger.info("Fitting estimator on clean train dataset...")
estimator.fit_generator(train_data, **fit_kwargs)
if defense_type == "Transform":
# NOTE: Transform currently not supported
logger.info(f"Transforming estimator with {defense_type} defense...")
defense = load_defense_wrapper(config["defense"], estimator)
estimator = defense()
attack_config = config["attack"]
attack_type = attack_config.get("type")
targeted = bool(attack_config.get("targeted"))
metrics_logger = metrics.MetricsLogger.from_config(
config["metric"],
skip_benign=skip_benign,
skip_attack=skip_attack,
targeted=targeted,
)
if config["dataset"]["batch_size"] != 1:
logger.warning("Evaluation batch_size != 1 may not be supported.")
predict_kwargs = config["model"].get("predict_kwargs", {})
eval_split = config["dataset"].get("eval_split", "test_clean")
if skip_benign:
logger.info("Skipping benign classification...")
else:
# Evaluate the ART estimator on benign test examples
logger.info(f"Loading test dataset {config['dataset']['name']}...")
test_data = load_dataset(
config["dataset"],
epochs=1,
split=eval_split,
num_batches=num_eval_batches,
shuffle_files=False,
)
logger.info("Running inference on benign examples...")
for x, y in tqdm(test_data, desc="Benign"):
# Ensure that input sample isn't overwritten by estimator
x.flags.writeable = False
with metrics.resource_context(
name="Inference",
profiler=config["metric"].get("profiler_type"),
computational_resource_dict=metrics_logger.computational_resource_dict,
):
y_pred = estimator.predict(x, **predict_kwargs)
metrics_logger.update_task(y, y_pred)
metrics_logger.log_task()
if skip_attack:
logger.info("Skipping attack generation...")
return metrics_logger.results()
# Imperceptible attack still WIP
if (config.get("adhoc") or {}).get("skip_adversarial"):
logger.info("Skipping adversarial classification...")
return metrics_logger.results()
# Evaluate the ART estimator on adversarial test examples
logger.info("Generating or loading / testing adversarial examples...")
if attack_type == "preloaded":
test_data = load_adversarial_dataset(
attack_config,
epochs=1,
split="adversarial",
num_batches=num_eval_batches,
shuffle_files=False,
)
else:
attack = load_attack(attack_config, estimator)
if targeted != attack.targeted:
logger.warning(
f"targeted config {targeted} != attack field {attack.targeted}"
)
test_data = load_dataset(
config["dataset"],
epochs=1,
split=eval_split,
num_batches=num_eval_batches,
shuffle_files=False,
)
if targeted:
label_targeter = load_label_targeter(attack_config["targeted_labels"])
export_samples = config["scenario"].get("export_samples")
if export_samples is not None and export_samples > 0:
sample_exporter = SampleExporter(
self.scenario_output_dir, test_data.context, export_samples
)
else:
sample_exporter = None
for x, y in tqdm(test_data, desc="Attack"):
with metrics.resource_context(
name="Attack",
profiler=config["metric"].get("profiler_type"),
computational_resource_dict=metrics_logger.computational_resource_dict,
):
if attack_type == "preloaded":
x, x_adv = x
if targeted:
y, y_target = y
elif attack_config.get("use_label"):
x_adv = attack.generate(x=x, y=y)
elif targeted:
y_target = label_targeter.generate(y)
x_adv = attack.generate(x=x, y=y_target)
else:
x_adv = attack.generate(x=x)
# Ensure that input sample isn't overwritten by estimator
x_adv.flags.writeable = False
y_pred_adv = estimator.predict(x_adv, **predict_kwargs)
metrics_logger.update_task(y, y_pred_adv, adversarial=True)
if targeted:
metrics_logger.update_task(
y_target, y_pred_adv, adversarial=True, targeted=True,
)
metrics_logger.update_perturbation(x, x_adv)
if sample_exporter is not None:
sample_exporter.export(x, x_adv, y, y_pred_adv)
metrics_logger.log_task(adversarial=True)
if targeted:
metrics_logger.log_task(adversarial=True, targeted=True)
return metrics_logger.results()
|
[
"logging.getLogger",
"armory.utils.config_loading.load_label_targeter",
"art.preprocessing.audio.LFilterPyTorch",
"armory.utils.export.SampleExporter",
"armory.utils.metrics.MetricsLogger.from_config",
"tqdm.tqdm",
"art.preprocessing.audio.LFilter",
"armory.utils.config_loading.load_defense_wrapper",
"numpy.array",
"numpy.zeros",
"armory.utils.config_loading.load_attack",
"armory.utils.config_loading.load_dataset",
"armory.utils.config_loading.load_defense_internal",
"armory.utils.config_loading.load_model",
"armory.utils.config_loading.load_adversarial_dataset",
"numpy.zeros_like"
] |
[((530, 557), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (547, 557), False, 'import logging\n'), ((2030, 2103), 'art.preprocessing.audio.LFilter', 'LFilter', ([], {'numerator_coef': 'numerator_coef', 'denominator_coef': 'denominator_coef'}), '(numerator_coef=numerator_coef, denominator_coef=denominator_coef)\n', (2037, 2103), False, 'from art.preprocessing.audio import LFilter, LFilterPyTorch\n'), ((1206, 1221), 'numpy.array', 'np.array', (['[1.0]'], {}), '([1.0])\n', (1214, 1221), True, 'import numpy as np\n'), ((1249, 1264), 'numpy.array', 'np.array', (['[1.0]'], {}), '([1.0])\n', (1257, 1264), True, 'import numpy as np\n'), ((1479, 1498), 'numpy.zeros', 'np.zeros', (['(delay + 1)'], {}), '(delay + 1)\n', (1487, 1498), True, 'import numpy as np\n'), ((1603, 1632), 'numpy.zeros_like', 'np.zeros_like', (['numerator_coef'], {}), '(numerator_coef)\n', (1616, 1632), True, 'import numpy as np\n'), ((2654, 2678), 'armory.utils.config_loading.load_model', 'load_model', (['model_config'], {}), '(model_config)\n', (2664, 2678), False, 'from armory.utils.config_loading import load_dataset, load_model, load_attack, load_adversarial_dataset, load_defense_wrapper, load_defense_internal, load_label_targeter\n'), ((5382, 5506), 'armory.utils.metrics.MetricsLogger.from_config', 'metrics.MetricsLogger.from_config', (["config['metric']"], {'skip_benign': 'skip_benign', 'skip_attack': 'skip_attack', 'targeted': 'targeted'}), "(config['metric'], skip_benign=skip_benign,\n skip_attack=skip_attack, targeted=targeted)\n", (5415, 5506), False, 'from armory.utils import metrics\n'), ((8664, 8694), 'tqdm.tqdm', 'tqdm', (['test_data'], {'desc': '"""Attack"""'}), "(test_data, desc='Attack')\n", (8668, 8694), False, 'from tqdm import tqdm\n'), ((1716, 1801), 'art.preprocessing.audio.LFilterPyTorch', 'LFilterPyTorch', ([], {'numerator_coef': 'numerator_coef', 'denominator_coef': 'denominator_coef'}), '(numerator_coef=numerator_coef, denominator_coef=denominator_coef\n )\n', (1730, 1801), False, 'from art.preprocessing.audio import LFilter, LFilterPyTorch\n'), ((3627, 3678), 'armory.utils.config_loading.load_defense_internal', 'load_defense_internal', (["config['defense']", 'estimator'], {}), "(config['defense'], estimator)\n", (3648, 3678), False, 'from armory.utils.config_loading import load_dataset, load_model, load_attack, load_adversarial_dataset, load_defense_wrapper, load_defense_internal, load_label_targeter\n'), ((5126, 5176), 'armory.utils.config_loading.load_defense_wrapper', 'load_defense_wrapper', (["config['defense']", 'estimator'], {}), "(config['defense'], estimator)\n", (5146, 5176), False, 'from armory.utils.config_loading import load_dataset, load_model, load_attack, load_adversarial_dataset, load_defense_wrapper, load_defense_internal, load_label_targeter\n'), ((6098, 6213), 'armory.utils.config_loading.load_dataset', 'load_dataset', (["config['dataset']"], {'epochs': '(1)', 'split': 'eval_split', 'num_batches': 'num_eval_batches', 'shuffle_files': '(False)'}), "(config['dataset'], epochs=1, split=eval_split, num_batches=\n num_eval_batches, shuffle_files=False)\n", (6110, 6213), False, 'from armory.utils.config_loading import load_dataset, load_model, load_attack, load_adversarial_dataset, load_defense_wrapper, load_defense_internal, load_label_targeter\n'), ((6395, 6425), 'tqdm.tqdm', 'tqdm', (['test_data'], {'desc': '"""Benign"""'}), "(test_data, desc='Benign')\n", (6399, 6425), False, 'from tqdm import tqdm\n'), ((7519, 7644), 'armory.utils.config_loading.load_adversarial_dataset', 'load_adversarial_dataset', (['attack_config'], {'epochs': '(1)', 'split': '"""adversarial"""', 'num_batches': 'num_eval_batches', 'shuffle_files': '(False)'}), "(attack_config, epochs=1, split='adversarial',\n num_batches=num_eval_batches, shuffle_files=False)\n", (7543, 7644), False, 'from armory.utils.config_loading import load_dataset, load_model, load_attack, load_adversarial_dataset, load_defense_wrapper, load_defense_internal, load_label_targeter\n'), ((7771, 7808), 'armory.utils.config_loading.load_attack', 'load_attack', (['attack_config', 'estimator'], {}), '(attack_config, estimator)\n', (7782, 7808), False, 'from armory.utils.config_loading import load_dataset, load_model, load_attack, load_adversarial_dataset, load_defense_wrapper, load_defense_internal, load_label_targeter\n'), ((8011, 8126), 'armory.utils.config_loading.load_dataset', 'load_dataset', (["config['dataset']"], {'epochs': '(1)', 'split': 'eval_split', 'num_batches': 'num_eval_batches', 'shuffle_files': '(False)'}), "(config['dataset'], epochs=1, split=eval_split, num_batches=\n num_eval_batches, shuffle_files=False)\n", (8023, 8126), False, 'from armory.utils.config_loading import load_dataset, load_model, load_attack, load_adversarial_dataset, load_defense_wrapper, load_defense_internal, load_label_targeter\n'), ((8488, 8563), 'armory.utils.export.SampleExporter', 'SampleExporter', (['self.scenario_output_dir', 'test_data.context', 'export_samples'], {}), '(self.scenario_output_dir, test_data.context, export_samples)\n', (8502, 8563), False, 'from armory.utils.export import SampleExporter\n'), ((4653, 4703), 'armory.utils.config_loading.load_defense_wrapper', 'load_defense_wrapper', (["config['defense']", 'estimator'], {}), "(config['defense'], estimator)\n", (4673, 4703), False, 'from armory.utils.config_loading import load_dataset, load_model, load_attack, load_adversarial_dataset, load_defense_wrapper, load_defense_internal, load_label_targeter\n'), ((8275, 8328), 'armory.utils.config_loading.load_label_targeter', 'load_label_targeter', (["attack_config['targeted_labels']"], {}), "(attack_config['targeted_labels'])\n", (8294, 8328), False, 'from armory.utils.config_loading import load_dataset, load_model, load_attack, load_adversarial_dataset, load_defense_wrapper, load_defense_internal, load_label_targeter\n')]
|
import tensorflow as tf
from os import path
import numpy as np
from scipy import misc
from styx_msgs.msg import TrafficLight
import cv2
import rospy
import tensorflow as tf
class CarlaModel(object):
def __init__(self, model_checkpoint):
self.sess = None
self.checkpoint = model_checkpoint
self.prob_thr = 0.90
self.TRAFFIC_LIGHT_CLASS = 10
self.image_no = 10000
tf.reset_default_graph()
def predict(self, img):
if self.sess == None:
gd = tf.GraphDef()
gd.ParseFromString(tf.gfile.GFile(self.checkpoint, "rb").read())
tf.import_graph_def(gd, name="object_detection_api")
self.sess = tf.Session()
g = tf.get_default_graph()
self.image = g.get_tensor_by_name("object_detection_api/image_tensor:0")
self.boxes = g.get_tensor_by_name("object_detection_api/detection_boxes:0")
self.scores = g.get_tensor_by_name("object_detection_api/detection_scores:0")
self.classes = g.get_tensor_by_name("object_detection_api/detection_classes:0")
img_h, img_w = img.shape[:2]
self.image_no = self.image_no+1
cv2.imwrite("full_"+str(self.image_no)+".png", img)
for h0 in [img_h//3, (img_h//3)-150]:
for w0 in [0, img_w//3, img_w*2//3]:
grid = img[h0:h0+img_h//3+50, w0:w0+img_w//3, :] # grid
pred_boxes, pred_scores, pred_classes = self.sess.run([self.boxes, self.scores, self.classes],
feed_dict={self.image: np.expand_dims(grid, axis=0)})
pred_boxes = pred_boxes.squeeze()
pred_scores = pred_scores.squeeze() # descreding order
pred_classes = pred_classes.squeeze()
traffic_light = None
h, w = grid.shape[:2]
cv2.imwrite("grid_"+str(self.image_no)+"_"+str(h0)+"_"+str(w0)+".png",grid)
rospy.loginfo("w,h is %s,%s",h0,w0)
for i in range(pred_boxes.shape[0]):
box = pred_boxes[i]
score = pred_scores[i]
if score < self.prob_thr: continue
if pred_classes[i] != self.TRAFFIC_LIGHT_CLASS: continue
x0, y0 = box[1] * w, box[0] * h
x1, y1 = box[3] * w, box[2] * h
x0, y0, x1, y1 = map(int, [x0, y0, x1, y1])
x_diff = x1 - x0
y_diff = y1 - y0
xy_ratio = x_diff/float(y_diff)
rospy.loginfo("image_no is %s", self.image_no)
rospy.loginfo("x,y ratio is %s",xy_ratio)
rospy.loginfo("score is %s",score)
if xy_ratio > 0.48: continue
area = np.abs((x1-x0) * (y1-y0)) / float(w*h)
rospy.loginfo("area is %s",area)
if area <= 0.001: continue
traffic_light = grid[y0:y1, x0:x1]
rospy.loginfo("traffic light given")
# select first -most confidence
if traffic_light is not None: break
if traffic_light is not None: break
if traffic_light is None:
pass
else:
rospy.loginfo("w,h is %s,%s",h0,w0)
rospy.loginfo("x,y ratio is %s",xy_ratio)
rospy.loginfo("score is %s",score)
cv2.imwrite("light_"+str(self.image_no)+".png",traffic_light)
#cv2.imwrite("full_"+str(self.image_no)+".png", img)
#cv2.imwrite("grid_"+str(self.image_no)+".png",grid)
#self.image_no = self.image_no+1
brightness = cv2.cvtColor(traffic_light, cv2.COLOR_RGB2HSV)[:,:,-1]
hs, ws = np.where(brightness >= (brightness.max()-30))
hs_mean = hs.mean()
tl_h = traffic_light.shape[0]
if hs_mean / tl_h < 0.4:
rospy.loginfo("image"+str(self.image_no-1)+" is RED")
return TrafficLight.RED
elif hs_mean / tl_h >= 0.55:
rospy.loginfo("image"+str(self.image_no-1)+" is GREEN")
return TrafficLight.GREEN
else:
rospy.loginfo("image"+str(self.image_no-1)+" is YELLOW")
return TrafficLight.YELLOW
return TrafficLight.UNKNOWN
|
[
"numpy.abs",
"tensorflow.reset_default_graph",
"tensorflow.Session",
"tensorflow.GraphDef",
"tensorflow.import_graph_def",
"cv2.cvtColor",
"tensorflow.gfile.GFile",
"numpy.expand_dims",
"rospy.loginfo",
"tensorflow.get_default_graph"
] |
[((417, 441), 'tensorflow.reset_default_graph', 'tf.reset_default_graph', ([], {}), '()\n', (439, 441), True, 'import tensorflow as tf\n'), ((522, 535), 'tensorflow.GraphDef', 'tf.GraphDef', ([], {}), '()\n', (533, 535), True, 'import tensorflow as tf\n'), ((625, 677), 'tensorflow.import_graph_def', 'tf.import_graph_def', (['gd'], {'name': '"""object_detection_api"""'}), "(gd, name='object_detection_api')\n", (644, 677), True, 'import tensorflow as tf\n'), ((702, 714), 'tensorflow.Session', 'tf.Session', ([], {}), '()\n', (712, 714), True, 'import tensorflow as tf\n'), ((740, 762), 'tensorflow.get_default_graph', 'tf.get_default_graph', ([], {}), '()\n', (760, 762), True, 'import tensorflow as tf\n'), ((3384, 3421), 'rospy.loginfo', 'rospy.loginfo', (['"""w,h is %s,%s"""', 'h0', 'w0'], {}), "('w,h is %s,%s', h0, w0)\n", (3397, 3421), False, 'import rospy\n'), ((3432, 3474), 'rospy.loginfo', 'rospy.loginfo', (['"""x,y ratio is %s"""', 'xy_ratio'], {}), "('x,y ratio is %s', xy_ratio)\n", (3445, 3474), False, 'import rospy\n'), ((3486, 3521), 'rospy.loginfo', 'rospy.loginfo', (['"""score is %s"""', 'score'], {}), "('score is %s', score)\n", (3499, 3521), False, 'import rospy\n'), ((2027, 2064), 'rospy.loginfo', 'rospy.loginfo', (['"""w,h is %s,%s"""', 'h0', 'w0'], {}), "('w,h is %s,%s', h0, w0)\n", (2040, 2064), False, 'import rospy\n'), ((3795, 3841), 'cv2.cvtColor', 'cv2.cvtColor', (['traffic_light', 'cv2.COLOR_RGB2HSV'], {}), '(traffic_light, cv2.COLOR_RGB2HSV)\n', (3807, 3841), False, 'import cv2\n'), ((2646, 2692), 'rospy.loginfo', 'rospy.loginfo', (['"""image_no is %s"""', 'self.image_no'], {}), "('image_no is %s', self.image_no)\n", (2659, 2692), False, 'import rospy\n'), ((2713, 2755), 'rospy.loginfo', 'rospy.loginfo', (['"""x,y ratio is %s"""', 'xy_ratio'], {}), "('x,y ratio is %s', xy_ratio)\n", (2726, 2755), False, 'import rospy\n'), ((2775, 2810), 'rospy.loginfo', 'rospy.loginfo', (['"""score is %s"""', 'score'], {}), "('score is %s', score)\n", (2788, 2810), False, 'import rospy\n'), ((2957, 2990), 'rospy.loginfo', 'rospy.loginfo', (['"""area is %s"""', 'area'], {}), "('area is %s', area)\n", (2970, 2990), False, 'import rospy\n'), ((3112, 3148), 'rospy.loginfo', 'rospy.loginfo', (['"""traffic light given"""'], {}), "('traffic light given')\n", (3125, 3148), False, 'import rospy\n'), ((567, 604), 'tensorflow.gfile.GFile', 'tf.gfile.GFile', (['self.checkpoint', '"""rb"""'], {}), "(self.checkpoint, 'rb')\n", (581, 604), True, 'import tensorflow as tf\n'), ((2898, 2927), 'numpy.abs', 'np.abs', (['((x1 - x0) * (y1 - y0))'], {}), '((x1 - x0) * (y1 - y0))\n', (2904, 2927), True, 'import numpy as np\n'), ((1636, 1664), 'numpy.expand_dims', 'np.expand_dims', (['grid'], {'axis': '(0)'}), '(grid, axis=0)\n', (1650, 1664), True, 'import numpy as np\n')]
|
# -*- coding: utf-8 -*-
# Copyright (c) 2021 The HERA Collaboration
# Licensed under the MIT License
"""Utilities for dealing with galaxy/QSO catalogs."""
import numpy as np
import matplotlib.pyplot as plt
from astropy.coordinates import SkyCoord
from .util import deg_per_hr
_xshooter_ref = "https://ui.adsabs.harvard.edu/abs/2020ApJ...905...51S/abstract"
# VIKING
_viking_ref1 = "https://ui.adsabs.harvard.edu/abs/2013ApJ...779...24V/abstract"
_viking_ref2 = "https://ui.adsabs.harvard.edu/abs/2015MNRAS.453.2259V/abstract"
_viking = {
"J2348-3054": {
"ra": "23h48m33.34s",
"dec": "-30d54m10.0s",
"z": 6.886,
"ref": _viking_ref1,
},
"J0109-3047": {
"ra": "01h09m53.13s",
"dec": "-30d47m26.3s",
"z": 6.745,
"ref": _viking_ref1,
},
"J0305-3150": {
"ra": "03h05m16.92s",
"dec": "-31d50m56.0s",
"z": 6.604,
"ref": _viking_ref1,
},
"J0328-3253": {
"ra": "03h28m35.511s",
"dec": "-32d53m22.92s",
"z": 5.860,
"ref": _viking_ref2,
},
"J0046-2837": {
"ra": "00h46m23.645s",
"dec": "-28d37m47.34s",
"z": 5.9926,
"ref": _xshooter_ref,
},
"J2211-3206": {
"ra": "22h11m12.391s",
"dec": "-32d06m12.95s",
"z": 6.3394,
"ref": _xshooter_ref,
},
"J2318-3029": {
"ra": "23h18m33.103s",
"dec": "-30d29m33.36s",
"z": 6.1456,
"ref": _xshooter_ref,
},
"J2348-3054_xshooter": {
"ra": "23h48m33.336s",
"dec": "-30d54m10.24s",
"z": 6.9007,
"ref": _xshooter_ref,
},
}
# Pan-STARRS1
_ps1_ref1 = "https://ui.adsabs.harvard.edu/abs/2014AJ....148...14B/abstract"
_ps1_ref2 = "https://ui.adsabs.harvard.edu/abs/2017ApJ...849...91M/abstract"
_ps1 = {
"PSO 231-20": {"ra": "231.6576", "dec": "-20.8335", "z": 6.5864, "ref": _ps1_ref2},
"PSO J037.9706-28.8389": {
"ra": "02h31m52.96s",
"dec": "-28d50m20.1s",
"z": 5.99,
"ref": _ps1_ref1,
},
"PSO J065.4085-26.9543": {
"ra": "04h21m38.049s",
"dec": "-26d57m15.61s",
"z": 6.1871,
"ref": _xshooter_ref,
},
}
# Banados+ 2016 https://ui.adsabs.harvard.edu/abs/2016ApJS..227...11B/abstract
# has table of all z > 5.6 quasars known at that point (March 2016).
# https://ned.ipac.caltech.edu/inrefcode?search_type=Search&refcode=2016ApJS..227...11B
# VLT ATLAS
# https://ui.adsabs.harvard.edu/abs/2015MNRAS.451L..16C/abstract
_atlas_ref1 = "https://ui.adsabs.harvard.edu/abs/2015MNRAS.451L..16C/abstract"
_atlas_ref2 = "https://ui.adsabs.harvard.edu/abs/2018MNRAS.478.1649C/abstract"
_atlas = {
"J025.6821-33.4627": {
"ra": "025.6821",
"dec": "-33.4627",
"z": 6.31,
"ref": _atlas_ref1,
},
"J332.8017-32.1036": {
"ra": "332.8017",
"dec": "-32.1036",
"z": 6.32,
"ref": _atlas_ref2,
},
}
# VHS-DES
_ps1_vhs_des = "https://ui.adsabs.harvard.edu/abs/2019MNRAS.487.1874R/abstract"
_des = {
"VDES J0020-3653": {
"ra": "00h20m31.47s",
"dec": "-36d53m41.8s",
"z": 6.5864,
"ref": _ps1_vhs_des,
},
}
_yang = "https://ui.adsabs.harvard.edu/abs/2020ApJ...904...26Y/abstract"
_decarli = "https://ui.adsabs.harvard.edu/abs/2018ApJ...854...97D/abstract"
_other = {
"J0142−3327": {"ra": "0142", "dec": "-3327", "z": 6.3379, "ref": _yang},
"J0148−2826": {"ra": "0148", "dec": "-2826", "z": 6.54, "ref": _yang},
"J2002−3013": {"ra": "2002", "dec": "-3013", "z": 6.67, "ref": _yang},
"J2318–3113": {
"ra": "23h18m18.351s",
"dec": "-31d13m46.35s",
"z": 6.444,
"ref": _decarli,
},
}
def _to_decimal(s):
if "." in s:
out = float(s)
elif s[0] == "-":
out = float(s[0:3] + "." + s[3:])
else:
out = float(s[0:2] + "." + s[2:])
return out
_qso_catalogs = {"viking": _viking, "panstarrs": _ps1, "atlas": _atlas, "other": _other}
class Catalog(object):
"""
Define a class for handling QSO catalogs.
Parameters
----------
data : str
The type of data to handle. Right now "qso" is the only allowed value.
kwargs : dict
Keyword arguments to save directly on the object.
"""
def __init__(self, data, **kwargs):
self.data = data
self.kwargs = kwargs
def plot_catalog(
self, ax=None, zmin=None, num=1, projection="rectilinear", **fig_kwargs
):
"""
Plot a catalog using matplotlib.
Parameters
----------
ax : matplotlib axis object, optional
The axes to use for plotting. If None, then a new figure and axis
will be created.
zmin : float, optional
The minimum redshift to use for plotting objects.
num : int, optional
The figure number to create if `ax` is not provided.
projection : str, optional
The projection to use for plotting.
kwargs : dict, optional
Additional kwargs passed to matplotlib.pyplot.figure
Returns
-------
ax : matplotlib axis object
If `ax` is provided as a parameter, the same axis object. Otherwise,
a new one.
Raises
------
NotImplementedError
Raised if any projection besides "rectilinear" is passed.
"""
if projection != "rectilinear":
raise NotImplementedError("Only know rectilinear projection right now!")
# Setup plot window
has_ax = True
if ax is None:
fig = plt.figure(num=num, **fig_kwargs)
ax = fig.gca()
has_ax = False
# Get all objects in catalog
names, coords = self.get_all_pos(zmin=zmin)
# Loop over them all and plot. Could do a lot more efficiently if
# we ever end up with big catalogs.
for i, coord in enumerate(coords):
ra, dec, z = coord
ax.scatter(ra, dec)
if not has_ax:
ax.set_xlabel(r"Right Ascension [hours]", fontsize=24, labelpad=5)
ax.set_ylabel(r"Declination [deg]", fontsize=24, labelpad=5)
return ax
def get_all_pos(self, zmin=None):
"""
Return a list of (RA, DEC, redshift) for all objects.
Parameters
----------
zmin : float
The minimum redshift to include for objects in the catalog.
Returns
-------
names : list of str, shape (n_objects)
The names of objects in the catalog.
data : ndarray, shape (n_objects, 3)
The RA [hour angle], dec [degree], and redshift of the objects.
Raises
------
ValueError
This is raised if `self.data` is not "qso", as this is the only type
of data we know how to handle right now.
"""
if not self.data.lower().startswith("qso"):
raise ValueError("Only know how to do QSOs right now.")
data = []
names = []
for cat in _qso_catalogs.keys():
for element in _qso_catalogs[cat]:
obj = _qso_catalogs[cat][element]
if zmin is not None:
if obj["z"] < zmin:
continue
if "h" in obj["ra"]:
kw = {"frame": "icrs"}
ra = obj["ra"]
dec = obj["dec"]
else:
kw = {"unit": "degree", "frame": "icrs"}
if len(obj["ra"]) == 4:
ra = _to_decimal(obj["ra"]) * deg_per_hr
else:
ra = _to_decimal(obj["ra"])
dec = _to_decimal(obj["dec"])
coord = SkyCoord(ra, dec, **kw)
names.append(element)
data.append((coord.ra.hour, coord.dec.degree, obj["z"]))
return names, np.array(data)
|
[
"numpy.array",
"matplotlib.pyplot.figure",
"astropy.coordinates.SkyCoord"
] |
[((5676, 5709), 'matplotlib.pyplot.figure', 'plt.figure', ([], {'num': 'num'}), '(num=num, **fig_kwargs)\n', (5686, 5709), True, 'import matplotlib.pyplot as plt\n'), ((8031, 8045), 'numpy.array', 'np.array', (['data'], {}), '(data)\n', (8039, 8045), True, 'import numpy as np\n'), ((7872, 7895), 'astropy.coordinates.SkyCoord', 'SkyCoord', (['ra', 'dec'], {}), '(ra, dec, **kw)\n', (7880, 7895), False, 'from astropy.coordinates import SkyCoord\n')]
|
"""*****************************************************************************************
MIT License
Copyright (c) 2022 <NAME>, <NAME>, <NAME>, <NAME>, <NAME>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*****************************************************************************************"""
import Utils
from helper_functions import Fast_Caratheodory
import numpy as np
from scipy.optimize import linprog
from numpy import linalg as la
from scipy.linalg import null_space
from numpy.linalg import matrix_rank
from sklearn.decomposition import TruncatedSVD
import time
######################################################## Caratheodory ##################################################
def computeInitialWeightVector(P, p):
"""
This function given a point, solves the linear program dot(self.P.P^T, x) = p where x \in [0, \infty)^n,
and n denotes the number of rows of self.P.P.
:param p: A numpy array representing a point.
:return: A numpy array of n non-negative weights with respect to each row of self.P.P
"""
N = P.shape[0] # number of rows of P
# # Solve the linear program using scipy
# ts = time.time()
Q = P.T
Q = np.vstack((Q, np.ones((1, N))))
b = np.hstack((p, 1))
res = linprog(np.ones((N,)), A_eq=Q, b_eq=b, options={'maxiter': int(1e7), 'tol': 1e-10})
w = res.x
assert (np.linalg.norm(np.dot(P.T, w) - p) <= 1e-9, np.linalg.norm(np.dot(P.T, w) - p))
return w
def attainCaratheodorySet(P, p):
"""
The function at hand returns a set of at most d+1 indices of rows of P where d denotes the dimension of
rows of P. It calls the algorithms implemented by <NAME>, <NAME> and <NAME> at
"Fast and Accurate Least-Mean-Squares Solvers".
:param p: A numpy array denoting a point.
:return: The indices of points from self.P.P which p is a convex combination of.
"""
d = P.shape[1]
u = computeInitialWeightVector(P, p) # compute initial weight vector
# print('Sum of weights {}'.format(np.sum(u)))
if np.count_nonzero(u) > (d + 1): # if the number of positive weights exceeds d+1
u = Fast_Caratheodory(P, u.flatten(), False)
assert(np.linalg.norm(p - np.dot(P.T, u)) <= 1e-9, np.linalg.norm(p - np.dot(P.T, u)))
return np.where(u != 0)[0]
############################################################ AMVEE #####################################################
def isPD(B):
"""Returns true when input is positive-definite, via Cholesky"""
try:
_ = la.cholesky(B)
return True
except la.LinAlgError:
return False
def nearestPD(A):
"""Find the nearest positive-definite matrix to input
A Python/Numpy port of <NAME>'s `nearestSPD` MATLAB code [1], which
credits [2].
[1] https://www.mathworks.com/matlabcentral/fileexchange/42885-nearestspd
[2] <NAME>, "Computing a nearest symmetric positive semidefinite
matrix" (1988): https://doi.org/10.1016/0024-3795(88)90223-6
"""
B = (A + A.T) / 2
_, s, V = la.svd(B)
H = np.dot(V.T, np.dot(np.diag(s), V))
A2 = (B + H) / 2
A3 = (A2 + A2.T) / 2
if isPD(A3):
return A3
spacing = np.spacing(la.norm(A))
# The above is different from [1]. It appears that MATLAB's `chol` Cholesky
# decomposition will accept matrixes with exactly 0-eigenvalue, whereas
# Numpy's will not. So where [1] uses `eps(mineig)` (where `eps` is Matlab
# for `np.spacing`), we use the above definition. CAVEAT: our `spacing`
# will be much larger than [1]'s `eps(mineig)`, since `mineig` is usually on
# the order of 1e-16, and `eps(1e-16)` is on the order of 1e-34, whereas
# `spacing` will, for Gaussian random matrixes of small dimension, be on
# othe order of 1e-16. In practice, both ways converge, as the unit test
# below suggests.
I = np.eye(A.shape[0])
k = 1
while not isPD(A3):
mineig = np.min(np.real(la.eigvals(A3)))
A3 += I * (-mineig * k ** 2 + spacing)
k += 1
return A3
def computeAxesPoints(E, C):
"""
This function finds the vertices of the self.E (the MVEE of P or the inscribed version of it)
:return: A numpy matrix containing the vertices of the ellipsoid.
"""
if not isPD(E):
E = nearestPD(E)
# L = np.linalg.cholesky(self.E) # compute the cholesky decomposition of self.E
# U, D, V = np.linalg.svd(L, full_matrices=True) # attain the length of each axis of the ellipsoid and the
# # rotation of the ellipsoid
_, D, V = np.linalg.svd(E, full_matrices=True)
ellips_points = np.multiply(1.0 / np.sqrt(D[:, np.newaxis]), V.T) # attain the vertices of the ellipsoid assuming it was
# centered at the origin
return np.vstack((ellips_points + C.flatten(), - ellips_points + C.flatten()))
def volumeApproximation(P):
"""
This is our implementation of Algorithm 4.1 at the paper "On Khachiyan’s Algorithm for te Computation of Minimum
Volume Enclosing Ellipsoids" by <NAME> and <NAME>. It serves to compute a set of at most
2*self.P.d points which will be used for computing an initial ellipsoid.
:return: A numpy array of 2 * self.P.d indices of points from self.P.P
"""
basis = None
basis_points = []
n, d = P
if n <= 2 * d:
# if number of points is less than 2*self.P.d, then return their indices in self.P.P
return [i for i in range(n)]
v = np.random.randn(d) # start with a random vector
while np.linalg.matrix_rank(basis) < d: # while rank of basis is less than self.P.d
if basis is not None: # if we already have computed basis points
if basis.shape[1] == d:
# if this line is reached then it means that there is numerical instability
print('Numerical Issues!')
_, _, V = np.linalg.svd(basis[:, :-1], full_matrices=True)
return list(range(n))
orth_basis = null_space(basis.T) # get the orthant of basis
v = orth_basis[:, 0] if orth_basis.ndim > 1 else orth_basis # set v to be the first column of basis
Q = np.dot(P, v.T) # get the dot product of each row of self.P.P and v
if len(basis_points) > 0: # if there are already chosen points, then their dot product is depricated
Q[basis_points] = np.nan
p_alpha = np.nanargmax(np.dot(P, v.T)) # get the index of row with largest non nan dot product value
p_beta = np.nanargmin(np.dot(P, v.T)) # get the index of row with smallest non nan dot product value
v = np.expand_dims(P[p_beta, :] - P[p_alpha, :], 1) # let v be the substraction between the
# row of the largest dot product and the
# point with the smallest dot product
if basis is None: # if no basis was computed
basis = v / np.linalg.norm(v)
else: # add v to the basis
basis = np.hstack((basis, v / np.linalg.norm(v, 2)))
basis_points.append(p_alpha) # add the index of the point with largest dot product
basis_points.append(p_beta) # add the index of the point with smallest dot product
return basis_points
def computemahalanobisDistance(Q, ellip):
"""
This function is used for computing the distance between the rows of Q and ellip using the Mahalanobis
loss function.
:param ellip: A numpy array representing a p.s.d matrix (an ellipsoid)
:return: The Mahalanobis distance between each row in self.P.P to ellip.
"""
s = np.einsum("ij,ij->i", np.dot(Q, ellip), Q) # compute the distance efficiently
return s
def computeEllipsoid(P, weights):
"""
This function computes the ellipsoid which is the MVEE of self.P.
:param weights: a numpy of array of weights with respest to the rows of self.P.P.
:return:
- The MVEE of self.P.P in a p.s.d. matrix form.
- The center of the MVEE of self.P.P.
"""
if weights.ndim == 1: # make sure that the weights are not flattened
weights = np.expand_dims(weights, 1)
c = np.dot(P.T, weights) # attain the center of the MVEE
d = P.shape[1]
Q = P[np.where(weights.flatten() > 0.0)[0], :] # get all the points with positive weights
weights2 = weights[np.where(weights.flatten() > 0.0)[0], :] # get all the positive weights
# compute a p.s.d matrix which will represent the ellipsoid
ellipsoid = 1.0 / d * np.linalg.inv(np.dot(np.multiply(Q, weights2).T, Q)
- np.multiply.outer(c.T.ravel(), c.T.ravel()))
return ellipsoid, c
def enlargeByTol(ellipsoid):
"""
The function at hand enlarges the MVEE (the ellipsoid) by a fact or (1 + Utils.TOL).
:param ellipsoid: A numpy matrix represent a p.s.d matrix
:return: An enlarged version of ellipsoid.
"""
return ellipsoid / (1 + Utils.TOL) ** 2.0
def getContainedEllipsoid(ellipsoid):
"""
This function returns a dialtion of E such that it will be contained in the convex hull of self.P.P.
:param ellipsoid: A p.s.d matrix which represents the MVEE of self.P.P
:return: A dilated version of the MVEE of self.P.P such that it will be contained in the convex hull
of self.P.P.
"""
return ellipsoid * ellipsoid.shape[1] ** 2 * (1 + Utils.TOL) ** 2 # get inscribed ellipsoid
def computeEllipInHigherDimension(Q, weights):
"""
The function at hand computes the ellipsoid in a self.P.d + 1 dimensional space (with respect to the
lifted points) which is centered at the origin.
:param weights: A numpy array of weights with respect to each lifter point in self.Q
:return:
"""
idxs = np.where(weights > 0.0)[0] # get all indices of points with positive weights
weighted_Q = np.multiply(Q[idxs, :], np.expand_dims(np.sqrt(weights[idxs]), 1)) # multiply the postive
# weights with their
# corresponding points
delta = np.sum(np.einsum('bi,bo->bio', weighted_Q, weighted_Q), axis=0) # compute an ellipsoid which is
# centered at the origin
return delta
def optimalityCondition(d, Q, ellip, weights):
"""
This function checks if the MVEE of P is found in the context of <NAME> and <NAME>
algorithm.
:param ellip: A numpy array representing a p.s.d matrix.
:param weights: A numpy array of weights with respect to the rows of P.
:return: A boolean value whether the desired MVEE has been achieved or not.
"""
pos_weights_idxs = np.where(weights > 0)[0] # get the indices of all the points with positive weights
current_dists = computemahalanobisDistance(Q, ellip) # compute the Mahalanobis distance between ellip and
# the rows of P
# check if all the distance are at max (1 + self.tol) * (self.P.d +1) and the distances of the points
# with positive weights are at least (1.0 - self.tol) * (self.P.d + 1)
return np.all(current_dists <= (1.0 + Utils.TOL) * (d + 1)) and \
np.all(current_dists[pos_weights_idxs] >= (1.0 - Utils.TOL) * (d + 1)), current_dists
def yilidrimAlgorithm(P):
"""
This is our implementation of Algorithm 4.2 at the paper "On Khachiyan’s Algorithm for te Computation of Minimum
Volume Enclosing Ellipsoids" by <NAME> and <NAME>. It serves to compute an MVEE of self.P.P
faster than Khachiyan's algorithm.
:return: The MVEE ellipsoid of self.P.P.
"""
n, d = P.shape
Q = np.hstack((P, np.ones((n, 1))))
chosen_indices = volumeApproximation(P) # compute an initial set of points which will give the initial
# ellipsoid
if len(chosen_indices) == n: # if all the points were chosen then simply run Khachiyan's algorithm.
# Might occur due to numerical instabilities.
return khachiyanAlgorithm(P)
weights = np.zeros((n, 1)).flatten() # initial the weights to zeros
weights[chosen_indices] = 1.0 / len(chosen_indices) # all the chosen indices of points by the
# volume Approximation algorithm are given uniform weights
ellip = np.linalg.inv(computeEllipInHigherDimension(Q, weights)) # compute the initial ellipsoid
while True: # run till conditions are fulfilled
stop_flag, distances = optimalityCondition(d, Q, ellip, weights) # check if current ellipsoid is desired
# MVEE, and get the distance between rows
# of self.P.P to current ellipsoid
pos_weights_idx = np.where(weights > 0)[0] # get indices of points with positive weights
if stop_flag: # if desired MVEE is achieved
break
j_plus = np.argmax(distances) # index of maximal distance from the ellipsoid
k_plus = distances[j_plus] # maximal distance from the ellipsoid
j_minus = pos_weights_idx[np.argmin(distances[pos_weights_idx])] # get the the index of the points with
# positive weights which also have the
# smallest distance from the current
# ellipsoid
k_minus = distances[j_minus] # the smallest distance of the point among the points with positive weights
eps_plus = k_plus / (d + 1.0) - 1.0
eps_minus = 1.0 - k_minus / (d + 1.0)
if eps_plus > eps_minus: # new point is found and it is important
beta_current = (k_plus - d - 1.0) / ((d + 1) * (k_plus - 1.0))
weights = (1.0 - beta_current) * weights
weights[j_plus] = weights[j_plus] + beta_current
else: # a point which was already found before, yet has large impact on the ellipsoid
beta_current = min((d + 1.0 - k_minus) / ((d + 1.0) * (k_minus - 1.0)),
weights[j_minus]/(1 - weights[j_minus]))
weights = weights * (1 + beta_current)
weights[j_minus] = weights[j_minus] - beta_current
weights[weights < 0.0] = 0.0 # all negative weights are set to zero
ellip = np.linalg.inv(computeEllipInHigherDimension(weights)) # recompute the ellipsoid
return computeEllipsoid(P, weights)
def khachiyanAlgorithm(P):
"""
This is our implementation of Algorithm 3.1 at the paper "On Khachiyan’s Algorithm for te Computation of Minimum
Volume Enclosing Ellipsoids" by <NAME> and <NAME>. It serves to compute an MVEE of self.P.P
using Khachiyan's algorithm.
:return: The MVEE ellipsoid of self.P.P.
"""
err = 1
count = 1 # used for debugging purposes
n, d = P.shape
u = np.ones((n, 1)) / n # all points have uniform weights
Q = np.hstack((P, np.ones((n, 1))))
while err > Utils.TOL: # while the approximation of the ellipsoid is higher than desired
X = np.dot(np.multiply(Q, u).T, Q) # compute ellipsoid
M = computemahalanobisDistance(Q, np.linalg.inv(X)) # get Mahalanobis distances between rows of self.P.P
# and current ellipsoid
j = np.argmax(M) # index of point with maximal distance from current ellipsoid
max_val = M[j] # the maximal Mahalanobis distance from the rows of self.P.P and the current ellipsoid
step_size = (max_val - d - 1) / ((d + 1) * (max_val - 1))
new_u = (1 - step_size) * u # update weights
new_u[j, 0] += step_size
count += 1
err = np.linalg.norm(new_u - u) # set err to be the change between updated weighted and current weights
u = new_u
return computeEllipsoid(P, u)
def computeMVEE(P, alg_type=1):
"""
This function is responsible for running the desired algorithm chosen by the user (or by default value) for
computing the MVEE of P.
:param alg_type: An algorithm type indicator where 1 stands for yilidrim and 0 stands kachaiyan.
:return:
- The inscribed version of MVEE of P.
- The center of the MVEE of P.
- The vertices of the inscribed ellipsoid.
"""
global ax
if alg_type == 1: # yilidrim is chosen or by default
E, C = yilidrimAlgorithm(P)
else: # Kachaiyan, slower yet more numerically stable
E, C = khachiyanAlgorithm(P)
# self.plotEllipsoid(self.E, self.C, self.computeAxesPoints())
contained_ellipsoid = getContainedEllipsoid(E) # get inscribed ellipsoid
return contained_ellipsoid, C, computeAxesPoints(contained_ellipsoid, C)
################################################## ApproximateCenterProblems ###########################################
def computeLINFCoresetKOne(P):
"""
The function at hand computes an L∞ coreset for the matrix vector multiplication or the dot product, with
respect to the weighted set of points P.
:return:
- C: the coreset points, which are a subset of the rows of P
- idx_in_P: the indices with respect to the coreset points C in P.
- an upper bound on the approximation which our L∞ coreset is associated with.
"""
global max_time
r = matrix_rank(P[:, :-1]) # get the rank of P or the dimension of the span of P
d = P.shape[1]
if r < d - 1: # if the span of P is a subspace in REAL^d
svd = TruncatedSVD(n_components=r) # an instance of TruncatedSVD
Q = svd.fit_transform(P[:, :-1]) # reduce the dimensionality of P by taking their dot product by the
# subspace which spans P
Q = np.hstack((Q, np.expand_dims(P[:, -1], 1))) # concatenate the indices to their respected "projected"
# points
else: # if the span of P is REAL^d where d is the dimension of P
Q = P
start_time = time.time() # start counting the time here
if r > 1: # if the dimension of the "projected points" is not on a line
if Q.shape[1] - 1 >= Q.shape[0]:
return Q, np.arange(Q.shape[0]).astype(np.int), Utils.UPPER_BOUND(r)
else:
_, _, S = computeMVEE(Q[:, :-1], alg_type=0) # compute the MVEE of Q
else: # otherwise
# get the index of the maximal and minimal point on the line, i.e., both its ends
idx_in_P = np.unique([np.argmin(Q[:, :-1]).astype(np.int),
np.argmax(Q[:, :-1]).astype(np.int)]).tolist()
return Q[idx_in_P], idx_in_P, Utils.UPPER_BOUND(r)
C = []
# idx_in_P_list = []
# C_list = []
# ts = time.time()
# for q in S: # for each boundary points along the axis of the MVEE of Q
# K = attainCaratheodorySet(P[:, :-1], q) # get d+1 indices of points from Q where q is their convex
# # combination
# idx_in_P_list += [int(idx) for idx in K] # get the indices of the coreset point in Q
# C_list += [int(Q[idx, -1]) for idx in K] # the actual coreset points
# # print('Time for list {}'.format(time.time() - ts))
idx_in_P = np.empty((2*(Utils.J + 1) ** 2, )).astype(np.int)
C = np.empty((2*(Utils.J + 1) ** 2, )).astype(np.int)
idx = 0
# ts = time.time()
for q in S: # for each boundary points along the axis of the MVEE of Q
K = attainCaratheodorySet(Q[:, :-1], q) # get d+1 indices of points from Q where q is their convex
# combination
idx_in_P[idx:idx+K.shape[0]] = K.astype(np.int) # get the indices of the coreset point in Q
C[idx:idx+K.shape[0]] = Q[idx_in_P[idx:idx+K.shape[0]], -1].astype(np.int)
idx += K.shape[0]
# print('Time for numpy {}'.format(time.time() - ts))
return np.unique(C[:idx]), np.unique(idx_in_P[:idx]), Utils.UPPER_BOUND(r)
####################################################### Bicriteria #####################################################
def attainClosestPointsToSubspaces(P, W, flats, indices):
"""
This function returns the closest n/2 points among all of the n points to a list of flats.
:param flats: A list of flats where each flat is represented by an orthogonal matrix and a translation vector.
:param indices: A list of indices of points in self.P.P
:return: The function returns the closest n/2 points to flats.
"""
dists = np.empty((P[indices, :].shape[0], ))
N = indices.shape[0]
if not Utils.ACCELERATE_BICRETERIA:
for i in range(N):
dists[i] = np.min([
Utils.computeDistanceToSubspace(P[np.array([indices[i]]), :], flats[j][0], flats[j][1])
for j in range(len(flats))])
else:
dists = Utils.computeDistanceToSubspace(P[indices, :], flats[0], flats[1])
idxs = np.argpartition(dists, N // 2)[:N//2]
return idxs.tolist()
return np.array(indices)[np.argsort(dists).astype(np.int)[:int(N / 2)]].tolist()
def sortDistancesToSubspace(P, X, v, points_indices):
"""
The function at hand sorts the distances in an ascending order between the points and the flat denoted by (X,v).
:param X: An orthogonal matrix which it's span is a subspace.
:param v: An numpy array denoting a translation vector.
:param points_indices: a numpy array of indices for computing the distance to a subset of the points.
:return: sorted distances between the subset points addressed by points_indices and the flat (X,v).
"""
dists = Utils.computeDistanceToSubspace(P[points_indices, :], X, v) # compute the distance between the subset
# of points towards
# the flat which is represented by (X,v)
return np.array(points_indices)[np.argsort(dists).astype(np.int)].tolist() # return sorted distances
def computeSubOptimalFlat(P, weights):
"""
This function computes the sub optimal flat with respect to l2^2 loss function, which relied on computing the
SVD factorization of the set of the given points, namely P.
:param P: A numpy matrix which denotes the set of points.
:param weights: A numpy array of weightes with respect to each row (point) in P.
:return: A flat which best fits P with respect to the l2^2 loss function.
"""
v = np.average(P, axis=0, weights=weights) # compute the weighted mean of the points
svd = TruncatedSVD(algorithm='randomized', n_iter=1, n_components=Utils.J).fit(P-v)
V = svd.components_
return V, v # return a flat denoted by an orthogonal matrix and a translation vector
def clusterIdxsBasedOnKSubspaces(P, B):
"""
This functions partitions the points into clusters a list of flats.
:param B: A list of flats
:return: A numpy array such each entry contains the index of the flat to which the point which is related to the
entry is assigned to.
"""
n = P.shape[0]
idxs = np.arange(n) # a numpy array of indices
centers = np.array(B) # a numpy array of the flats
dists = np.apply_along_axis(lambda x: Utils.computeDistanceToSubspace(P[idxs, :], x[0], x[1]), 1, centers) # compute the
# distance between
# each point and
# each flat
idxs = np.argmin(dists, axis=0)
return idxs # return the index of the closest flat to each point in self.P.P
def addFlats(P, W, S, B):
"""
This function is responsible for computing a set of all possible flats which passes through j+1 points.
:param S: list of j+1 subsets of points.
:return: None (Add all the aforementioned flats into B).
"""
indices = [np.arange(S[i].shape[0]) for i in range(len(S))]
points = np.meshgrid(*indices) # compute a mesh grid using the duplicated coefs
points = np.array([p.flatten() for p in points]) # flatten each point in the meshgrid for computing the
# all possible ordered sets of j+1 points
idx = len(B)
for i in range(points.shape[1]):
A = [S[j][points[j, i]][0] for j in range(points.shape[0])]
P_sub, W_sub = P[A, :], W[A]
B.append(computeSubOptimalFlat(P_sub, W_sub))
return np.arange(idx, len(B)), B
def computeBicriteria(P, W):
"""
The function at hand is an implemetation of Algorithm Approx-k-j-Flats(P, k, j) at the paper
"Bi-criteria Linear-time Approximations for Generalized k-Mean/Median/Center". The algorithm returns an
(2^j, O(log(n) * (jk)^O(j))-approximation algorithm for the (k,j)-projective clustering problem using the l2^2
loss function.
:return: A (2^j, O(log(n) * (jk)^O(j)) approximation solution towards the optimal solution.
"""
n = P.shape[0]
Q = np.arange(0, n, 1)
t = 1
B = []
tol_sample_size = Utils.K * (Utils.J + 1)
sample_size = (lambda t: int(np.ceil(Utils.K * (Utils.J + 1) * (2 + np.log(Utils.J + 1) +
np.log(Utils.K) +
min(t, np.log(np.log(n)))))))
while np.size(Q) >= tol_sample_size: # run we have small set of points
S = []
for i in range(0, Utils.J+1): # Sample j + 1 subsets of the points in an i.i.d. fashion
random_sample = np.random.choice(Q, size=sample_size(t))
S.append(random_sample[:, np.newaxis])
if not Utils.ACCELERATE_BICRETERIA:
F = addFlats(P, W, S, B)
else:
S = np.unique(np.vstack(S).flatten())
F = computeSubOptimalFlat(P[S, :], W[S])
B.append(F)
sorted_indices = attainClosestPointsToSubspaces(P, W, F, Q)
Q = np.delete(Q, sorted_indices)
t += 1
if not Utils.ACCELERATE_BICRETERIA:
_, B = addFlats(P, W, [Q for i in range(Utils.J + 1)], B)
else:
F = computeSubOptimalFlat(P[Q.flatten(), :], W[Q.flatten()])
B.append(F)
return B
################################################### L1Coreset ##########################################################
def applyBiCriterea(P, W):
"""
The function at hand runs a bicriteria algorithm, which then partition the rows of P into clusters.
:return:
- B: The set of flats which give the bicriteria algorithm, i.e., O((jk)^{j+1}) j-flats which attain 2^j
approximation towards the optimal (k,j)-projective clustering problem involving self.P.P.
- idxs: The set of indices where each entry is with respect to a point in P and contains
index of the flat in B which is assigned to respected point in P.
"""
B = computeBicriteria(P,W) # compute the set of flats which bi-cirteria algorithm returns
idxs = clusterIdxsBasedOnKSubspaces(P, B) # compute for each point which flat fits it best
return B, idxs
def initializeSens(P, B, idxs):
"""
This function initializes the sensitivities using the bicriteria algorithm, to be the distance between each
point to it's closest flat from the set of flats B divided by the sum of distances between self.P.P and B.
:param B: A set of flats where each flat is represented by an orthogonal matrix and a translation vector.
:param idxs: A numpy array which represents the clustering which B imposes on self.P.P
:return: None.
"""
centers_idxs = np.unique(idxs) # number of clusters imposed by B
sensitivity_additive_term = np.zeros((P.shape[0], ))
for center_idx in centers_idxs: # go over each cluster of points from self.P.P
cluster_per_center = np.where(idxs == center_idx)[0] # get all points in certain cluster
# compute the distance of each point in the cluster to its respect flat
cost_per_point_in_cluster = Utils.computeDistanceToSubspace(P[cluster_per_center, :-1],
B[center_idx][0], B[center_idx][1])
# ost_per_point_in_cluster = np.apply_along_axis(lambda x:
# Utils.computeDistanceToSubspace(x, B[center_idx][0],
# B[center_idx][1]), 1,
# self.set_P.P[cluster_per_center, :-1])
# set the sensitivity to the distance of each point from its respected flat divided by the total distance
# between cluster points and the respected flat
sensitivity_additive_term[cluster_per_center] = 2 ** Utils.J * \
np.nan_to_num(cost_per_point_in_cluster /
np.sum(cost_per_point_in_cluster))
return sensitivity_additive_term
def Level(P, k, V, desired_eps=0.01):
"""
The algorithm is an implementation of Algorithm 7 of "Coresets for Gaussian Mixture Models of Any shapes" by Zahi
Kfir and <NAME>.
:param P: A Pointset object, i.e., a weighted set of points.
:param k: The number of $j$-subspaces which defines the (k,j)-projective clustering problem.
:param V: A set of numpy arrays
:param desired_eps: An approximation error, default value is set to 0.01.
:return: A list "C" of subset of points of P.P.
"""
t = V.shape[0] # numnber of points in V
d = P.shape[1] - 1 # exclude last entry of each point for it is the concatenated index
# C = [[]] #np.empty((P.shape[0] + Utils.J ** (2 * Utils.K), P.shape[1])) # initialize list of coresets
# U = [[]] #np.empty((P.shape[0] + Utils.J ** (2 * Utils.K), P.shape[1])) # list of each point in V \setminus V_0 minus its
# projection onto a specific affine subspace, see below
C = np.zeros((P.shape[0], ), dtype="bool")
D = np.zeros((P.shape[0], ), dtype="bool")
if k <= 1 or t-1 >= Utils.J:
return np.array([])
# ts = time.time()
A, v = Utils.computeAffineSpan(V)
# print('Affine took {}'.format(time.time() - ts))
dists_from_P_to_A = Utils.computeDistanceToSubspace(P[:, :-1], A.T, v)
non_zero_idxs = np.where(dists_from_P_to_A > 1e-11)[0]
d_0 = 0 if len(non_zero_idxs) < 1 else np.min(dists_from_P_to_A[non_zero_idxs])
c = 1 / d ** (1.5 * (d + 1))
M = np.max(np.abs(P[:, :-1]))
on_j_subspace = np.where(dists_from_P_to_A <= 1e-11)[0]
B = [[]]
if on_j_subspace.size != 0:
B[0] = P[on_j_subspace, :]
if B[0].shape[0] >= Utils.J ** (2 * k):
indices_in_B = B[0][:, -1]
Q = np.hstack((B[0][:,:-1], np.arange(B[0].shape[0])[:, np.newaxis]))
temp = computeLInfCoreset(B[0], k-1)
C[indices_in_B[temp].astype(np.int)] = True
else:
C[B[0][:, -1].astype(np.int)] = True
# current_point += temp.shape[0]
# D = [P[C]]
# print('Bound is {}'.format(int(np.ceil(8 * np.log(M) + np.log(1.0/c)) + 1)))
if d_0 > 0:
for i in range(1, int(np.ceil(8 * np.log(M) + np.log(1.0/c)) + 1)):
B.append(P[np.where(np.logical_and(2 ** (i-1) * d_0 <= dists_from_P_to_A,
dists_from_P_to_A <= 2 ** i * d_0))[0], :])
if len(B[i]) > 0:
if len(B[i]) >= Utils.J ** (2 * k):
indices_B = B[i][:, -1]
Q_B = np.hstack((B[i][:, :-1], np.arange(B[i].shape[0])[:, np.newaxis]))
temp = computeLInfCoreset(Q_B, k-1)
if temp.size > 0:
C[indices_B[temp].astype(np.int)] = True
else:
C[B[i][:, -1].astype(np.int)] = True
temp = np.arange(B[i].shape[0]).astype(np.int)
list_of_coresets = [x for x in B if len(x) > 0]
Q = np.vstack(list_of_coresets)
indices_Q = Q[:, -1]
Q = np.hstack((Q[:, :-1], np.arange(Q.shape[0])[:, np.newaxis]))
if temp.size > 0:
for point in B[i][temp, :]:
indices = Level(Q, k-1, np.vstack((V, point[np.newaxis, :-1])))
if indices.size > 0:
D[indices_Q[indices].astype(np.int)] = True
# D.extend(Level(Q, k-1, np.vstack((V, point[np.newaxis, :-1]))))
return np.where(np.add(C, D))[0]
def computeLInfCoreset(P, k):
"""
This function is our main L_\infty coreset method, as for k = 1 it runs our fast algorithm for computing the
L_\infty coreset. When k > 1, it runs a recursive algorithm for computing a L_\infty coreset for the
(k,j)-projective clustering problem.
This algorithm is a variant of Algorithm 6 of "Coresets for Gaussian Mixture Models of Any shapes" by Zahi
Kfir and <NAME>.
:param P: A PointSet object, i.e., a weighted set of points.
:param k: The number of $j$-subspaces which defines the (k,j)-projective clustering problem.
:return: A PointSet object which contains a subset of P which serves as a L_\infty coreset for the
(k,j)-projective clustering problem.
"""
C = []
if k == 1: # if subspace clustering problem
_, idxs_in_Q, upper_bound = computeLINFCoresetKOne(P) # Compute our L_\infty coreset for P
return idxs_in_Q
elif k < 1: # should return None here
return np.array([])
else: # If k > 1
temp = computeLInfCoreset(P, k-1) # call recursively till k == 1
C = np.zeros((P.shape[0], ), dtype="bool")
C[P[temp, -1].astype(np.int)] = True
# Q = np.empty((P.shape[0] + Utils.J ** (2 * Utils.K), P.shape[1]))
# Q[:C_0.shape[0], :] = C_0
for p in P[temp, :]: # for each point in coreset
# print('K = {}'.format(k))
recursive_core = Level(P, k, p[np.newaxis, :-1]) # compute a coreset for (k,j)-projective clustering
# problem using a coreset for (k-1,j)-projective
# clustering problem
if recursive_core.size > 0: # if the coreset for the (k,j)-projective clustering problem is not empty
C[P[recursive_core, -1].astype(np.int)] = True
if np.where(C == False)[0].size < 1:
return np.where(C)[0]
return np.where(C)[0] # return a L_\infty coreset for (k,j)-projective clustering problem
def computeSensitivityPerCluster(P):
sensitivity = np.ones((P.shape[0], )) * np.inf
i = 0
upper_bound = Utils.determineUpperBound() # set upper bound on the approximation which the L_\infty
Q = np.hstack((P[:, :-1], np.arange(P.shape[0])[:, np.newaxis]))
# coreset attains
while Q.shape[0] > 2 * Q.shape[1]: # run till you have at most 2*j points
orig_idx_in_Q = Q[:, -1]
idxs_of_P = computeLInfCoreset(np.hstack((Q[:, :-1], np.arange(Q.shape[0])[:, np.newaxis])), Utils.K) # compute L_\infty coreset
# idxs_of_P = np.unique(Q_P[:, -1]).astype(np.int) # get all points in P which are also in Q_P
if np.any(np.logical_not(np.isinf(sensitivity[orig_idx_in_Q[idxs_of_P].astype(np.int)]))): # used for debugging
raise ValueError('A crucial Bug!')
sensitivity[orig_idx_in_Q[idxs_of_P].astype(np.int)] = upper_bound / (i + 1) # bound the sensitivity of each point in Q_P
if np.isnan(np.sum(sensitivity)):
print('HOLD ON!')
remaining_idxs = Utils.attainAllButSpecifiedIndices(Q, orig_idx_in_Q[idxs_of_P].astype(np.int)) # get all points in cluster which
# are not in Q_P
idxs_in_Q = np.where(remaining_idxs)[0] # get indices in cluster which are not in Q_P
Q = Q[idxs_in_Q, :] # update cluster to exclude current L_\infty coreset
print('Batch {} has finished'.format(i))
i += 1 # count number of L_\infty coreset per each cluster of points
remaining_idxs_per_cluster = Q[:, -1].astype(np.int) # all of the remaining 2*j points
sensitivity[remaining_idxs_per_cluster] = upper_bound / (i if i > 0 else i + 1) # give them the lowest
return np.hstack((sensitivity[:, np.newaxis], P[:, -1][:, np.newaxis]))
def computeSensitivity(P, W):
"""
The function at hand computes the sensitivity of each point using a reduction from L_\infty to L1.
:return: None
"""
P = np.hstack((P, np.arange(P.shape[0])[:, np.newaxis]))
B, idxs = applyBiCriterea(P[:, :-1], W) # attain set of flats which gives 2^j approximation to the optimal solution
sensitivity_additive_term = initializeSens(P, B, idxs) # initialize the sensitivities
unique_cetner_idxs = np.unique(idxs) # get unique indices of clusters
sensitivity = np.empty((P.shape[0], ))
clusters = [np.where(idxs == idx)[0] for idx in unique_cetner_idxs]
Qs = [[] for idx in range(len(clusters))]
for idx in range(len(clusters)): # apply L_\infty conversion to L_1 on each cluster of points
# Qs[idx] = np.hstack(((P[clusters[idx], :-1] - B[idx][1]).dot(B[idx][0].T.dot(B[idx][0])), P[clusters[idx], -1][:, np.newaxis]))
Qs[idx] = np.hstack(((P[clusters[idx], :-1] - B[idx][1]).dot(B[idx][0].T), P[clusters[idx], -1][:, np.newaxis]))
ts = time.time()
# s = computeSensitivityPerCluster(Qs[0])
# print('max = {}, min = {}'.format(np.max(s[0,:]), np.min(s[0,:])))
# print('Time for one cluster took {} secs'.format(time.time() - ts))
# input()
# pool = multiprocessing.Pool(3)
# list_of_sensitivities = pool.map(computeSensitivityPerCluster, Qs)
# print('Time for parallel took {} secs'.format(time.time() - ts))
for i in range(len(Qs)):
s = computeSensitivityPerCluster(Qs[i])
sensitivity[s[:, -1].astype(np.int)] = s[:, 0]
# print('Number of unique values = {}, max = {}, min = {}'.format(np.unique(sensitivity).shape[0],
# np.max(sensitivity), np.min(sensitivity)))
sensitivity += 2 ** Utils.J * sensitivity_additive_term # add the additive term for the sensitivity
return sensitivity
if __name__ == '__main__':
P = np.random.randn(10000, 5)
P = np.hstack((P, np.arange(10000)[:, np.newaxis]))
W = np.ones((P.shape[0], ))
s = computeSensitivity(P, W)
|
[
"numpy.linalg.matrix_rank",
"numpy.sqrt",
"numpy.hstack",
"numpy.log",
"Utils.UPPER_BOUND",
"Utils.computeDistanceToSubspace",
"numpy.array",
"numpy.count_nonzero",
"numpy.argsort",
"numpy.einsum",
"numpy.linalg.norm",
"numpy.arange",
"Utils.determineUpperBound",
"numpy.multiply",
"numpy.where",
"numpy.delete",
"numpy.dot",
"numpy.empty",
"numpy.vstack",
"numpy.min",
"numpy.argmin",
"numpy.meshgrid",
"numpy.abs",
"numpy.eye",
"numpy.ones",
"numpy.add",
"numpy.average",
"numpy.size",
"numpy.argmax",
"sklearn.decomposition.TruncatedSVD",
"Utils.computeAffineSpan",
"numpy.linalg.eigvals",
"numpy.linalg.svd",
"time.time",
"numpy.random.randn",
"numpy.unique",
"numpy.argpartition",
"scipy.linalg.null_space",
"numpy.logical_and",
"numpy.diag",
"numpy.sum",
"numpy.zeros",
"numpy.linalg.inv",
"numpy.expand_dims",
"numpy.linalg.cholesky",
"numpy.all"
] |
[((2252, 2269), 'numpy.hstack', 'np.hstack', (['(p, 1)'], {}), '((p, 1))\n', (2261, 2269), True, 'import numpy as np\n'), ((4103, 4112), 'numpy.linalg.svd', 'la.svd', (['B'], {}), '(B)\n', (4109, 4112), True, 'from numpy import linalg as la\n'), ((4953, 4971), 'numpy.eye', 'np.eye', (['A.shape[0]'], {}), '(A.shape[0])\n', (4959, 4971), True, 'import numpy as np\n'), ((5709, 5745), 'numpy.linalg.svd', 'np.linalg.svd', (['E'], {'full_matrices': '(True)'}), '(E, full_matrices=True)\n', (5722, 5745), True, 'import numpy as np\n'), ((6684, 6702), 'numpy.random.randn', 'np.random.randn', (['d'], {}), '(d)\n', (6699, 6702), True, 'import numpy as np\n'), ((9502, 9522), 'numpy.dot', 'np.dot', (['P.T', 'weights'], {}), '(P.T, weights)\n', (9508, 9522), True, 'import numpy as np\n'), ((19251, 19273), 'numpy.linalg.matrix_rank', 'matrix_rank', (['P[:, :-1]'], {}), '(P[:, :-1])\n', (19262, 19273), False, 'from numpy.linalg import matrix_rank\n'), ((19954, 19965), 'time.time', 'time.time', ([], {}), '()\n', (19963, 19965), False, 'import time\n'), ((22541, 22576), 'numpy.empty', 'np.empty', (['(P[indices, :].shape[0],)'], {}), '((P[indices, :].shape[0],))\n', (22549, 22576), True, 'import numpy as np\n'), ((23678, 23737), 'Utils.computeDistanceToSubspace', 'Utils.computeDistanceToSubspace', (['P[points_indices, :]', 'X', 'v'], {}), '(P[points_indices, :], X, v)\n', (23709, 23737), False, 'import Utils\n'), ((24578, 24616), 'numpy.average', 'np.average', (['P'], {'axis': '(0)', 'weights': 'weights'}), '(P, axis=0, weights=weights)\n', (24588, 24616), True, 'import numpy as np\n'), ((25220, 25232), 'numpy.arange', 'np.arange', (['n'], {}), '(n)\n', (25229, 25232), True, 'import numpy as np\n'), ((25276, 25287), 'numpy.array', 'np.array', (['B'], {}), '(B)\n', (25284, 25287), True, 'import numpy as np\n'), ((25798, 25822), 'numpy.argmin', 'np.argmin', (['dists'], {'axis': '(0)'}), '(dists, axis=0)\n', (25807, 25822), True, 'import numpy as np\n'), ((26257, 26278), 'numpy.meshgrid', 'np.meshgrid', (['*indices'], {}), '(*indices)\n', (26268, 26278), True, 'import numpy as np\n'), ((27335, 27353), 'numpy.arange', 'np.arange', (['(0)', 'n', '(1)'], {}), '(0, n, 1)\n', (27344, 27353), True, 'import numpy as np\n'), ((30064, 30079), 'numpy.unique', 'np.unique', (['idxs'], {}), '(idxs)\n', (30073, 30079), True, 'import numpy as np\n'), ((30148, 30171), 'numpy.zeros', 'np.zeros', (['(P.shape[0],)'], {}), '((P.shape[0],))\n', (30156, 30171), True, 'import numpy as np\n'), ((32579, 32616), 'numpy.zeros', 'np.zeros', (['(P.shape[0],)'], {'dtype': '"""bool"""'}), "((P.shape[0],), dtype='bool')\n", (32587, 32616), True, 'import numpy as np\n'), ((32627, 32664), 'numpy.zeros', 'np.zeros', (['(P.shape[0],)'], {'dtype': '"""bool"""'}), "((P.shape[0],), dtype='bool')\n", (32635, 32664), True, 'import numpy as np\n'), ((32771, 32797), 'Utils.computeAffineSpan', 'Utils.computeAffineSpan', (['V'], {}), '(V)\n', (32794, 32797), False, 'import Utils\n'), ((32879, 32929), 'Utils.computeDistanceToSubspace', 'Utils.computeDistanceToSubspace', (['P[:, :-1]', 'A.T', 'v'], {}), '(P[:, :-1], A.T, v)\n', (32910, 32929), False, 'import Utils\n'), ((37502, 37529), 'Utils.determineUpperBound', 'Utils.determineUpperBound', ([], {}), '()\n', (37527, 37529), False, 'import Utils\n'), ((39108, 39172), 'numpy.hstack', 'np.hstack', (['(sensitivity[:, np.newaxis], P[:, -1][:, np.newaxis])'], {}), '((sensitivity[:, np.newaxis], P[:, -1][:, np.newaxis]))\n', (39117, 39172), True, 'import numpy as np\n'), ((39655, 39670), 'numpy.unique', 'np.unique', (['idxs'], {}), '(idxs)\n', (39664, 39670), True, 'import numpy as np\n'), ((39724, 39747), 'numpy.empty', 'np.empty', (['(P.shape[0],)'], {}), '((P.shape[0],))\n', (39732, 39747), True, 'import numpy as np\n'), ((40248, 40259), 'time.time', 'time.time', ([], {}), '()\n', (40257, 40259), False, 'import time\n'), ((41191, 41216), 'numpy.random.randn', 'np.random.randn', (['(10000)', '(5)'], {}), '(10000, 5)\n', (41206, 41216), True, 'import numpy as np\n'), ((41283, 41305), 'numpy.ones', 'np.ones', (['(P.shape[0],)'], {}), '((P.shape[0],))\n', (41290, 41305), True, 'import numpy as np\n'), ((2289, 2302), 'numpy.ones', 'np.ones', (['(N,)'], {}), '((N,))\n', (2296, 2302), True, 'import numpy as np\n'), ((3081, 3100), 'numpy.count_nonzero', 'np.count_nonzero', (['u'], {}), '(u)\n', (3097, 3100), True, 'import numpy as np\n'), ((3321, 3337), 'numpy.where', 'np.where', (['(u != 0)'], {}), '(u != 0)\n', (3329, 3337), True, 'import numpy as np\n'), ((3574, 3588), 'numpy.linalg.cholesky', 'la.cholesky', (['B'], {}), '(B)\n', (3585, 3588), True, 'from numpy import linalg as la\n'), ((4278, 4288), 'numpy.linalg.norm', 'la.norm', (['A'], {}), '(A)\n', (4285, 4288), True, 'from numpy import linalg as la\n'), ((6744, 6772), 'numpy.linalg.matrix_rank', 'np.linalg.matrix_rank', (['basis'], {}), '(basis)\n', (6765, 6772), True, 'import numpy as np\n'), ((7388, 7402), 'numpy.dot', 'np.dot', (['P', 'v.T'], {}), '(P, v.T)\n', (7394, 7402), True, 'import numpy as np\n'), ((7841, 7888), 'numpy.expand_dims', 'np.expand_dims', (['(P[p_beta, :] - P[p_alpha, :])', '(1)'], {}), '(P[p_beta, :] - P[p_alpha, :], 1)\n', (7855, 7888), True, 'import numpy as np\n'), ((8954, 8970), 'numpy.dot', 'np.dot', (['Q', 'ellip'], {}), '(Q, ellip)\n', (8960, 8970), True, 'import numpy as np\n'), ((9464, 9490), 'numpy.expand_dims', 'np.expand_dims', (['weights', '(1)'], {}), '(weights, 1)\n', (9478, 9490), True, 'import numpy as np\n'), ((11165, 11188), 'numpy.where', 'np.where', (['(weights > 0.0)'], {}), '(weights > 0.0)\n', (11173, 11188), True, 'import numpy as np\n'), ((11598, 11645), 'numpy.einsum', 'np.einsum', (['"""bi,bo->bio"""', 'weighted_Q', 'weighted_Q'], {}), "('bi,bo->bio', weighted_Q, weighted_Q)\n", (11607, 11645), True, 'import numpy as np\n'), ((12229, 12250), 'numpy.where', 'np.where', (['(weights > 0)'], {}), '(weights > 0)\n', (12237, 12250), True, 'import numpy as np\n'), ((14638, 14658), 'numpy.argmax', 'np.argmax', (['distances'], {}), '(distances)\n', (14647, 14658), True, 'import numpy as np\n'), ((16710, 16725), 'numpy.ones', 'np.ones', (['(n, 1)'], {}), '((n, 1))\n', (16717, 16725), True, 'import numpy as np\n'), ((17184, 17196), 'numpy.argmax', 'np.argmax', (['M'], {}), '(M)\n', (17193, 17196), True, 'import numpy as np\n'), ((17563, 17588), 'numpy.linalg.norm', 'np.linalg.norm', (['(new_u - u)'], {}), '(new_u - u)\n', (17577, 17588), True, 'import numpy as np\n'), ((19427, 19455), 'sklearn.decomposition.TruncatedSVD', 'TruncatedSVD', ([], {'n_components': 'r'}), '(n_components=r)\n', (19439, 19455), False, 'from sklearn.decomposition import TruncatedSVD\n'), ((21912, 21930), 'numpy.unique', 'np.unique', (['C[:idx]'], {}), '(C[:idx])\n', (21921, 21930), True, 'import numpy as np\n'), ((21932, 21957), 'numpy.unique', 'np.unique', (['idx_in_P[:idx]'], {}), '(idx_in_P[:idx])\n', (21941, 21957), True, 'import numpy as np\n'), ((21959, 21979), 'Utils.UPPER_BOUND', 'Utils.UPPER_BOUND', (['r'], {}), '(r)\n', (21976, 21979), False, 'import Utils\n'), ((22885, 22951), 'Utils.computeDistanceToSubspace', 'Utils.computeDistanceToSubspace', (['P[indices, :]', 'flats[0]', 'flats[1]'], {}), '(P[indices, :], flats[0], flats[1])\n', (22916, 22951), False, 'import Utils\n'), ((26192, 26216), 'numpy.arange', 'np.arange', (['S[i].shape[0]'], {}), '(S[i].shape[0])\n', (26201, 26216), True, 'import numpy as np\n'), ((27728, 27738), 'numpy.size', 'np.size', (['Q'], {}), '(Q)\n', (27735, 27738), True, 'import numpy as np\n'), ((28344, 28372), 'numpy.delete', 'np.delete', (['Q', 'sorted_indices'], {}), '(Q, sorted_indices)\n', (28353, 28372), True, 'import numpy as np\n'), ((30479, 30579), 'Utils.computeDistanceToSubspace', 'Utils.computeDistanceToSubspace', (['P[cluster_per_center, :-1]', 'B[center_idx][0]', 'B[center_idx][1]'], {}), '(P[cluster_per_center, :-1], B[center_idx][0\n ], B[center_idx][1])\n', (30510, 30579), False, 'import Utils\n'), ((32718, 32730), 'numpy.array', 'np.array', (['[]'], {}), '([])\n', (32726, 32730), True, 'import numpy as np\n'), ((32951, 32986), 'numpy.where', 'np.where', (['(dists_from_P_to_A > 1e-11)'], {}), '(dists_from_P_to_A > 1e-11)\n', (32959, 32986), True, 'import numpy as np\n'), ((33036, 33076), 'numpy.min', 'np.min', (['dists_from_P_to_A[non_zero_idxs]'], {}), '(dists_from_P_to_A[non_zero_idxs])\n', (33042, 33076), True, 'import numpy as np\n'), ((33127, 33144), 'numpy.abs', 'np.abs', (['P[:, :-1]'], {}), '(P[:, :-1])\n', (33133, 33144), True, 'import numpy as np\n'), ((33167, 33203), 'numpy.where', 'np.where', (['(dists_from_P_to_A <= 1e-11)'], {}), '(dists_from_P_to_A <= 1e-11)\n', (33175, 33203), True, 'import numpy as np\n'), ((37439, 37461), 'numpy.ones', 'np.ones', (['(P.shape[0],)'], {}), '((P.shape[0],))\n', (37446, 37461), True, 'import numpy as np\n'), ((2225, 2240), 'numpy.ones', 'np.ones', (['(1, N)'], {}), '((1, N))\n', (2232, 2240), True, 'import numpy as np\n'), ((4143, 4153), 'numpy.diag', 'np.diag', (['s'], {}), '(s)\n', (4150, 4153), True, 'import numpy as np\n'), ((5785, 5810), 'numpy.sqrt', 'np.sqrt', (['D[:, np.newaxis]'], {}), '(D[:, np.newaxis])\n', (5792, 5810), True, 'import numpy as np\n'), ((7213, 7232), 'scipy.linalg.null_space', 'null_space', (['basis.T'], {}), '(basis.T)\n', (7223, 7232), False, 'from scipy.linalg import null_space\n'), ((7639, 7653), 'numpy.dot', 'np.dot', (['P', 'v.T'], {}), '(P, v.T)\n', (7645, 7653), True, 'import numpy as np\n'), ((7749, 7763), 'numpy.dot', 'np.dot', (['P', 'v.T'], {}), '(P, v.T)\n', (7755, 7763), True, 'import numpy as np\n'), ((11300, 11322), 'numpy.sqrt', 'np.sqrt', (['weights[idxs]'], {}), '(weights[idxs])\n', (11307, 11322), True, 'import numpy as np\n'), ((12697, 12749), 'numpy.all', 'np.all', (['(current_dists <= (1.0 + Utils.TOL) * (d + 1))'], {}), '(current_dists <= (1.0 + Utils.TOL) * (d + 1))\n', (12703, 12749), True, 'import numpy as np\n'), ((12765, 12835), 'numpy.all', 'np.all', (['(current_dists[pos_weights_idxs] >= (1.0 - Utils.TOL) * (d + 1))'], {}), '(current_dists[pos_weights_idxs] >= (1.0 - Utils.TOL) * (d + 1))\n', (12771, 12835), True, 'import numpy as np\n'), ((13246, 13261), 'numpy.ones', 'np.ones', (['(n, 1)'], {}), '((n, 1))\n', (13253, 13261), True, 'import numpy as np\n'), ((13673, 13689), 'numpy.zeros', 'np.zeros', (['(n, 1)'], {}), '((n, 1))\n', (13681, 13689), True, 'import numpy as np\n'), ((14475, 14496), 'numpy.where', 'np.where', (['(weights > 0)'], {}), '(weights > 0)\n', (14483, 14496), True, 'import numpy as np\n'), ((14817, 14854), 'numpy.argmin', 'np.argmin', (['distances[pos_weights_idx]'], {}), '(distances[pos_weights_idx])\n', (14826, 14854), True, 'import numpy as np\n'), ((16788, 16803), 'numpy.ones', 'np.ones', (['(n, 1)'], {}), '((n, 1))\n', (16795, 16803), True, 'import numpy as np\n'), ((17011, 17027), 'numpy.linalg.inv', 'np.linalg.inv', (['X'], {}), '(X)\n', (17024, 17027), True, 'import numpy as np\n'), ((20605, 20625), 'Utils.UPPER_BOUND', 'Utils.UPPER_BOUND', (['r'], {}), '(r)\n', (20622, 20625), False, 'import Utils\n'), ((21231, 21266), 'numpy.empty', 'np.empty', (['(2 * (Utils.J + 1) ** 2,)'], {}), '((2 * (Utils.J + 1) ** 2,))\n', (21239, 21266), True, 'import numpy as np\n'), ((21290, 21325), 'numpy.empty', 'np.empty', (['(2 * (Utils.J + 1) ** 2,)'], {}), '((2 * (Utils.J + 1) ** 2,))\n', (21298, 21325), True, 'import numpy as np\n'), ((22968, 22998), 'numpy.argpartition', 'np.argpartition', (['dists', '(N // 2)'], {}), '(dists, N // 2)\n', (22983, 22998), True, 'import numpy as np\n'), ((24671, 24739), 'sklearn.decomposition.TruncatedSVD', 'TruncatedSVD', ([], {'algorithm': '"""randomized"""', 'n_iter': '(1)', 'n_components': 'Utils.J'}), "(algorithm='randomized', n_iter=1, n_components=Utils.J)\n", (24683, 24739), False, 'from sklearn.decomposition import TruncatedSVD\n'), ((25363, 25418), 'Utils.computeDistanceToSubspace', 'Utils.computeDistanceToSubspace', (['P[idxs, :]', 'x[0]', 'x[1]'], {}), '(P[idxs, :], x[0], x[1])\n', (25394, 25418), False, 'import Utils\n'), ((30290, 30318), 'numpy.where', 'np.where', (['(idxs == center_idx)'], {}), '(idxs == center_idx)\n', (30298, 30318), True, 'import numpy as np\n'), ((35233, 35245), 'numpy.add', 'np.add', (['C', 'D'], {}), '(C, D)\n', (35239, 35245), True, 'import numpy as np\n'), ((36271, 36283), 'numpy.array', 'np.array', (['[]'], {}), '([])\n', (36279, 36283), True, 'import numpy as np\n'), ((36395, 36432), 'numpy.zeros', 'np.zeros', (['(P.shape[0],)'], {'dtype': '"""bool"""'}), "((P.shape[0],), dtype='bool')\n", (36403, 36432), True, 'import numpy as np\n'), ((38365, 38384), 'numpy.sum', 'np.sum', (['sensitivity'], {}), '(sensitivity)\n', (38371, 38384), True, 'import numpy as np\n'), ((38605, 38629), 'numpy.where', 'np.where', (['remaining_idxs'], {}), '(remaining_idxs)\n', (38613, 38629), True, 'import numpy as np\n'), ((39768, 39789), 'numpy.where', 'np.where', (['(idxs == idx)'], {}), '(idxs == idx)\n', (39776, 39789), True, 'import numpy as np\n'), ((2452, 2466), 'numpy.dot', 'np.dot', (['P.T', 'w'], {}), '(P.T, w)\n', (2458, 2466), True, 'import numpy as np\n'), ((3292, 3306), 'numpy.dot', 'np.dot', (['P.T', 'u'], {}), '(P.T, u)\n', (3298, 3306), True, 'import numpy as np\n'), ((5041, 5055), 'numpy.linalg.eigvals', 'la.eigvals', (['A3'], {}), '(A3)\n', (5051, 5055), True, 'from numpy import linalg as la\n'), ((7099, 7147), 'numpy.linalg.svd', 'np.linalg.svd', (['basis[:, :-1]'], {'full_matrices': '(True)'}), '(basis[:, :-1], full_matrices=True)\n', (7112, 7147), True, 'import numpy as np\n'), ((8241, 8258), 'numpy.linalg.norm', 'np.linalg.norm', (['v'], {}), '(v)\n', (8255, 8258), True, 'import numpy as np\n'), ((16923, 16940), 'numpy.multiply', 'np.multiply', (['Q', 'u'], {}), '(Q, u)\n', (16934, 16940), True, 'import numpy as np\n'), ((19693, 19720), 'numpy.expand_dims', 'np.expand_dims', (['P[:, -1]', '(1)'], {}), '(P[:, -1], 1)\n', (19707, 19720), True, 'import numpy as np\n'), ((20179, 20199), 'Utils.UPPER_BOUND', 'Utils.UPPER_BOUND', (['r'], {}), '(r)\n', (20196, 20199), False, 'import Utils\n'), ((23050, 23067), 'numpy.array', 'np.array', (['indices'], {}), '(indices)\n', (23058, 23067), True, 'import numpy as np\n'), ((24002, 24026), 'numpy.array', 'np.array', (['points_indices'], {}), '(points_indices)\n', (24010, 24026), True, 'import numpy as np\n'), ((34679, 34706), 'numpy.vstack', 'np.vstack', (['list_of_coresets'], {}), '(list_of_coresets)\n', (34688, 34706), True, 'import numpy as np\n'), ((37292, 37303), 'numpy.where', 'np.where', (['C'], {}), '(C)\n', (37300, 37303), True, 'import numpy as np\n'), ((37620, 37641), 'numpy.arange', 'np.arange', (['P.shape[0]'], {}), '(P.shape[0])\n', (37629, 37641), True, 'import numpy as np\n'), ((39376, 39397), 'numpy.arange', 'np.arange', (['P.shape[0]'], {}), '(P.shape[0])\n', (39385, 39397), True, 'import numpy as np\n'), ((41240, 41256), 'numpy.arange', 'np.arange', (['(10000)'], {}), '(10000)\n', (41249, 41256), True, 'import numpy as np\n'), ((2408, 2422), 'numpy.dot', 'np.dot', (['P.T', 'w'], {}), '(P.T, w)\n', (2414, 2422), True, 'import numpy as np\n'), ((3248, 3262), 'numpy.dot', 'np.dot', (['P.T', 'u'], {}), '(P.T, u)\n', (3254, 3262), True, 'import numpy as np\n'), ((31462, 31495), 'numpy.sum', 'np.sum', (['cost_per_point_in_cluster'], {}), '(cost_per_point_in_cluster)\n', (31468, 31495), True, 'import numpy as np\n'), ((8339, 8359), 'numpy.linalg.norm', 'np.linalg.norm', (['v', '(2)'], {}), '(v, 2)\n', (8353, 8359), True, 'import numpy as np\n'), ((9888, 9912), 'numpy.multiply', 'np.multiply', (['Q', 'weights2'], {}), '(Q, weights2)\n', (9899, 9912), True, 'import numpy as np\n'), ((20141, 20162), 'numpy.arange', 'np.arange', (['Q.shape[0]'], {}), '(Q.shape[0])\n', (20150, 20162), True, 'import numpy as np\n'), ((24027, 24044), 'numpy.argsort', 'np.argsort', (['dists'], {}), '(dists)\n', (24037, 24044), True, 'import numpy as np\n'), ((28157, 28169), 'numpy.vstack', 'np.vstack', (['S'], {}), '(S)\n', (28166, 28169), True, 'import numpy as np\n'), ((33424, 33448), 'numpy.arange', 'np.arange', (['B[0].shape[0]'], {}), '(B[0].shape[0])\n', (33433, 33448), True, 'import numpy as np\n'), ((37261, 37272), 'numpy.where', 'np.where', (['C'], {}), '(C)\n', (37269, 37272), True, 'import numpy as np\n'), ((37858, 37879), 'numpy.arange', 'np.arange', (['Q.shape[0]'], {}), '(Q.shape[0])\n', (37867, 37879), True, 'import numpy as np\n'), ((23068, 23085), 'numpy.argsort', 'np.argsort', (['dists'], {}), '(dists)\n', (23078, 23085), True, 'import numpy as np\n'), ((27593, 27608), 'numpy.log', 'np.log', (['Utils.K'], {}), '(Utils.K)\n', (27599, 27608), True, 'import numpy as np\n'), ((33856, 33871), 'numpy.log', 'np.log', (['(1.0 / c)'], {}), '(1.0 / c)\n', (33862, 33871), True, 'import numpy as np\n'), ((34553, 34577), 'numpy.arange', 'np.arange', (['B[i].shape[0]'], {}), '(B[i].shape[0])\n', (34562, 34577), True, 'import numpy as np\n'), ((34788, 34809), 'numpy.arange', 'np.arange', (['Q.shape[0]'], {}), '(Q.shape[0])\n', (34797, 34809), True, 'import numpy as np\n'), ((34960, 34998), 'numpy.vstack', 'np.vstack', (['(V, point[np.newaxis, :-1])'], {}), '((V, point[np.newaxis, :-1]))\n', (34969, 34998), True, 'import numpy as np\n'), ((37203, 37223), 'numpy.where', 'np.where', (['(C == False)'], {}), '(C == False)\n', (37211, 37223), True, 'import numpy as np\n'), ((20446, 20466), 'numpy.argmin', 'np.argmin', (['Q[:, :-1]'], {}), '(Q[:, :-1])\n', (20455, 20466), True, 'import numpy as np\n'), ((20519, 20539), 'numpy.argmax', 'np.argmax', (['Q[:, :-1]'], {}), '(Q[:, :-1])\n', (20528, 20539), True, 'import numpy as np\n'), ((22757, 22779), 'numpy.array', 'np.array', (['[indices[i]]'], {}), '([indices[i]])\n', (22765, 22779), True, 'import numpy as np\n'), ((27497, 27516), 'numpy.log', 'np.log', (['(Utils.J + 1)'], {}), '(Utils.J + 1)\n', (27503, 27516), True, 'import numpy as np\n'), ((27699, 27708), 'numpy.log', 'np.log', (['n'], {}), '(n)\n', (27705, 27708), True, 'import numpy as np\n'), ((33844, 33853), 'numpy.log', 'np.log', (['M'], {}), '(M)\n', (33850, 33853), True, 'import numpy as np\n'), ((33911, 34005), 'numpy.logical_and', 'np.logical_and', (['(2 ** (i - 1) * d_0 <= dists_from_P_to_A)', '(dists_from_P_to_A <= 2 ** i * d_0)'], {}), '(2 ** (i - 1) * d_0 <= dists_from_P_to_A, dists_from_P_to_A <=\n 2 ** i * d_0)\n', (33925, 34005), True, 'import numpy as np\n'), ((34240, 34264), 'numpy.arange', 'np.arange', (['B[i].shape[0]'], {}), '(B[i].shape[0])\n', (34249, 34264), True, 'import numpy as np\n')]
|
import logic
import numpy as np
import gym
ACTION_MAP = {
0: 'up',
1: 'down',
2: 'left',
3: 'right'
}
class Env2048(gym.Env):
metadata = {'render.modes': ['human']}
def __init__(self, n=4, max_idle=100, seed=None):
super(Env2048, self).__init__()
self.n = n
self.max_idle = max_idle
self.action_map = ACTION_MAP
# up, down, left, right
self.action_space = gym.spaces.Discrete(4)
self.observation_space = gym.spaces.Box(
low=0, high=255,
shape=(self.n, self.n, 2 ** n), dtype=np.uint8)
self.eye = np.eye(2 ** n)
self.reward_range = (float('-inf'), float('inf'))
if seed is not None:
self.seed(seed)
def seed(self, seed):
np.random.seed(seed)
def reset(self):
self.matrix = logic.new_game(self.n)
self.reward_i = self.i = 0
self.total_reward = 0
return self.obs
@property
def obs(self):
m = np.array(self.matrix)
m = np.clip(m, 1, float('inf')) # from 0, 2, 4, 8, ... to 1, 2, 4, 8
m = np.log2(m).astype(np.int64) # from 1, 2, 4, 8,..., 2048 to 0, 1, 2, 3, ..., 11
m = self.eye[m]
m = m * 255
m = m.astype(np.uint8)
obs = m
return obs
def step(self, action):
if isinstance(action, str) and action in ('up', 'down', 'left', 'right'):
pass
if isinstance(action, (int, np.int64, np.int32)):
action = self.action_map[int(action)]
else:
print(action, type(action))
raise
old_score = np.sort(np.array(self.matrix).flatten())[::-1]
old_matrix = str(self.matrix)
# import pdb; pdb.set_trace()
if action == 'up':
self.matrix, updated = logic.up(self.matrix)
elif action == 'down':
self.matrix, updated = logic.down(self.matrix)
elif action == 'left':
self.matrix, updated = logic.left(self.matrix)
elif action == 'right':
self.matrix, updated = logic.right(self.matrix)
new_matrix = str(self.matrix)
new_score = np.sort(np.array(self.matrix).flatten())[::-1]
reward = np.sum((new_score - old_score) * (new_score >= old_score)) * 4
reward = float(reward)
self.total_reward += reward
self.i += 1
if updated: # matrix有更新
self.matrix = logic.add_two(self.matrix)
if logic.game_state(self.matrix) == 'win':
print('you win')
return self.obs, 10000.0, True, {'i': self.i, 'ri': self.reward_i, 'tr': self.total_reward}
elif logic.game_state(self.matrix) == 'lose':
return self.obs, 100.0, True, {'i': self.i, 'ri': self.reward_i, 'tr': self.total_reward}
idle = False
if old_matrix == new_matrix:
idle = True
if idle:
reward = -1
else:
self.reward_i = self.i
if self.i - self.reward_i > self.max_idle:
return self.obs, -100, True, {'i': self.i, 'ri': self.reward_i, 'tr': self.total_reward}
return self.obs, reward, False, {'i': self.i, 'ri': self.reward_i, 'tr': self.total_reward}
def render(self, mode='human'):
pass
def close(self):
pass
def main():
env = Env2048()
obs = env.reset()
print(obs)
for _ in range(1000):
obs, reward, done, info = env.step(np.random.choice(['right', 'left', 'up', 'down']))
print(obs)
print(reward, done, info)
if done:
break
if __name__ == '__main__':
main()
|
[
"numpy.eye",
"logic.left",
"numpy.random.choice",
"logic.game_state",
"gym.spaces.Discrete",
"gym.spaces.Box",
"logic.new_game",
"numpy.array",
"numpy.sum",
"logic.right",
"numpy.random.seed",
"logic.add_two",
"logic.up",
"numpy.log2",
"logic.down"
] |
[((434, 456), 'gym.spaces.Discrete', 'gym.spaces.Discrete', (['(4)'], {}), '(4)\n', (453, 456), False, 'import gym\n'), ((490, 569), 'gym.spaces.Box', 'gym.spaces.Box', ([], {'low': '(0)', 'high': '(255)', 'shape': '(self.n, self.n, 2 ** n)', 'dtype': 'np.uint8'}), '(low=0, high=255, shape=(self.n, self.n, 2 ** n), dtype=np.uint8)\n', (504, 569), False, 'import gym\n'), ((614, 628), 'numpy.eye', 'np.eye', (['(2 ** n)'], {}), '(2 ** n)\n', (620, 628), True, 'import numpy as np\n'), ((779, 799), 'numpy.random.seed', 'np.random.seed', (['seed'], {}), '(seed)\n', (793, 799), True, 'import numpy as np\n'), ((844, 866), 'logic.new_game', 'logic.new_game', (['self.n'], {}), '(self.n)\n', (858, 866), False, 'import logic\n'), ((1002, 1023), 'numpy.array', 'np.array', (['self.matrix'], {}), '(self.matrix)\n', (1010, 1023), True, 'import numpy as np\n'), ((1823, 1844), 'logic.up', 'logic.up', (['self.matrix'], {}), '(self.matrix)\n', (1831, 1844), False, 'import logic\n'), ((2240, 2298), 'numpy.sum', 'np.sum', (['((new_score - old_score) * (new_score >= old_score))'], {}), '((new_score - old_score) * (new_score >= old_score))\n', (2246, 2298), True, 'import numpy as np\n'), ((2450, 2476), 'logic.add_two', 'logic.add_two', (['self.matrix'], {}), '(self.matrix)\n', (2463, 2476), False, 'import logic\n'), ((3495, 3544), 'numpy.random.choice', 'np.random.choice', (["['right', 'left', 'up', 'down']"], {}), "(['right', 'left', 'up', 'down'])\n", (3511, 3544), True, 'import numpy as np\n'), ((1114, 1124), 'numpy.log2', 'np.log2', (['m'], {}), '(m)\n', (1121, 1124), True, 'import numpy as np\n'), ((1911, 1934), 'logic.down', 'logic.down', (['self.matrix'], {}), '(self.matrix)\n', (1921, 1934), False, 'import logic\n'), ((2493, 2522), 'logic.game_state', 'logic.game_state', (['self.matrix'], {}), '(self.matrix)\n', (2509, 2522), False, 'import logic\n'), ((2001, 2024), 'logic.left', 'logic.left', (['self.matrix'], {}), '(self.matrix)\n', (2011, 2024), False, 'import logic\n'), ((2691, 2720), 'logic.game_state', 'logic.game_state', (['self.matrix'], {}), '(self.matrix)\n', (2707, 2720), False, 'import logic\n'), ((1646, 1667), 'numpy.array', 'np.array', (['self.matrix'], {}), '(self.matrix)\n', (1654, 1667), True, 'import numpy as np\n'), ((2092, 2116), 'logic.right', 'logic.right', (['self.matrix'], {}), '(self.matrix)\n', (2103, 2116), False, 'import logic\n'), ((2184, 2205), 'numpy.array', 'np.array', (['self.matrix'], {}), '(self.matrix)\n', (2192, 2205), True, 'import numpy as np\n')]
|
# -*- coding: utf-8 -*-
"""
Created on Tue Nov 13 12:55:47 2018
@name: CSVMachLearn.py
@description: 1D CNN using CSV vector for machine learning
@author: <NAME>
"""
from __future__ import absolute_import, division, print_function
import matplotlib.pyplot as plt
from matplotlib.lines import Line2D
from sklearn.decomposition import PCA
import numpy as np
import tensorflow as tf
import tensorflow.contrib.eager as tfe
from tensorflow import set_random_seed
tf.enable_eager_execution()
set_random_seed(0)
nrds='S0'
#==============================================================================
# Global parameters
#==============================================================================
total_dataset_fp="D:\\AI_experiments\\CSV\\"+nrds+"\\DAT"+nrds+".csv"
pathlog="D:\\AI_experiments\\CSV\\"+nrds+"\\"+nrds+"pub.log"
pathimg="D:\\AI_experiments\\CSV\\"+nrds+"\\IMG"
num_epochs = 1001 # number of epochs
lrate=2e-5 # learning rate
test_procent=0.2 # procentage of test_dataset
learn_batch_size=32 # batch size
print("Local copy of the dataset file: {}".format(total_dataset_fp))
print("TensorFlow version: {}".format(tf.VERSION))
print("Eager execution: {}".format(tf.executing_eagerly()))
#==============================================================================
# Methods
#==============================================================================
def ChangeBatchSize(dataset,bsize):
dataset=dataset.apply(tf.data.experimental.unbatch())
dataset=dataset.batch(batch_size=bsize)
return dataset
def pack_features_vector(features, labels):
"""Pack the features into a single array."""
features = tf.stack(list(features.values()), axis=1)
return features, labels
with open(total_dataset_fp) as f:
content = f.readlines()
grup=content[0].split(',')
print(grup[1])
f_size=int(grup[1])-1 #number of points in data vector
print("Vector size: "+str(f_size))
filtr1=32
filtr_size1=5
filtr2=32
filtr_size2=5
filtr3=64
filtr_size3=5
filtr4=64
filtr_size4=4
DenseLast=4096
filtr5=512
filtr_size5=5
def create_model():
model = tf.keras.models.Sequential([
tf.keras.layers.Reshape((f_size,1), input_shape=(None,f_size),name='x'),
tf.keras.layers.Conv1D(filters=filtr1,kernel_size=filtr_size1,strides=1, kernel_initializer='random_uniform',activation=tf.nn.relu,padding='same',name='Conv1'),
tf.keras.layers.MaxPooling1D(pool_size=filtr_size1, strides=2, padding='same', name='pool1'),
tf.keras.layers.Conv1D(filters=filtr2,kernel_size=filtr_size2,strides=1, padding='same',name='Conv2',activation=tf.nn.relu, kernel_initializer='random_uniform'),
tf.keras.layers.MaxPooling1D(pool_size=filtr_size2, strides=2, padding='same', name='pool2'),
tf.keras.layers.Conv1D(filters=filtr3,kernel_size=filtr_size3,strides=1, padding='same',name='Conv3',activation=tf.nn.relu, kernel_initializer='random_uniform'),
tf.keras.layers.MaxPooling1D(pool_size=filtr_size3, strides=2, padding='same', name='pool3'),
tf.keras.layers.Conv1D(filters=filtr4,kernel_size=filtr_size4,strides=1, padding='same',name='Conv4',activation=tf.nn.relu, kernel_initializer='random_uniform'),
tf.keras.layers.MaxPooling1D(pool_size=filtr_size4, strides=2, padding='same', name='pool4'),
tf.keras.layers.GlobalMaxPool1D(), #size of last filter
tf.keras.layers.Dense(DenseLast, activation=tf.nn.relu,name='fir'), # input shape required
tf.keras.layers.Dense(256, activation=tf.nn.relu,name='mod_up'),
tf.keras.layers.Dense(3,name='y_pred'), #output layer
])
model.compile(optimizer=tf.train.AdamOptimizer(),
loss=tf.keras.losses.sparse_categorical_crossentropy,
metrics=['accuracy'])
return model
def loss(model, x, y):
y_ = model(x)
#print(y)
#print(y_)
return tf.losses.sparse_softmax_cross_entropy(labels=y, logits=y_)
def grad(model, inputs, targets):
with tf.GradientTape() as tape:
loss_value = loss(model, inputs, targets)
#print(loss_value)
return loss_value, tape.gradient(loss_value, model.trainable_variables)
mapcolor=['red','green','blue']
# column order in CSV file
column_names = []
for a in range(0,f_size):
column_names.append(str(a))
column_names.append('signal')
print(len(column_names))
feature_names = column_names[:-1]
label_name = column_names[-1]
#class_names = ['Left','Right','NONE']
class_names = ['LIP','JAW','NONE']
batch_size = 200000
#train_dataset = tf.data.experimental.make_csv_dataset(
# total_dataset_fp,
# batch_size,
# column_names=column_names,
# label_name=label_name,
# num_epochs=1,
# shuffle=False)
#train_dataset = train_dataset.map(pack_features_vector)
total_dataset = tf.data.experimental.make_csv_dataset(
total_dataset_fp,
batch_size,
column_names=column_names,
label_name=label_name,
num_epochs=1,
shuffle=True)
features, labels = next(iter(total_dataset))
setsize=float(str(labels.shape[0]))
ts_size=setsize*test_procent
tr_size=setsize-ts_size
print("Total_CSV_size: "+str(setsize) )
print("Train_size: "+str(tr_size) )
print("Test_size: "+str(ts_size) )
total_dataset = total_dataset.map(pack_features_vector)
total_dataset=ChangeBatchSize(total_dataset,tr_size)
#==============================================================================
#Split dataset into train_dataset and test_dataset.
#==============================================================================
i=0
for (parts, labels) in total_dataset:
if(i==0):
k1 = parts
l1 = labels
else:
k2 = parts
l2 = labels
i=i+1
train_dataset = tf.data.Dataset.from_tensors((k1, l1))
train_dataset = ChangeBatchSize(train_dataset,learn_batch_size)
test_dataset = tf.data.Dataset.from_tensors((k2, l2))
test_dataset = ChangeBatchSize(test_dataset,ts_size)
#==============================================================================
# Create model object
#==============================================================================
model=create_model()
model.summary()
optimizer = tf.train.AdamOptimizer(learning_rate=lrate)
global_step = tf.train.get_or_create_global_step()
legend_elements = [Line2D([0], [0], marker='o', color='w', label=class_names[0],markerfacecolor='r', markersize=10),
Line2D([0], [0], marker='o', color='w', label=class_names[1],markerfacecolor='g', markersize=10),
Line2D([0], [0], marker='o', color='w', label=class_names[2],markerfacecolor='b', markersize=10)]
# keep results for plotting
train_loss_results = []
train_accuracy_results = []
np.set_printoptions(threshold=np.nan)
#==============================================================================
# Make machine learning process
#==============================================================================
old_loss=1000
for epoch in range(num_epochs):
epoch_loss_avg = tfe.metrics.Mean()
epoch_accuracy = tfe.metrics.Accuracy()
# Training loop - using batches of 32
for x, y in train_dataset:
# Optimize the model
#print(str(type(x)))
#print(str(x.shape))
loss_value, grads = grad(model, x, y)
optimizer.apply_gradients(zip(grads, model.variables),
global_step)
# Track progress
epoch_loss_avg(loss_value) # add current batch loss
# compare predicted label to actual label
epoch_accuracy(tf.argmax(model(x), axis=1, output_type=tf.int32), y)
# end epoch
train_loss_results.append(epoch_loss_avg.result())
train_accuracy_results.append(epoch_accuracy.result())
if epoch % 5 == 0:
test_accuracy = tfe.metrics.Accuracy()
for (x, y) in test_dataset:
logits = model(x)
prediction = tf.argmax(logits, axis=1, output_type=tf.int32)
test_accuracy(prediction, y)
X=logits.numpy()
Y=y.numpy()
PCA(copy=True, iterated_power='auto', n_components=2, random_state=None, svd_solver='auto', tol=0.0, whiten=False)
X = PCA(n_components=2).fit_transform(X)
arrcolor = []
for cl in Y:
arrcolor.append(mapcolor[cl])
plt.scatter(X[:, 0], X[:, 1], s=40, c=arrcolor)
#plt.show()
imgfile="{:s}\\epoch{:03d}.png".format(pathimg,epoch)
plt.title("{:.3%}".format(test_accuracy.result()))
plt.legend(handles=legend_elements, loc='upper right')
plt.savefig(imgfile)
plt.close()
new_loss=epoch_loss_avg.result()
accur=epoch_accuracy.result()
test_acc=test_accuracy.result()
msg="Epoch {:03d}: Loss: {:.6f}, Accuracy: {:.3%}, Test: {:.3%}".format(epoch,new_loss,accur,test_acc)
msg2 = "{0} {1:.6f} {2:.6f} {3:.6f} \n".format(epoch,accur,test_acc,new_loss)
print(msg)
if new_loss>old_loss:
break
file = open(pathlog,"a");
file.write(msg2)
file.close();
old_loss=epoch_loss_avg.result()
#==============================================================================
# Save trained model to disk
#==============================================================================
model.compile(optimizer=tf.train.AdamOptimizer(),
loss=tf.keras.losses.sparse_categorical_crossentropy,
metrics=['accuracy'])
filepath="csvsignal.h5"
tf.keras.models.save_model(
model,
filepath,
overwrite=True,
include_optimizer=True
)
print("Model csvsignal.h5 saved to disk")
|
[
"tensorflow.enable_eager_execution",
"tensorflow.GradientTape",
"tensorflow.keras.layers.Dense",
"tensorflow.keras.layers.MaxPooling1D",
"tensorflow.set_random_seed",
"matplotlib.lines.Line2D",
"tensorflow.keras.models.save_model",
"tensorflow.keras.layers.Reshape",
"sklearn.decomposition.PCA",
"tensorflow.executing_eagerly",
"matplotlib.pyplot.close",
"matplotlib.pyplot.scatter",
"tensorflow.contrib.eager.metrics.Accuracy",
"tensorflow.train.AdamOptimizer",
"tensorflow.data.experimental.unbatch",
"tensorflow.train.get_or_create_global_step",
"tensorflow.data.Dataset.from_tensors",
"matplotlib.pyplot.savefig",
"tensorflow.keras.layers.GlobalMaxPool1D",
"matplotlib.pyplot.legend",
"numpy.set_printoptions",
"tensorflow.contrib.eager.metrics.Mean",
"tensorflow.data.experimental.make_csv_dataset",
"tensorflow.argmax",
"tensorflow.keras.layers.Conv1D",
"tensorflow.losses.sparse_softmax_cross_entropy"
] |
[((485, 512), 'tensorflow.enable_eager_execution', 'tf.enable_eager_execution', ([], {}), '()\n', (510, 512), True, 'import tensorflow as tf\n'), ((514, 532), 'tensorflow.set_random_seed', 'set_random_seed', (['(0)'], {}), '(0)\n', (529, 532), False, 'from tensorflow import set_random_seed\n'), ((5009, 5163), 'tensorflow.data.experimental.make_csv_dataset', 'tf.data.experimental.make_csv_dataset', (['total_dataset_fp', 'batch_size'], {'column_names': 'column_names', 'label_name': 'label_name', 'num_epochs': '(1)', 'shuffle': '(True)'}), '(total_dataset_fp, batch_size,\n column_names=column_names, label_name=label_name, num_epochs=1, shuffle\n =True)\n', (5046, 5163), True, 'import tensorflow as tf\n'), ((5951, 5989), 'tensorflow.data.Dataset.from_tensors', 'tf.data.Dataset.from_tensors', (['(k1, l1)'], {}), '((k1, l1))\n', (5979, 5989), True, 'import tensorflow as tf\n'), ((6074, 6112), 'tensorflow.data.Dataset.from_tensors', 'tf.data.Dataset.from_tensors', (['(k2, l2)'], {}), '((k2, l2))\n', (6102, 6112), True, 'import tensorflow as tf\n'), ((6411, 6454), 'tensorflow.train.AdamOptimizer', 'tf.train.AdamOptimizer', ([], {'learning_rate': 'lrate'}), '(learning_rate=lrate)\n', (6433, 6454), True, 'import tensorflow as tf\n'), ((6472, 6508), 'tensorflow.train.get_or_create_global_step', 'tf.train.get_or_create_global_step', ([], {}), '()\n', (6506, 6508), True, 'import tensorflow as tf\n'), ((6953, 6990), 'numpy.set_printoptions', 'np.set_printoptions', ([], {'threshold': 'np.nan'}), '(threshold=np.nan)\n', (6972, 6990), True, 'import numpy as np\n'), ((9700, 9787), 'tensorflow.keras.models.save_model', 'tf.keras.models.save_model', (['model', 'filepath'], {'overwrite': '(True)', 'include_optimizer': '(True)'}), '(model, filepath, overwrite=True,\n include_optimizer=True)\n', (9726, 9787), True, 'import tensorflow as tf\n'), ((4065, 4124), 'tensorflow.losses.sparse_softmax_cross_entropy', 'tf.losses.sparse_softmax_cross_entropy', ([], {'labels': 'y', 'logits': 'y_'}), '(labels=y, logits=y_)\n', (4103, 4124), True, 'import tensorflow as tf\n'), ((6533, 6634), 'matplotlib.lines.Line2D', 'Line2D', (['[0]', '[0]'], {'marker': '"""o"""', 'color': '"""w"""', 'label': 'class_names[0]', 'markerfacecolor': '"""r"""', 'markersize': '(10)'}), "([0], [0], marker='o', color='w', label=class_names[0],\n markerfacecolor='r', markersize=10)\n", (6539, 6634), False, 'from matplotlib.lines import Line2D\n'), ((6651, 6752), 'matplotlib.lines.Line2D', 'Line2D', (['[0]', '[0]'], {'marker': '"""o"""', 'color': '"""w"""', 'label': 'class_names[1]', 'markerfacecolor': '"""g"""', 'markersize': '(10)'}), "([0], [0], marker='o', color='w', label=class_names[1],\n markerfacecolor='g', markersize=10)\n", (6657, 6752), False, 'from matplotlib.lines import Line2D\n'), ((6769, 6870), 'matplotlib.lines.Line2D', 'Line2D', (['[0]', '[0]'], {'marker': '"""o"""', 'color': '"""w"""', 'label': 'class_names[2]', 'markerfacecolor': '"""b"""', 'markersize': '(10)'}), "([0], [0], marker='o', color='w', label=class_names[2],\n markerfacecolor='b', markersize=10)\n", (6775, 6870), False, 'from matplotlib.lines import Line2D\n'), ((7256, 7274), 'tensorflow.contrib.eager.metrics.Mean', 'tfe.metrics.Mean', ([], {}), '()\n', (7272, 7274), True, 'import tensorflow.contrib.eager as tfe\n'), ((7295, 7317), 'tensorflow.contrib.eager.metrics.Accuracy', 'tfe.metrics.Accuracy', ([], {}), '()\n', (7315, 7317), True, 'import tensorflow.contrib.eager as tfe\n'), ((1376, 1398), 'tensorflow.executing_eagerly', 'tf.executing_eagerly', ([], {}), '()\n', (1396, 1398), True, 'import tensorflow as tf\n'), ((1640, 1670), 'tensorflow.data.experimental.unbatch', 'tf.data.experimental.unbatch', ([], {}), '()\n', (1668, 1670), True, 'import tensorflow as tf\n'), ((4172, 4189), 'tensorflow.GradientTape', 'tf.GradientTape', ([], {}), '()\n', (4187, 4189), True, 'import tensorflow as tf\n'), ((8000, 8022), 'tensorflow.contrib.eager.metrics.Accuracy', 'tfe.metrics.Accuracy', ([], {}), '()\n', (8020, 8022), True, 'import tensorflow.contrib.eager as tfe\n'), ((9535, 9559), 'tensorflow.train.AdamOptimizer', 'tf.train.AdamOptimizer', ([], {}), '()\n', (9557, 9559), True, 'import tensorflow as tf\n'), ((2351, 2425), 'tensorflow.keras.layers.Reshape', 'tf.keras.layers.Reshape', (['(f_size, 1)'], {'input_shape': '(None, f_size)', 'name': '"""x"""'}), "((f_size, 1), input_shape=(None, f_size), name='x')\n", (2374, 2425), True, 'import tensorflow as tf\n'), ((2429, 2602), 'tensorflow.keras.layers.Conv1D', 'tf.keras.layers.Conv1D', ([], {'filters': 'filtr1', 'kernel_size': 'filtr_size1', 'strides': '(1)', 'kernel_initializer': '"""random_uniform"""', 'activation': 'tf.nn.relu', 'padding': '"""same"""', 'name': '"""Conv1"""'}), "(filters=filtr1, kernel_size=filtr_size1, strides=1,\n kernel_initializer='random_uniform', activation=tf.nn.relu, padding=\n 'same', name='Conv1')\n", (2451, 2602), True, 'import tensorflow as tf\n'), ((2595, 2692), 'tensorflow.keras.layers.MaxPooling1D', 'tf.keras.layers.MaxPooling1D', ([], {'pool_size': 'filtr_size1', 'strides': '(2)', 'padding': '"""same"""', 'name': '"""pool1"""'}), "(pool_size=filtr_size1, strides=2, padding=\n 'same', name='pool1')\n", (2623, 2692), True, 'import tensorflow as tf\n'), ((2694, 2867), 'tensorflow.keras.layers.Conv1D', 'tf.keras.layers.Conv1D', ([], {'filters': 'filtr2', 'kernel_size': 'filtr_size2', 'strides': '(1)', 'padding': '"""same"""', 'name': '"""Conv2"""', 'activation': 'tf.nn.relu', 'kernel_initializer': '"""random_uniform"""'}), "(filters=filtr2, kernel_size=filtr_size2, strides=1,\n padding='same', name='Conv2', activation=tf.nn.relu, kernel_initializer\n ='random_uniform')\n", (2716, 2867), True, 'import tensorflow as tf\n'), ((2861, 2958), 'tensorflow.keras.layers.MaxPooling1D', 'tf.keras.layers.MaxPooling1D', ([], {'pool_size': 'filtr_size2', 'strides': '(2)', 'padding': '"""same"""', 'name': '"""pool2"""'}), "(pool_size=filtr_size2, strides=2, padding=\n 'same', name='pool2')\n", (2889, 2958), True, 'import tensorflow as tf\n'), ((2966, 3139), 'tensorflow.keras.layers.Conv1D', 'tf.keras.layers.Conv1D', ([], {'filters': 'filtr3', 'kernel_size': 'filtr_size3', 'strides': '(1)', 'padding': '"""same"""', 'name': '"""Conv3"""', 'activation': 'tf.nn.relu', 'kernel_initializer': '"""random_uniform"""'}), "(filters=filtr3, kernel_size=filtr_size3, strides=1,\n padding='same', name='Conv3', activation=tf.nn.relu, kernel_initializer\n ='random_uniform')\n", (2988, 3139), True, 'import tensorflow as tf\n'), ((3133, 3230), 'tensorflow.keras.layers.MaxPooling1D', 'tf.keras.layers.MaxPooling1D', ([], {'pool_size': 'filtr_size3', 'strides': '(2)', 'padding': '"""same"""', 'name': '"""pool3"""'}), "(pool_size=filtr_size3, strides=2, padding=\n 'same', name='pool3')\n", (3161, 3230), True, 'import tensorflow as tf\n'), ((3232, 3405), 'tensorflow.keras.layers.Conv1D', 'tf.keras.layers.Conv1D', ([], {'filters': 'filtr4', 'kernel_size': 'filtr_size4', 'strides': '(1)', 'padding': '"""same"""', 'name': '"""Conv4"""', 'activation': 'tf.nn.relu', 'kernel_initializer': '"""random_uniform"""'}), "(filters=filtr4, kernel_size=filtr_size4, strides=1,\n padding='same', name='Conv4', activation=tf.nn.relu, kernel_initializer\n ='random_uniform')\n", (3254, 3405), True, 'import tensorflow as tf\n'), ((3399, 3496), 'tensorflow.keras.layers.MaxPooling1D', 'tf.keras.layers.MaxPooling1D', ([], {'pool_size': 'filtr_size4', 'strides': '(2)', 'padding': '"""same"""', 'name': '"""pool4"""'}), "(pool_size=filtr_size4, strides=2, padding=\n 'same', name='pool4')\n", (3427, 3496), True, 'import tensorflow as tf\n'), ((3500, 3533), 'tensorflow.keras.layers.GlobalMaxPool1D', 'tf.keras.layers.GlobalMaxPool1D', ([], {}), '()\n', (3531, 3533), True, 'import tensorflow as tf\n'), ((3566, 3633), 'tensorflow.keras.layers.Dense', 'tf.keras.layers.Dense', (['DenseLast'], {'activation': 'tf.nn.relu', 'name': '"""fir"""'}), "(DenseLast, activation=tf.nn.relu, name='fir')\n", (3587, 3633), True, 'import tensorflow as tf\n'), ((3663, 3727), 'tensorflow.keras.layers.Dense', 'tf.keras.layers.Dense', (['(256)'], {'activation': 'tf.nn.relu', 'name': '"""mod_up"""'}), "(256, activation=tf.nn.relu, name='mod_up')\n", (3684, 3727), True, 'import tensorflow as tf\n'), ((3735, 3774), 'tensorflow.keras.layers.Dense', 'tf.keras.layers.Dense', (['(3)'], {'name': '"""y_pred"""'}), "(3, name='y_pred')\n", (3756, 3774), True, 'import tensorflow as tf\n'), ((3828, 3852), 'tensorflow.train.AdamOptimizer', 'tf.train.AdamOptimizer', ([], {}), '()\n', (3850, 3852), True, 'import tensorflow as tf\n'), ((8103, 8150), 'tensorflow.argmax', 'tf.argmax', (['logits'], {'axis': '(1)', 'output_type': 'tf.int32'}), '(logits, axis=1, output_type=tf.int32)\n', (8112, 8150), True, 'import tensorflow as tf\n'), ((8237, 8355), 'sklearn.decomposition.PCA', 'PCA', ([], {'copy': '(True)', 'iterated_power': '"""auto"""', 'n_components': '(2)', 'random_state': 'None', 'svd_solver': '"""auto"""', 'tol': '(0.0)', 'whiten': '(False)'}), "(copy=True, iterated_power='auto', n_components=2, random_state=None,\n svd_solver='auto', tol=0.0, whiten=False)\n", (8240, 8355), False, 'from sklearn.decomposition import PCA\n'), ((8503, 8550), 'matplotlib.pyplot.scatter', 'plt.scatter', (['X[:, 0]', 'X[:, 1]'], {'s': '(40)', 'c': 'arrcolor'}), '(X[:, 0], X[:, 1], s=40, c=arrcolor)\n', (8514, 8550), True, 'import matplotlib.pyplot as plt\n'), ((8714, 8768), 'matplotlib.pyplot.legend', 'plt.legend', ([], {'handles': 'legend_elements', 'loc': '"""upper right"""'}), "(handles=legend_elements, loc='upper right')\n", (8724, 8768), True, 'import matplotlib.pyplot as plt\n'), ((8776, 8796), 'matplotlib.pyplot.savefig', 'plt.savefig', (['imgfile'], {}), '(imgfile)\n', (8787, 8796), True, 'import matplotlib.pyplot as plt\n'), ((8804, 8815), 'matplotlib.pyplot.close', 'plt.close', ([], {}), '()\n', (8813, 8815), True, 'import matplotlib.pyplot as plt\n'), ((8363, 8382), 'sklearn.decomposition.PCA', 'PCA', ([], {'n_components': '(2)'}), '(n_components=2)\n', (8366, 8382), False, 'from sklearn.decomposition import PCA\n')]
|
# -*- coding: utf-8 -*-
"""
Created on 2020/03/16
Feature selection: Relief-based feature selection algorithm.
------
@author: <NAME>
"""
import numpy as np
from sklearn import preprocessing
import os
from sklearn.externals import joblib
from el_classify_sensitive_person_train_validation import ClassifyFourKindOfPersonTrain
from eslearn.utils.lc_evaluation_model_performances import eval_performance
class ClassifyFourKindOfPersonTest():
"""
This class is used to testing classification model for 2 kind of sensitive person identification.
Parameters
----------
data_test_file: path str
Path of the dataset
label_test_file: path str
Path of the label
path_out :
Path to save results
is_feature_selection : bool
if perfrome feature selection.
is_showfig_finally: bool
If show figure after all iteration finished.
Returns
-------
Save all classification results and figures to local disk.
"""
def __init__(selftest,
data_test_file=None,
label_test_file=None,
data_train_file=None,
models_path=None,
path_out=None,
is_feature_selection=False,
is_showfig_finally=True):
selftest.data_test_file = data_test_file
selftest.label_test_file = label_test_file
selftest.data_train_file = data_train_file
selftest.path_out = path_out
selftest.models_path = models_path
selftest.is_feature_selection = is_feature_selection
selftest.is_showfig_finally = is_showfig_finally
def main_function(selftest):
"""
"""
print('Training model and testing...\n')
# load data and mask
mask_lassocv = joblib.load(os.path.join(selftest.path_out, 'mask_selected_features_lassocv.pkl'))
model_feature_selection = joblib.load(os.path.join(selftest.models_path, 'model_feature_selection.pkl'))
model_classification = joblib.load(os.path.join(selftest.models_path, 'model_classification.pkl'))
feature_test, selftest.label_test, feature_train = selftest._load_data()
# Age encoding
feature_test[:,2] = ClassifyFourKindOfPersonTrain().age_encodeing(feature_train[:,2], feature_test[:,2])
# Feature selection
if selftest.is_feature_selection:
feature_test = feature_test[:, mask_lassocv != 0]
# Testting
selftest.prediction, selftest.decision = selftest.testing(model_classification, feature_test)
# Evaluating classification performances
selftest.accuracy, selftest.sensitivity, selftest.specificity, selftest.AUC = eval_performance(selftest.label_test, selftest.prediction, selftest.decision,
accuracy_kfold=None, sensitivity_kfold=None, specificity_kfold=None, AUC_kfold=None,
verbose=1, is_showfig=0)
# Save results and fig to local path
selftest.save_results()
selftest.save_fig()
print("--" * 10 + "Done!" + "--" * 10 )
return selftest
def _load_data(selftest):
"""
Load data
"""
data_test = np.load(selftest.data_test_file)
label_test = np.load(selftest.label_test_file)
data_train = np.load(selftest.data_train_file)
return data_test, label_test, data_train
def testing(selftest, model, test_X):
predict = model.predict(test_X)
decision = model.decision_function(test_X)
return predict, decision
def save_results(selftest):
# Save performances and others
import pandas as pd
performances_to_save = np.array([selftest.accuracy, selftest.sensitivity, selftest.specificity, selftest.AUC]).reshape(1,4)
de_pred_label_to_save = np.vstack([selftest.decision.T, selftest.prediction.T, selftest.label_test.T]).T
performances_to_save = pd.DataFrame(performances_to_save, columns=[['Accuracy','Sensitivity', 'Specificity', 'AUC']])
de_pred_label_to_save = pd.DataFrame(de_pred_label_to_save, columns=[['Decision','Prediction', 'Sorted_Real_Label']])
performances_to_save.to_csv(os.path.join(selftest.path_out, 'test_Performances.txt'), index=False, header=True)
de_pred_label_to_save.to_csv(os.path.join(selftest.path_out, 'test_Decision_prediction_label.txt'), index=False, header=True)
def save_fig(selftest):
# Save ROC and Classification 2D figure
acc, sens, spec, auc = eval_performance(selftest.label_test, selftest.prediction, selftest.decision,
selftest.accuracy, selftest.sensitivity, selftest.specificity, selftest.AUC,
verbose=0, is_showfig=selftest.is_showfig_finally, is_savefig=1,
out_name=os.path.join(selftest.path_out, 'Classification_performances_test.pdf'),
legend1='Healthy', legend2='Unhealthy')
#
if __name__ == '__main__':
# =============================================================================
# All inputs
data_file = r'D:\workstation_b\Fundation\给黎超.xlsx'
path_out = r'D:\workstation_b\Fundation'
models_path = r'D:\workstation_b\Fundation'
# =============================================================================
selftest = ClassifyFourKindOfPersonTest(data_test_file=r'D:\workstation_b\Fundation\feature_test.npy',
label_test_file=r'D:\workstation_b\Fundation\label_test.npy',
data_train_file=r'D:\workstation_b\Fundation\feature_train.npy',
path_out=path_out,
models_path=models_path,
is_feature_selection=1)
selftest.main_function()
|
[
"pandas.DataFrame",
"os.path.join",
"numpy.array",
"numpy.vstack",
"eslearn.utils.lc_evaluation_model_performances.eval_performance",
"el_classify_sensitive_person_train_validation.ClassifyFourKindOfPersonTrain",
"numpy.load"
] |
[((2744, 2940), 'eslearn.utils.lc_evaluation_model_performances.eval_performance', 'eval_performance', (['selftest.label_test', 'selftest.prediction', 'selftest.decision'], {'accuracy_kfold': 'None', 'sensitivity_kfold': 'None', 'specificity_kfold': 'None', 'AUC_kfold': 'None', 'verbose': '(1)', 'is_showfig': '(0)'}), '(selftest.label_test, selftest.prediction, selftest.\n decision, accuracy_kfold=None, sensitivity_kfold=None,\n specificity_kfold=None, AUC_kfold=None, verbose=1, is_showfig=0)\n', (2760, 2940), False, 'from eslearn.utils.lc_evaluation_model_performances import eval_performance\n'), ((3243, 3275), 'numpy.load', 'np.load', (['selftest.data_test_file'], {}), '(selftest.data_test_file)\n', (3250, 3275), True, 'import numpy as np\n'), ((3297, 3330), 'numpy.load', 'np.load', (['selftest.label_test_file'], {}), '(selftest.label_test_file)\n', (3304, 3330), True, 'import numpy as np\n'), ((3352, 3385), 'numpy.load', 'np.load', (['selftest.data_train_file'], {}), '(selftest.data_train_file)\n', (3359, 3385), True, 'import numpy as np\n'), ((3979, 4078), 'pandas.DataFrame', 'pd.DataFrame', (['performances_to_save'], {'columns': "[['Accuracy', 'Sensitivity', 'Specificity', 'AUC']]"}), "(performances_to_save, columns=[['Accuracy', 'Sensitivity',\n 'Specificity', 'AUC']])\n", (3991, 4078), True, 'import pandas as pd\n'), ((4106, 4204), 'pandas.DataFrame', 'pd.DataFrame', (['de_pred_label_to_save'], {'columns': "[['Decision', 'Prediction', 'Sorted_Real_Label']]"}), "(de_pred_label_to_save, columns=[['Decision', 'Prediction',\n 'Sorted_Real_Label']])\n", (4118, 4204), True, 'import pandas as pd\n'), ((1827, 1896), 'os.path.join', 'os.path.join', (['selftest.path_out', '"""mask_selected_features_lassocv.pkl"""'], {}), "(selftest.path_out, 'mask_selected_features_lassocv.pkl')\n", (1839, 1896), False, 'import os\n'), ((1944, 2009), 'os.path.join', 'os.path.join', (['selftest.models_path', '"""model_feature_selection.pkl"""'], {}), "(selftest.models_path, 'model_feature_selection.pkl')\n", (1956, 2009), False, 'import os\n'), ((2054, 2116), 'os.path.join', 'os.path.join', (['selftest.models_path', '"""model_classification.pkl"""'], {}), "(selftest.models_path, 'model_classification.pkl')\n", (2066, 2116), False, 'import os\n'), ((3867, 3945), 'numpy.vstack', 'np.vstack', (['[selftest.decision.T, selftest.prediction.T, selftest.label_test.T]'], {}), '([selftest.decision.T, selftest.prediction.T, selftest.label_test.T])\n', (3876, 3945), True, 'import numpy as np\n'), ((4245, 4301), 'os.path.join', 'os.path.join', (['selftest.path_out', '"""test_Performances.txt"""'], {}), "(selftest.path_out, 'test_Performances.txt')\n", (4257, 4301), False, 'import os\n'), ((4366, 4435), 'os.path.join', 'os.path.join', (['selftest.path_out', '"""test_Decision_prediction_label.txt"""'], {}), "(selftest.path_out, 'test_Decision_prediction_label.txt')\n", (4378, 4435), False, 'import os\n'), ((2253, 2284), 'el_classify_sensitive_person_train_validation.ClassifyFourKindOfPersonTrain', 'ClassifyFourKindOfPersonTrain', ([], {}), '()\n', (2282, 2284), False, 'from el_classify_sensitive_person_train_validation import ClassifyFourKindOfPersonTrain\n'), ((3734, 3825), 'numpy.array', 'np.array', (['[selftest.accuracy, selftest.sensitivity, selftest.specificity, selftest.AUC]'], {}), '([selftest.accuracy, selftest.sensitivity, selftest.specificity,\n selftest.AUC])\n', (3742, 3825), True, 'import numpy as np\n'), ((4954, 5025), 'os.path.join', 'os.path.join', (['selftest.path_out', '"""Classification_performances_test.pdf"""'], {}), "(selftest.path_out, 'Classification_performances_test.pdf')\n", (4966, 5025), False, 'import os\n')]
|
from pandas.core.algorithms import mode
import torch
import torch.nn as nn
from albumentations import Compose,Resize,Normalize
from albumentations.pytorch import ToTensorV2
import wandb
import time
import torchvision
import torch.nn.functional as F
import torch.optim as optim
from torch.cuda.amp import autocast,GradScaler
import os
import numpy as np
from tqdm import tqdm
from callbacks import EarlyStopping
import pandas as pd
from torch.utils.data import Dataset, DataLoader
import cv2
import torch.nn.functional as F
import random
from build_model import Deformed_Darknet53
torch.manual_seed(2021)
np.random.seed(2021)
random.seed(2021)
torch.backends.cudnn.benchmark = True
torch.backends.cudnn.deterministic = True
DEVICE = "cuda:0" if torch.cuda.is_available() else "cpu"
TOTAL_EPOCHS = 100
scaler = GradScaler()
early_stop = EarlyStopping()
wandb.init(project='deformed-darknet',entity='tensorthug',name='new-darknet-256x256_32')
print("***** Loading the Model in {} *****".format(DEVICE))
Model = Deformed_Darknet53().to(DEVICE)
print("Model Shipped to {}".format(DEVICE))
data = pd.read_csv("data.csv")
train_loss_fn = nn.BCEWithLogitsLoss()
val_loss_fn = nn.BCEWithLogitsLoss()
optim = torch.optim.Adam(Model.parameters())
wandb.watch(Model)
class dog_cat(Dataset):
def __init__(self,df,mode="train",folds=0,transforms=None):
super(dog_cat,self).__init__()
self.df = df
self.mode = mode
self.folds = folds
self.transforms = transforms
if self.mode == "train":
self.data = self.df[self.df.folds != self.folds].reset_index(drop=True)
else:
self.data = self.df[self.df.folds == self.folds].reset_index(drop=True)
def __len__(self):
return len(self.data)
def __getitem__(self,idx):
img = cv2.imread(self.data.loc[idx,"Paths"])
label = self.data.loc[idx,'Labels']
if self.transforms is not None:
image = self.transforms(image=img)['image']
return image,label
def train_loop(epoch,dataloader,model,loss_fn,optim,device=DEVICE):
model.train()
epoch_loss = 0
epoch_acc = 0
#start_time = time.time()
pbar = tqdm(enumerate(dataloader),total=len(dataloader))
for i,(img,label) in pbar:
optim.zero_grad()
img = img.to(DEVICE).float()
label = label.to(DEVICE).float()
#LOAD_TIME = time.time() - start_time
with autocast():
yhat = model(img)
#Loss Calculation
train_loss = loss_fn(input = yhat.flatten(), target = label)
out = (yhat.flatten().sigmoid() > 0.5).float()
correct = (label == out).float().sum()
scaler.scale(train_loss).backward()
scaler.step(optim)
scaler.update()
epoch_loss += train_loss.item()
epoch_acc += correct.item() / out.shape[0]
train_epoch_loss = epoch_loss / len(dataloader)
train_epoch_acc = epoch_acc / len(dataloader)
wandb.log({"Training_Loss":train_epoch_loss})
wandb.log({"Training_Acc":train_epoch_acc})
#print(f"Epoch:{epoch}/{TOTAL_EPOCHS} Epoch Loss:{epoch_loss / len(dataloader):.4f} Epoch Acc:{epoch_acc / len(dataloader):.4f}")
return train_epoch_loss,train_epoch_acc
def val_loop(epoch,dataloader,model,loss_fn,device = DEVICE):
model.eval()
val_epoch_loss = 0
val_epoch_acc = 0
pbar = tqdm(enumerate(dataloader),total=len(dataloader))
with torch.no_grad():
for i,(img,label) in pbar:
img = img.to(device).float()
label = label.to(device).float()
yhat = model(img)
val_loss = loss_fn(input=yhat.flatten(),target=label)
out = (yhat.flatten().sigmoid()>0.5).float()
correct = (label == out).float().sum()
val_epoch_loss += val_loss.item()
val_epoch_acc += correct.item() / out.shape[0]
val_lossd = val_epoch_loss / len(dataloader)
val_accd = val_epoch_acc / len(dataloader)
wandb.log({"Val_Loss":val_lossd,"Epoch":epoch})
wandb.log({"Val_Acc":val_accd/len(dataloader),"Epoch":epoch})
return val_lossd,val_accd
if __name__ == "__main__":
train_per_epoch_loss,train_per_epoch_acc = [],[]
val_per_epoch_loss,val_per_epoch_acc = [],[]
train = dog_cat(data,transforms=Compose([Resize(256,256),Normalize(),ToTensorV2()]))
val = dog_cat(data,mode='val',transforms=Compose([Resize(256,256),Normalize(),ToTensorV2()]))
train_load = DataLoader(train,batch_size=32,shuffle=True,num_workers=4)
val_load = DataLoader(val,batch_size=32,num_workers=4)
for e in range(TOTAL_EPOCHS):
train_loss,train_acc = train_loop(e,train_load,Model,train_loss_fn,optim)
val_loss,val_acc = val_loop(e,val_load,Model,val_loss_fn)
train_per_epoch_loss.append(train_loss)
train_per_epoch_acc.append(train_acc)
val_per_epoch_loss.append(val_loss)
val_per_epoch_acc.append(val_acc)
print(f"TrainLoss:{train_loss:.4f} TrainAcc:{train_acc:.4f}")
print(f"ValLoss:{val_loss:.4f} ValAcc:{val_acc:.4f}")
early_stop(Model,val_loss)
if early_stop.early_stop:
break
|
[
"wandb.log",
"pandas.read_csv",
"wandb.init",
"torch.cuda.is_available",
"torch.cuda.amp.GradScaler",
"torch.cuda.amp.autocast",
"numpy.random.seed",
"build_model.Deformed_Darknet53",
"albumentations.Normalize",
"callbacks.EarlyStopping",
"torch.nn.BCEWithLogitsLoss",
"torch.optim.zero_grad",
"cv2.imread",
"torch.manual_seed",
"albumentations.pytorch.ToTensorV2",
"random.seed",
"wandb.watch",
"albumentations.Resize",
"torch.utils.data.DataLoader",
"torch.no_grad"
] |
[((585, 608), 'torch.manual_seed', 'torch.manual_seed', (['(2021)'], {}), '(2021)\n', (602, 608), False, 'import torch\n'), ((609, 629), 'numpy.random.seed', 'np.random.seed', (['(2021)'], {}), '(2021)\n', (623, 629), True, 'import numpy as np\n'), ((630, 647), 'random.seed', 'random.seed', (['(2021)'], {}), '(2021)\n', (641, 647), False, 'import random\n'), ((814, 826), 'torch.cuda.amp.GradScaler', 'GradScaler', ([], {}), '()\n', (824, 826), False, 'from torch.cuda.amp import autocast, GradScaler\n'), ((840, 855), 'callbacks.EarlyStopping', 'EarlyStopping', ([], {}), '()\n', (853, 855), False, 'from callbacks import EarlyStopping\n'), ((856, 951), 'wandb.init', 'wandb.init', ([], {'project': '"""deformed-darknet"""', 'entity': '"""tensorthug"""', 'name': '"""new-darknet-256x256_32"""'}), "(project='deformed-darknet', entity='tensorthug', name=\n 'new-darknet-256x256_32')\n", (866, 951), False, 'import wandb\n'), ((1102, 1125), 'pandas.read_csv', 'pd.read_csv', (['"""data.csv"""'], {}), "('data.csv')\n", (1113, 1125), True, 'import pandas as pd\n'), ((1143, 1165), 'torch.nn.BCEWithLogitsLoss', 'nn.BCEWithLogitsLoss', ([], {}), '()\n', (1163, 1165), True, 'import torch.nn as nn\n'), ((1180, 1202), 'torch.nn.BCEWithLogitsLoss', 'nn.BCEWithLogitsLoss', ([], {}), '()\n', (1200, 1202), True, 'import torch.nn as nn\n'), ((1250, 1268), 'wandb.watch', 'wandb.watch', (['Model'], {}), '(Model)\n', (1261, 1268), False, 'import wandb\n'), ((749, 774), 'torch.cuda.is_available', 'torch.cuda.is_available', ([], {}), '()\n', (772, 774), False, 'import torch\n'), ((3052, 3098), 'wandb.log', 'wandb.log', (["{'Training_Loss': train_epoch_loss}"], {}), "({'Training_Loss': train_epoch_loss})\n", (3061, 3098), False, 'import wandb\n'), ((3102, 3146), 'wandb.log', 'wandb.log', (["{'Training_Acc': train_epoch_acc}"], {}), "({'Training_Acc': train_epoch_acc})\n", (3111, 3146), False, 'import wandb\n'), ((4616, 4677), 'torch.utils.data.DataLoader', 'DataLoader', (['train'], {'batch_size': '(32)', 'shuffle': '(True)', 'num_workers': '(4)'}), '(train, batch_size=32, shuffle=True, num_workers=4)\n', (4626, 4677), False, 'from torch.utils.data import Dataset, DataLoader\n'), ((4690, 4735), 'torch.utils.data.DataLoader', 'DataLoader', (['val'], {'batch_size': '(32)', 'num_workers': '(4)'}), '(val, batch_size=32, num_workers=4)\n', (4700, 4735), False, 'from torch.utils.data import Dataset, DataLoader\n'), ((1017, 1037), 'build_model.Deformed_Darknet53', 'Deformed_Darknet53', ([], {}), '()\n', (1035, 1037), False, 'from build_model import Deformed_Darknet53\n'), ((1853, 1892), 'cv2.imread', 'cv2.imread', (["self.data.loc[idx, 'Paths']"], {}), "(self.data.loc[idx, 'Paths'])\n", (1863, 1892), False, 'import cv2\n'), ((2325, 2342), 'torch.optim.zero_grad', 'optim.zero_grad', ([], {}), '()\n', (2340, 2342), True, 'import torch.optim as optim\n'), ((3534, 3549), 'torch.no_grad', 'torch.no_grad', ([], {}), '()\n', (3547, 3549), False, 'import torch\n'), ((4106, 4156), 'wandb.log', 'wandb.log', (["{'Val_Loss': val_lossd, 'Epoch': epoch}"], {}), "({'Val_Loss': val_lossd, 'Epoch': epoch})\n", (4115, 4156), False, 'import wandb\n'), ((2491, 2501), 'torch.cuda.amp.autocast', 'autocast', ([], {}), '()\n', (2499, 2501), False, 'from torch.cuda.amp import autocast, GradScaler\n'), ((4456, 4472), 'albumentations.Resize', 'Resize', (['(256)', '(256)'], {}), '(256, 256)\n', (4462, 4472), False, 'from albumentations import Compose, Resize, Normalize\n'), ((4472, 4483), 'albumentations.Normalize', 'Normalize', ([], {}), '()\n', (4481, 4483), False, 'from albumentations import Compose, Resize, Normalize\n'), ((4484, 4496), 'albumentations.pytorch.ToTensorV2', 'ToTensorV2', ([], {}), '()\n', (4494, 4496), False, 'from albumentations.pytorch import ToTensorV2\n'), ((4554, 4570), 'albumentations.Resize', 'Resize', (['(256)', '(256)'], {}), '(256, 256)\n', (4560, 4570), False, 'from albumentations import Compose, Resize, Normalize\n'), ((4570, 4581), 'albumentations.Normalize', 'Normalize', ([], {}), '()\n', (4579, 4581), False, 'from albumentations import Compose, Resize, Normalize\n'), ((4582, 4594), 'albumentations.pytorch.ToTensorV2', 'ToTensorV2', ([], {}), '()\n', (4592, 4594), False, 'from albumentations.pytorch import ToTensorV2\n')]
|
import os.path as op
from urllib.request import urlretrieve
import matplotlib
import numpy as np
from numpy.testing import assert_allclose
import pytest
import hnn_core
from hnn_core import read_params, read_dipole, average_dipoles
from hnn_core import Network, jones_2009_model
from hnn_core.viz import plot_dipole
from hnn_core.dipole import Dipole, simulate_dipole, _rmse
from hnn_core.parallel_backends import requires_mpi4py, requires_psutil
matplotlib.use('agg')
def test_dipole(tmpdir, run_hnn_core_fixture):
"""Test dipole object."""
hnn_core_root = op.dirname(hnn_core.__file__)
params_fname = op.join(hnn_core_root, 'param', 'default.json')
dpl_out_fname = tmpdir.join('dpl1.txt')
params = read_params(params_fname)
times = np.arange(0, 6000 * params['dt'], params['dt'])
data = np.random.random((6000, 3))
dipole = Dipole(times, data)
dipole._baseline_renormalize(params['N_pyr_x'], params['N_pyr_y'])
dipole._convert_fAm_to_nAm()
# test smoothing and scaling
dipole_raw = dipole.copy()
dipole.scale(params['dipole_scalefctr'])
dipole.smooth(window_len=params['dipole_smooth_win'])
with pytest.raises(AssertionError):
assert_allclose(dipole.data['agg'], dipole_raw.data['agg'])
assert_allclose(dipole.data['agg'],
(params['dipole_scalefctr'] * dipole_raw.smooth(
params['dipole_smooth_win']).data['agg']))
dipole.plot(show=False)
plot_dipole([dipole, dipole], show=False)
# Test IO
dipole.write(dpl_out_fname)
dipole_read = read_dipole(dpl_out_fname)
assert_allclose(dipole_read.times, dipole.times, rtol=0, atol=0.00051)
for dpl_key in dipole.data.keys():
assert_allclose(dipole_read.data[dpl_key],
dipole.data[dpl_key], rtol=0, atol=0.000051)
# average two identical dipole objects
dipole_avg = average_dipoles([dipole, dipole_read])
for dpl_key in dipole_avg.data.keys():
assert_allclose(dipole_read.data[dpl_key],
dipole_avg.data[dpl_key], rtol=0, atol=0.000051)
with pytest.raises(ValueError, match="Dipole at index 0 was already an "
"average of 2 trials"):
dipole_avg = average_dipoles([dipole_avg, dipole_read])
# average an n_of_1 dipole list
single_dpl_avg = average_dipoles([dipole])
for dpl_key in single_dpl_avg.data.keys():
assert_allclose(
dipole_read.data[dpl_key],
single_dpl_avg.data[dpl_key],
rtol=0,
atol=0.000051)
# average dipole list with one dipole object and a zero dipole object
n_times = len(dipole_read.data['agg'])
dpl_null = Dipole(np.zeros(n_times, ), np.zeros((n_times, 3)))
dpl_1 = [dipole, dpl_null]
dpl_avg = average_dipoles(dpl_1)
for dpl_key in dpl_avg.data.keys():
assert_allclose(dpl_1[0].data[dpl_key] / 2., dpl_avg.data[dpl_key])
# Test experimental dipole
dipole_exp = Dipole(times, data[:, 1])
dipole_exp.write(dpl_out_fname)
dipole_exp_read = read_dipole(dpl_out_fname)
assert_allclose(dipole_exp.data['agg'], dipole_exp_read.data['agg'],
rtol=1e-2)
dipole_exp_avg = average_dipoles([dipole_exp, dipole_exp])
assert_allclose(dipole_exp.data['agg'], dipole_exp_avg.data['agg'])
# XXX all below to be deprecated in 0.3
dpls_raw, net = run_hnn_core_fixture(backend='joblib', n_jobs=1,
reduced=True, record_isoma=True,
record_vsoma=True)
# test deprecation of postproc
with pytest.warns(DeprecationWarning,
match='The postproc-argument is deprecated'):
dpls, _ = run_hnn_core_fixture(backend='joblib', n_jobs=1,
reduced=True, record_isoma=True,
record_vsoma=True, postproc=True)
with pytest.raises(AssertionError):
assert_allclose(dpls[0].data['agg'], dpls_raw[0].data['agg'])
dpls_raw[0]._post_proc(net._params['dipole_smooth_win'],
net._params['dipole_scalefctr'])
assert_allclose(dpls_raw[0].data['agg'], dpls[0].data['agg'])
def test_dipole_simulation():
"""Test data produced from simulate_dipole() call."""
hnn_core_root = op.dirname(hnn_core.__file__)
params_fname = op.join(hnn_core_root, 'param', 'default.json')
params = read_params(params_fname)
params.update({'N_pyr_x': 3,
'N_pyr_y': 3,
'dipole_smooth_win': 5,
't_evprox_1': 5,
't_evdist_1': 10,
't_evprox_2': 20})
net = jones_2009_model(params, add_drives_from_params=True)
with pytest.raises(ValueError, match="Invalid number of simulations: 0"):
simulate_dipole(net, tstop=25., n_trials=0)
with pytest.raises(TypeError, match="record_vsoma must be bool, got int"):
simulate_dipole(net, tstop=25., n_trials=1, record_vsoma=0)
with pytest.raises(TypeError, match="record_isoma must be bool, got int"):
simulate_dipole(net, tstop=25., n_trials=1, record_vsoma=False,
record_isoma=0)
# test Network.copy() returns 'bare' network after simulating
dpl = simulate_dipole(net, tstop=25., n_trials=1)[0]
net_copy = net.copy()
assert len(net_copy.external_drives['evprox1']['events']) == 0
# test that Dipole.copy() returns the expected exact copy
assert_allclose(dpl.data['agg'], dpl.copy().data['agg'])
with pytest.warns(UserWarning, match='No connections'):
net = Network(params)
# warning triggered on simulate_dipole()
simulate_dipole(net, tstop=0.1, n_trials=1)
# Smoke test for raster plot with no spikes
net.cell_response.plot_spikes_raster()
@requires_mpi4py
@requires_psutil
def test_cell_response_backends(run_hnn_core_fixture):
"""Test cell_response outputs across backends."""
# reduced simulation has n_trials=2
trial_idx, n_trials, gid = 0, 2, 7
_, joblib_net = run_hnn_core_fixture(backend='joblib', n_jobs=1,
reduced=True, record_isoma=True,
record_vsoma=True)
_, mpi_net = run_hnn_core_fixture(backend='mpi', n_procs=2, reduced=True,
record_isoma=True, record_vsoma=True)
n_times = len(joblib_net.cell_response.times)
assert len(joblib_net.cell_response.vsoma) == n_trials
assert len(joblib_net.cell_response.isoma) == n_trials
assert len(joblib_net.cell_response.vsoma[trial_idx][gid]) == n_times
assert len(joblib_net.cell_response.isoma[
trial_idx][gid]['soma_gabaa']) == n_times
assert len(mpi_net.cell_response.vsoma) == n_trials
assert len(mpi_net.cell_response.isoma) == n_trials
assert len(mpi_net.cell_response.vsoma[trial_idx][gid]) == n_times
assert len(mpi_net.cell_response.isoma[
trial_idx][gid]['soma_gabaa']) == n_times
assert mpi_net.cell_response.vsoma == joblib_net.cell_response.vsoma
assert mpi_net.cell_response.isoma == joblib_net.cell_response.isoma
# Test if spike time falls within depolarization window above v_thresh
v_thresh = 0.0
times = np.array(joblib_net.cell_response.times)
spike_times = np.array(joblib_net.cell_response.spike_times[trial_idx])
spike_gids = np.array(joblib_net.cell_response.spike_gids[trial_idx])
vsoma = np.array(joblib_net.cell_response.vsoma[trial_idx][gid])
v_mask = vsoma > v_thresh
assert np.all([spike_times[spike_gids == gid] > times[v_mask][0],
spike_times[spike_gids == gid] < times[v_mask][-1]])
# test that event times before and after simulation are the same
for drive_name, drive in joblib_net.external_drives.items():
gid_ran = joblib_net.gid_ranges[drive_name]
for idx_drive, event_times in enumerate(drive['events'][trial_idx]):
net_ets = [spike_times[i] for i, g in enumerate(spike_gids) if
g == gid_ran[idx_drive]]
assert_allclose(np.array(event_times), np.array(net_ets))
def test_rmse():
"""Test to check RMSE calculation"""
data_url = ('https://raw.githubusercontent.com/jonescompneurolab/hnn/'
'master/data/MEG_detection_data/yes_trial_S1_ERP_all_avg.txt')
if not op.exists('yes_trial_S1_ERP_all_avg.txt'):
urlretrieve(data_url, 'yes_trial_S1_ERP_all_avg.txt')
extdata = np.loadtxt('yes_trial_S1_ERP_all_avg.txt')
exp_dpl = Dipole(times=extdata[:, 0],
data=np.c_[extdata[:, 1], extdata[:, 1], extdata[:, 1]])
hnn_core_root = op.join(op.dirname(hnn_core.__file__))
params_fname = op.join(hnn_core_root, 'param', 'default.json')
params = read_params(params_fname)
expected_rmse = 0.1
test_dpl = Dipole(times=extdata[:, 0],
data=np.c_[extdata[:, 1] + expected_rmse,
extdata[:, 1] + expected_rmse,
extdata[:, 1] + expected_rmse])
avg_rmse = _rmse(test_dpl, exp_dpl, tstop=params['tstop'])
assert_allclose(avg_rmse, expected_rmse)
|
[
"hnn_core.jones_2009_model",
"hnn_core.dipole.Dipole",
"numpy.array",
"numpy.loadtxt",
"numpy.arange",
"os.path.exists",
"hnn_core.dipole.simulate_dipole",
"urllib.request.urlretrieve",
"numpy.random.random",
"numpy.testing.assert_allclose",
"hnn_core.average_dipoles",
"hnn_core.dipole._rmse",
"matplotlib.use",
"os.path.dirname",
"pytest.raises",
"hnn_core.read_params",
"hnn_core.read_dipole",
"hnn_core.Network",
"os.path.join",
"numpy.zeros",
"numpy.all",
"hnn_core.viz.plot_dipole",
"pytest.warns"
] |
[((450, 471), 'matplotlib.use', 'matplotlib.use', (['"""agg"""'], {}), "('agg')\n", (464, 471), False, 'import matplotlib\n'), ((571, 600), 'os.path.dirname', 'op.dirname', (['hnn_core.__file__'], {}), '(hnn_core.__file__)\n', (581, 600), True, 'import os.path as op\n'), ((620, 667), 'os.path.join', 'op.join', (['hnn_core_root', '"""param"""', '"""default.json"""'], {}), "(hnn_core_root, 'param', 'default.json')\n", (627, 667), True, 'import os.path as op\n'), ((725, 750), 'hnn_core.read_params', 'read_params', (['params_fname'], {}), '(params_fname)\n', (736, 750), False, 'from hnn_core import read_params, read_dipole, average_dipoles\n'), ((763, 810), 'numpy.arange', 'np.arange', (['(0)', "(6000 * params['dt'])", "params['dt']"], {}), "(0, 6000 * params['dt'], params['dt'])\n", (772, 810), True, 'import numpy as np\n'), ((822, 849), 'numpy.random.random', 'np.random.random', (['(6000, 3)'], {}), '((6000, 3))\n', (838, 849), True, 'import numpy as np\n'), ((863, 882), 'hnn_core.dipole.Dipole', 'Dipole', (['times', 'data'], {}), '(times, data)\n', (869, 882), False, 'from hnn_core.dipole import Dipole, simulate_dipole, _rmse\n'), ((1472, 1513), 'hnn_core.viz.plot_dipole', 'plot_dipole', (['[dipole, dipole]'], {'show': '(False)'}), '([dipole, dipole], show=False)\n', (1483, 1513), False, 'from hnn_core.viz import plot_dipole\n'), ((1579, 1605), 'hnn_core.read_dipole', 'read_dipole', (['dpl_out_fname'], {}), '(dpl_out_fname)\n', (1590, 1605), False, 'from hnn_core import read_params, read_dipole, average_dipoles\n'), ((1610, 1680), 'numpy.testing.assert_allclose', 'assert_allclose', (['dipole_read.times', 'dipole.times'], {'rtol': '(0)', 'atol': '(0.00051)'}), '(dipole_read.times, dipole.times, rtol=0, atol=0.00051)\n', (1625, 1680), False, 'from numpy.testing import assert_allclose\n'), ((1901, 1939), 'hnn_core.average_dipoles', 'average_dipoles', (['[dipole, dipole_read]'], {}), '([dipole, dipole_read])\n', (1916, 1939), False, 'from hnn_core import read_params, read_dipole, average_dipoles\n'), ((2354, 2379), 'hnn_core.average_dipoles', 'average_dipoles', (['[dipole]'], {}), '([dipole])\n', (2369, 2379), False, 'from hnn_core import read_params, read_dipole, average_dipoles\n'), ((2810, 2832), 'hnn_core.average_dipoles', 'average_dipoles', (['dpl_1'], {}), '(dpl_1)\n', (2825, 2832), False, 'from hnn_core import read_params, read_dipole, average_dipoles\n'), ((2998, 3023), 'hnn_core.dipole.Dipole', 'Dipole', (['times', 'data[:, 1]'], {}), '(times, data[:, 1])\n', (3004, 3023), False, 'from hnn_core.dipole import Dipole, simulate_dipole, _rmse\n'), ((3082, 3108), 'hnn_core.read_dipole', 'read_dipole', (['dpl_out_fname'], {}), '(dpl_out_fname)\n', (3093, 3108), False, 'from hnn_core import read_params, read_dipole, average_dipoles\n'), ((3113, 3192), 'numpy.testing.assert_allclose', 'assert_allclose', (["dipole_exp.data['agg']", "dipole_exp_read.data['agg']"], {'rtol': '(0.01)'}), "(dipole_exp.data['agg'], dipole_exp_read.data['agg'], rtol=0.01)\n", (3128, 3192), False, 'from numpy.testing import assert_allclose\n'), ((3234, 3275), 'hnn_core.average_dipoles', 'average_dipoles', (['[dipole_exp, dipole_exp]'], {}), '([dipole_exp, dipole_exp])\n', (3249, 3275), False, 'from hnn_core import read_params, read_dipole, average_dipoles\n'), ((3280, 3347), 'numpy.testing.assert_allclose', 'assert_allclose', (["dipole_exp.data['agg']", "dipole_exp_avg.data['agg']"], {}), "(dipole_exp.data['agg'], dipole_exp_avg.data['agg'])\n", (3295, 3347), False, 'from numpy.testing import assert_allclose\n'), ((4189, 4250), 'numpy.testing.assert_allclose', 'assert_allclose', (["dpls_raw[0].data['agg']", "dpls[0].data['agg']"], {}), "(dpls_raw[0].data['agg'], dpls[0].data['agg'])\n", (4204, 4250), False, 'from numpy.testing import assert_allclose\n'), ((4361, 4390), 'os.path.dirname', 'op.dirname', (['hnn_core.__file__'], {}), '(hnn_core.__file__)\n', (4371, 4390), True, 'import os.path as op\n'), ((4410, 4457), 'os.path.join', 'op.join', (['hnn_core_root', '"""param"""', '"""default.json"""'], {}), "(hnn_core_root, 'param', 'default.json')\n", (4417, 4457), True, 'import os.path as op\n'), ((4471, 4496), 'hnn_core.read_params', 'read_params', (['params_fname'], {}), '(params_fname)\n', (4482, 4496), False, 'from hnn_core import read_params, read_dipole, average_dipoles\n'), ((4727, 4780), 'hnn_core.jones_2009_model', 'jones_2009_model', (['params'], {'add_drives_from_params': '(True)'}), '(params, add_drives_from_params=True)\n', (4743, 4780), False, 'from hnn_core import Network, jones_2009_model\n'), ((7349, 7389), 'numpy.array', 'np.array', (['joblib_net.cell_response.times'], {}), '(joblib_net.cell_response.times)\n', (7357, 7389), True, 'import numpy as np\n'), ((7408, 7465), 'numpy.array', 'np.array', (['joblib_net.cell_response.spike_times[trial_idx]'], {}), '(joblib_net.cell_response.spike_times[trial_idx])\n', (7416, 7465), True, 'import numpy as np\n'), ((7483, 7539), 'numpy.array', 'np.array', (['joblib_net.cell_response.spike_gids[trial_idx]'], {}), '(joblib_net.cell_response.spike_gids[trial_idx])\n', (7491, 7539), True, 'import numpy as np\n'), ((7552, 7608), 'numpy.array', 'np.array', (['joblib_net.cell_response.vsoma[trial_idx][gid]'], {}), '(joblib_net.cell_response.vsoma[trial_idx][gid])\n', (7560, 7608), True, 'import numpy as np\n'), ((7651, 7767), 'numpy.all', 'np.all', (['[spike_times[spike_gids == gid] > times[v_mask][0], spike_times[spike_gids ==\n gid] < times[v_mask][-1]]'], {}), '([spike_times[spike_gids == gid] > times[v_mask][0], spike_times[\n spike_gids == gid] < times[v_mask][-1]])\n', (7657, 7767), True, 'import numpy as np\n'), ((8583, 8625), 'numpy.loadtxt', 'np.loadtxt', (['"""yes_trial_S1_ERP_all_avg.txt"""'], {}), "('yes_trial_S1_ERP_all_avg.txt')\n", (8593, 8625), True, 'import numpy as np\n'), ((8641, 8729), 'hnn_core.dipole.Dipole', 'Dipole', ([], {'times': 'extdata[:, 0]', 'data': 'np.c_[extdata[:, 1], extdata[:, 1], extdata[:, 1]]'}), '(times=extdata[:, 0], data=np.c_[extdata[:, 1], extdata[:, 1],\n extdata[:, 1]])\n', (8647, 8729), False, 'from hnn_core.dipole import Dipole, simulate_dipole, _rmse\n'), ((8826, 8873), 'os.path.join', 'op.join', (['hnn_core_root', '"""param"""', '"""default.json"""'], {}), "(hnn_core_root, 'param', 'default.json')\n", (8833, 8873), True, 'import os.path as op\n'), ((8887, 8912), 'hnn_core.read_params', 'read_params', (['params_fname'], {}), '(params_fname)\n', (8898, 8912), False, 'from hnn_core import read_params, read_dipole, average_dipoles\n'), ((8953, 9090), 'hnn_core.dipole.Dipole', 'Dipole', ([], {'times': 'extdata[:, 0]', 'data': 'np.c_[extdata[:, 1] + expected_rmse, extdata[:, 1] + expected_rmse, extdata\n [:, 1] + expected_rmse]'}), '(times=extdata[:, 0], data=np.c_[extdata[:, 1] + expected_rmse, \n extdata[:, 1] + expected_rmse, extdata[:, 1] + expected_rmse])\n', (8959, 9090), False, 'from hnn_core.dipole import Dipole, simulate_dipole, _rmse\n'), ((9189, 9236), 'hnn_core.dipole._rmse', '_rmse', (['test_dpl', 'exp_dpl'], {'tstop': "params['tstop']"}), "(test_dpl, exp_dpl, tstop=params['tstop'])\n", (9194, 9236), False, 'from hnn_core.dipole import Dipole, simulate_dipole, _rmse\n'), ((9242, 9282), 'numpy.testing.assert_allclose', 'assert_allclose', (['avg_rmse', 'expected_rmse'], {}), '(avg_rmse, expected_rmse)\n', (9257, 9282), False, 'from numpy.testing import assert_allclose\n'), ((1164, 1193), 'pytest.raises', 'pytest.raises', (['AssertionError'], {}), '(AssertionError)\n', (1177, 1193), False, 'import pytest\n'), ((1203, 1262), 'numpy.testing.assert_allclose', 'assert_allclose', (["dipole.data['agg']", "dipole_raw.data['agg']"], {}), "(dipole.data['agg'], dipole_raw.data['agg'])\n", (1218, 1262), False, 'from numpy.testing import assert_allclose\n'), ((1728, 1818), 'numpy.testing.assert_allclose', 'assert_allclose', (['dipole_read.data[dpl_key]', 'dipole.data[dpl_key]'], {'rtol': '(0)', 'atol': '(5.1e-05)'}), '(dipole_read.data[dpl_key], dipole.data[dpl_key], rtol=0,\n atol=5.1e-05)\n', (1743, 1818), False, 'from numpy.testing import assert_allclose\n'), ((1991, 2085), 'numpy.testing.assert_allclose', 'assert_allclose', (['dipole_read.data[dpl_key]', 'dipole_avg.data[dpl_key]'], {'rtol': '(0)', 'atol': '(5.1e-05)'}), '(dipole_read.data[dpl_key], dipole_avg.data[dpl_key], rtol=0,\n atol=5.1e-05)\n', (2006, 2085), False, 'from numpy.testing import assert_allclose\n'), ((2117, 2209), 'pytest.raises', 'pytest.raises', (['ValueError'], {'match': '"""Dipole at index 0 was already an average of 2 trials"""'}), "(ValueError, match=\n 'Dipole at index 0 was already an average of 2 trials')\n", (2130, 2209), False, 'import pytest\n'), ((2253, 2295), 'hnn_core.average_dipoles', 'average_dipoles', (['[dipole_avg, dipole_read]'], {}), '([dipole_avg, dipole_read])\n', (2268, 2295), False, 'from hnn_core import read_params, read_dipole, average_dipoles\n'), ((2435, 2533), 'numpy.testing.assert_allclose', 'assert_allclose', (['dipole_read.data[dpl_key]', 'single_dpl_avg.data[dpl_key]'], {'rtol': '(0)', 'atol': '(5.1e-05)'}), '(dipole_read.data[dpl_key], single_dpl_avg.data[dpl_key],\n rtol=0, atol=5.1e-05)\n', (2450, 2533), False, 'from numpy.testing import assert_allclose\n'), ((2720, 2737), 'numpy.zeros', 'np.zeros', (['n_times'], {}), '(n_times)\n', (2728, 2737), True, 'import numpy as np\n'), ((2741, 2763), 'numpy.zeros', 'np.zeros', (['(n_times, 3)'], {}), '((n_times, 3))\n', (2749, 2763), True, 'import numpy as np\n'), ((2881, 2949), 'numpy.testing.assert_allclose', 'assert_allclose', (['(dpl_1[0].data[dpl_key] / 2.0)', 'dpl_avg.data[dpl_key]'], {}), '(dpl_1[0].data[dpl_key] / 2.0, dpl_avg.data[dpl_key])\n', (2896, 2949), False, 'from numpy.testing import assert_allclose\n'), ((3640, 3717), 'pytest.warns', 'pytest.warns', (['DeprecationWarning'], {'match': '"""The postproc-argument is deprecated"""'}), "(DeprecationWarning, match='The postproc-argument is deprecated')\n", (3652, 3717), False, 'import pytest\n'), ((3962, 3991), 'pytest.raises', 'pytest.raises', (['AssertionError'], {}), '(AssertionError)\n', (3975, 3991), False, 'import pytest\n'), ((4001, 4062), 'numpy.testing.assert_allclose', 'assert_allclose', (["dpls[0].data['agg']", "dpls_raw[0].data['agg']"], {}), "(dpls[0].data['agg'], dpls_raw[0].data['agg'])\n", (4016, 4062), False, 'from numpy.testing import assert_allclose\n'), ((4790, 4857), 'pytest.raises', 'pytest.raises', (['ValueError'], {'match': '"""Invalid number of simulations: 0"""'}), "(ValueError, match='Invalid number of simulations: 0')\n", (4803, 4857), False, 'import pytest\n'), ((4867, 4911), 'hnn_core.dipole.simulate_dipole', 'simulate_dipole', (['net'], {'tstop': '(25.0)', 'n_trials': '(0)'}), '(net, tstop=25.0, n_trials=0)\n', (4882, 4911), False, 'from hnn_core.dipole import Dipole, simulate_dipole, _rmse\n'), ((4920, 4988), 'pytest.raises', 'pytest.raises', (['TypeError'], {'match': '"""record_vsoma must be bool, got int"""'}), "(TypeError, match='record_vsoma must be bool, got int')\n", (4933, 4988), False, 'import pytest\n'), ((4998, 5058), 'hnn_core.dipole.simulate_dipole', 'simulate_dipole', (['net'], {'tstop': '(25.0)', 'n_trials': '(1)', 'record_vsoma': '(0)'}), '(net, tstop=25.0, n_trials=1, record_vsoma=0)\n', (5013, 5058), False, 'from hnn_core.dipole import Dipole, simulate_dipole, _rmse\n'), ((5067, 5135), 'pytest.raises', 'pytest.raises', (['TypeError'], {'match': '"""record_isoma must be bool, got int"""'}), "(TypeError, match='record_isoma must be bool, got int')\n", (5080, 5135), False, 'import pytest\n'), ((5145, 5230), 'hnn_core.dipole.simulate_dipole', 'simulate_dipole', (['net'], {'tstop': '(25.0)', 'n_trials': '(1)', 'record_vsoma': '(False)', 'record_isoma': '(0)'}), '(net, tstop=25.0, n_trials=1, record_vsoma=False, record_isoma=0\n )\n', (5160, 5230), False, 'from hnn_core.dipole import Dipole, simulate_dipole, _rmse\n'), ((5326, 5370), 'hnn_core.dipole.simulate_dipole', 'simulate_dipole', (['net'], {'tstop': '(25.0)', 'n_trials': '(1)'}), '(net, tstop=25.0, n_trials=1)\n', (5341, 5370), False, 'from hnn_core.dipole import Dipole, simulate_dipole, _rmse\n'), ((5600, 5649), 'pytest.warns', 'pytest.warns', (['UserWarning'], {'match': '"""No connections"""'}), "(UserWarning, match='No connections')\n", (5612, 5649), False, 'import pytest\n'), ((5665, 5680), 'hnn_core.Network', 'Network', (['params'], {}), '(params)\n', (5672, 5680), False, 'from hnn_core import Network, jones_2009_model\n'), ((5738, 5781), 'hnn_core.dipole.simulate_dipole', 'simulate_dipole', (['net'], {'tstop': '(0.1)', 'n_trials': '(1)'}), '(net, tstop=0.1, n_trials=1)\n', (5753, 5781), False, 'from hnn_core.dipole import Dipole, simulate_dipole, _rmse\n'), ((8464, 8505), 'os.path.exists', 'op.exists', (['"""yes_trial_S1_ERP_all_avg.txt"""'], {}), "('yes_trial_S1_ERP_all_avg.txt')\n", (8473, 8505), True, 'import os.path as op\n'), ((8515, 8568), 'urllib.request.urlretrieve', 'urlretrieve', (['data_url', '"""yes_trial_S1_ERP_all_avg.txt"""'], {}), "(data_url, 'yes_trial_S1_ERP_all_avg.txt')\n", (8526, 8568), False, 'from urllib.request import urlretrieve\n'), ((8776, 8805), 'os.path.dirname', 'op.dirname', (['hnn_core.__file__'], {}), '(hnn_core.__file__)\n', (8786, 8805), True, 'import os.path as op\n'), ((8197, 8218), 'numpy.array', 'np.array', (['event_times'], {}), '(event_times)\n', (8205, 8218), True, 'import numpy as np\n'), ((8220, 8237), 'numpy.array', 'np.array', (['net_ets'], {}), '(net_ets)\n', (8228, 8237), True, 'import numpy as np\n')]
|
# USAGE
# python extract_embeddings.py --dataset dataset --embeddings output/embeddings.pickle \
# --detector face_detection_model --embedding-model openface_nn4.small2.v1.t7
# import the necessary packages
from imutils.face_utils import FaceAligner
from imutils import paths
import numpy as np
import argparse
import imutils
import pickle
import cv2
import os
import dlib
from PIL import Image
from yolo import YOLO, detect_video
from yolo3.utils import letterbox_image
from keras import backend as K
def detect_image(self, image):
if self.model_image_size != (None, None):
assert self.model_image_size[0]%32 == 0, 'Multiples of 32 required'
assert self.model_image_size[1]%32 == 0, 'Multiples of 32 required'
boxed_image = letterbox_image(image, tuple(reversed(self.model_image_size)))
else:
new_image_size = (image.width - (image.width % 32),
image.height - (image.height % 32))
boxed_image = letterbox_image(image, new_image_size)
image_data = np.array(boxed_image, dtype='float32')
#print(image_data.shape)
image_data /= 255.
image_data = np.expand_dims(image_data, 0) # Add batch dimension.
out_boxes, out_scores, out_classes = self.sess.run(
[self.boxes, self.scores, self.classes],
feed_dict={
self.yolo_model.input: image_data,
self.input_image_shape: [image.size[1], image.size[0]],
K.learning_phase(): 0
})
print('Found {} boxes for {}'.format(len(out_boxes), 'img'))
return out_boxes, out_scores, out_classes
# construct the argument parser and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-i", "--dataset", required=True,
help="path to input directory of faces + images")
ap.add_argument("-e", "--embeddings", required=True,
help="path to output serialized db of facial embeddings")
ap.add_argument("-m", "--embedding-model", required=True,
help="path to OpenCV's deep learning face embedding model")
ap.add_argument("-p", "--shape-predictor", required=True,
help="path to facial landmark predictor")
args = vars(ap.parse_args())
# load our serialized face detector from disk
print("[INFO] loading face detector...")
predictor = dlib.shape_predictor(args["shape_predictor"])
#detector = dlib.get_frontal_face_detector()
detector = YOLO()
# load our serialized face embedding model from disk
print("[INFO] loading face recognizer...")
embedder = cv2.dnn.readNetFromTorch(args["embedding_model"])
# grab the paths to the input images in our dataset
print("[INFO] quantifying faces...")
imagePaths = list(paths.list_images(args["dataset"]))
# initialize our lists of extracted facial embeddings and
# corresponding people names
knownEmbeddings = []
knownNames = []
# initialize the total number of faces processed
total = 0
# loop over the image paths
for (i, imagePath) in enumerate(imagePaths):
# extract the person name from the image path
print("[INFO] processing image {}/{}".format(i + 1,
len(imagePaths)))
name = imagePath.split(os.path.sep)[-2]
# load the image, resize it to have a width of 800 pixels (while
# maintaining the aspect ratio), and then grab the image
# dimensions
image = cv2.imread(imagePath)
image = imutils.resize(image, width=800)
#try to rise resolution
#gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
#blurred = cv2.GaussianBlur(gray, (5, 5), 0)
#image = blurred
#clahe = cv2.createCLAHE(clipLimit=4.0, tileGridSize=(8,8))
#image = clahe.apply(image)
#image = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
(h, w) = image.shape[:2]
# we're making the assumption that each image has only ONE
# face, so find the bounding box with the largest probability
#align_faces
fa = FaceAligner(predictor, desiredFaceWidth=256)
#gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
#rects = detector(gray, 2)
rects = []
out_boxes, out_scores, out_classes = detect_image(detector, Image.fromarray(image))
for i, c in reversed(list(enumerate(out_classes))):
(x, y, x1, y1) = out_boxes[i]
w = abs(x - x1)
h = abs(y - y1)
startX = int(min(x1, x))
endX = startX + w
startY = int(min(y1, y))
endY = startY + h
left, right, bottom, top = startX, endX, endY, startY
rect = dlib.rectangle(int(top), int(left), int(bottom) , int(right))
rects.append(rect)
for rect in rects:
faceAligned = fa.align(image, gray, rect)
print(faceAligned)
cv2.imshow("Aligned", np.asarray(faceAligned))
cv2.waitKey(0)
face = faceAligned
(fH, fW) = face.shape[:2]
# ensure the face width and height are sufficiently large
if fW < 20 or fH < 20:
continue
# construct a blob for the face ROI, then pass the blob
# through our face embedding model to obtain the 128-d
# quantification of the face
faceBlob = cv2.dnn.blobFromImage(face, 1.0 / 255,
(96, 96), (0, 0, 0), swapRB=True, crop=False)
embedder.setInput(faceBlob)
vec = embedder.forward()
# add the name of the person + corresponding face
# embedding to their respective lists
knownNames.append(name)
knownEmbeddings.append(vec.flatten())
total += 1
# dump the facial embeddings + names to disk
print("[INFO] serializing {} encodings...".format(total))
data = {"embeddings": knownEmbeddings, "names": knownNames}
f = open(args["embeddings"], "wb")
f.write(pickle.dumps(data))
f.close()
|
[
"cv2.dnn.blobFromImage",
"PIL.Image.fromarray",
"cv2.dnn.readNetFromTorch",
"argparse.ArgumentParser",
"yolo.YOLO",
"pickle.dumps",
"keras.backend.learning_phase",
"numpy.asarray",
"dlib.shape_predictor",
"numpy.array",
"imutils.resize",
"cv2.waitKey",
"imutils.paths.list_images",
"numpy.expand_dims",
"cv2.cvtColor",
"yolo3.utils.letterbox_image",
"cv2.imread",
"imutils.face_utils.FaceAligner"
] |
[((1650, 1675), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (1673, 1675), False, 'import argparse\n'), ((2238, 2283), 'dlib.shape_predictor', 'dlib.shape_predictor', (["args['shape_predictor']"], {}), "(args['shape_predictor'])\n", (2258, 2283), False, 'import dlib\n'), ((2340, 2346), 'yolo.YOLO', 'YOLO', ([], {}), '()\n', (2344, 2346), False, 'from yolo import YOLO, detect_video\n'), ((2455, 2504), 'cv2.dnn.readNetFromTorch', 'cv2.dnn.readNetFromTorch', (["args['embedding_model']"], {}), "(args['embedding_model'])\n", (2479, 2504), False, 'import cv2\n'), ((1028, 1066), 'numpy.array', 'np.array', (['boxed_image'], {'dtype': '"""float32"""'}), "(boxed_image, dtype='float32')\n", (1036, 1066), True, 'import numpy as np\n'), ((1137, 1166), 'numpy.expand_dims', 'np.expand_dims', (['image_data', '(0)'], {}), '(image_data, 0)\n', (1151, 1166), True, 'import numpy as np\n'), ((2613, 2647), 'imutils.paths.list_images', 'paths.list_images', (["args['dataset']"], {}), "(args['dataset'])\n", (2630, 2647), False, 'from imutils import paths\n'), ((3217, 3238), 'cv2.imread', 'cv2.imread', (['imagePath'], {}), '(imagePath)\n', (3227, 3238), False, 'import cv2\n'), ((3248, 3280), 'imutils.resize', 'imutils.resize', (['image'], {'width': '(800)'}), '(image, width=800)\n', (3262, 3280), False, 'import imutils\n'), ((3572, 3611), 'cv2.cvtColor', 'cv2.cvtColor', (['image', 'cv2.COLOR_BGR2GRAY'], {}), '(image, cv2.COLOR_BGR2GRAY)\n', (3584, 3611), False, 'import cv2\n'), ((3790, 3834), 'imutils.face_utils.FaceAligner', 'FaceAligner', (['predictor'], {'desiredFaceWidth': '(256)'}), '(predictor, desiredFaceWidth=256)\n', (3801, 3834), False, 'from imutils.face_utils import FaceAligner\n'), ((4846, 4934), 'cv2.dnn.blobFromImage', 'cv2.dnn.blobFromImage', (['face', '(1.0 / 255)', '(96, 96)', '(0, 0, 0)'], {'swapRB': '(True)', 'crop': '(False)'}), '(face, 1.0 / 255, (96, 96), (0, 0, 0), swapRB=True,\n crop=False)\n', (4867, 4934), False, 'import cv2\n'), ((5362, 5380), 'pickle.dumps', 'pickle.dumps', (['data'], {}), '(data)\n', (5374, 5380), False, 'import pickle\n'), ((972, 1010), 'yolo3.utils.letterbox_image', 'letterbox_image', (['image', 'new_image_size'], {}), '(image, new_image_size)\n', (987, 1010), False, 'from yolo3.utils import letterbox_image\n'), ((3990, 4012), 'PIL.Image.fromarray', 'Image.fromarray', (['image'], {}), '(image)\n', (4005, 4012), False, 'from PIL import Image\n'), ((4526, 4540), 'cv2.waitKey', 'cv2.waitKey', (['(0)'], {}), '(0)\n', (4537, 4540), False, 'import cv2\n'), ((4499, 4522), 'numpy.asarray', 'np.asarray', (['faceAligned'], {}), '(faceAligned)\n', (4509, 4522), True, 'import numpy as np\n'), ((1442, 1460), 'keras.backend.learning_phase', 'K.learning_phase', ([], {}), '()\n', (1458, 1460), True, 'from keras import backend as K\n')]
|
#!/usr/bin/env python
""" HIAS AI Model Data Augmentation Class.
Provides data augmentation methods.
MIT License
Copyright (c) 2021 Asociación de Investigacion en Inteligencia Artificial
Para la Leucemia <NAME>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Contributors:
- <NAME> - First version - 2021-5-2
"""
import cv2
import random
import numpy as np
from numpy.random import seed
from scipy import ndimage
from skimage import transform as tm
class augmentation():
""" HIAS AI Model Data Augmentation Class
Provides data augmentation methods.
"""
def __init__(self, helpers):
""" Initializes the class. """
self.helpers = helpers
self.seed = self.helpers.confs["data"]["seed"]
seed(self.seed)
self.helpers.logger.info(
"Augmentation class initialization complete.")
def grayscale(self, data):
""" Creates a grayscale copy. """
gray = cv2.cvtColor(data, cv2.COLOR_BGR2GRAY)
return np.dstack([gray, gray, gray]).astype(np.float32)/255.
def equalize_hist(self, data):
""" Creates a histogram equalized copy. """
img_to_yuv = cv2.cvtColor(data, cv2.COLOR_BGR2YUV)
img_to_yuv[:, :, 0] = cv2.equalizeHist(img_to_yuv[:, :, 0])
hist_equalization_result = cv2.cvtColor(img_to_yuv, cv2.COLOR_YUV2BGR)
return hist_equalization_result.astype(np.float32)/255.
def reflection(self, data):
""" Creates a reflected copy. """
return cv2.flip(data, 0).astype(np.float32)/255., cv2.flip(data, 1).astype(np.float32)/255.
def gaussian(self, data):
""" Creates a gaussian blurred copy. """
return ndimage.gaussian_filter(
data, sigma=5.11).astype(np.float32)/255.
def translate(self, data):
""" Creates transformed copy. """
cols, rows, chs = data.shape
return cv2.warpAffine(
data, np.float32([[1, 0, 84], [0, 1, 56]]), (rows, cols),
borderMode=cv2.BORDER_CONSTANT,
borderValue=(144, 159, 162)).astype(np.float32)/255.
def rotation(self, data, label, tdata, tlabels):
""" Creates rotated copies. """
cols, rows, chs = data.shape
for i in range(0, self.helpers.confs["data"]["rotations"]):
# Seed needs to be set each time randint is called
random.seed(self.seed)
rand_deg = random.randint(-180, 180)
matrix = cv2.getRotationMatrix2D(
(cols/2, rows/2), rand_deg, 0.70)
rotated = cv2.warpAffine(
data, matrix, (rows, cols),
borderMode=cv2.BORDER_CONSTANT,
borderValue=(144, 159, 162))
rotated = rotated.astype(np.float32)/255.
tdata.append(rotated)
tlabels.append(label)
return tdata, tlabels
def shear(self, data):
""" Creates a histogram equalized copy. """
at = tm.AffineTransform(shear=0.5)
return tm.warp(data, inverse_map=at)
|
[
"numpy.dstack",
"cv2.warpAffine",
"cv2.flip",
"numpy.float32",
"skimage.transform.AffineTransform",
"skimage.transform.warp",
"random.seed",
"cv2.equalizeHist",
"numpy.random.seed",
"cv2.cvtColor",
"scipy.ndimage.gaussian_filter",
"cv2.getRotationMatrix2D",
"random.randint"
] |
[((1721, 1736), 'numpy.random.seed', 'seed', (['self.seed'], {}), '(self.seed)\n', (1725, 1736), False, 'from numpy.random import seed\n'), ((1921, 1959), 'cv2.cvtColor', 'cv2.cvtColor', (['data', 'cv2.COLOR_BGR2GRAY'], {}), '(data, cv2.COLOR_BGR2GRAY)\n', (1933, 1959), False, 'import cv2\n'), ((2139, 2176), 'cv2.cvtColor', 'cv2.cvtColor', (['data', 'cv2.COLOR_BGR2YUV'], {}), '(data, cv2.COLOR_BGR2YUV)\n', (2151, 2176), False, 'import cv2\n'), ((2207, 2244), 'cv2.equalizeHist', 'cv2.equalizeHist', (['img_to_yuv[:, :, 0]'], {}), '(img_to_yuv[:, :, 0])\n', (2223, 2244), False, 'import cv2\n'), ((2280, 2323), 'cv2.cvtColor', 'cv2.cvtColor', (['img_to_yuv', 'cv2.COLOR_YUV2BGR'], {}), '(img_to_yuv, cv2.COLOR_YUV2BGR)\n', (2292, 2323), False, 'import cv2\n'), ((3930, 3959), 'skimage.transform.AffineTransform', 'tm.AffineTransform', ([], {'shear': '(0.5)'}), '(shear=0.5)\n', (3948, 3959), True, 'from skimage import transform as tm\n'), ((3975, 4004), 'skimage.transform.warp', 'tm.warp', (['data'], {'inverse_map': 'at'}), '(data, inverse_map=at)\n', (3982, 4004), True, 'from skimage import transform as tm\n'), ((3338, 3360), 'random.seed', 'random.seed', (['self.seed'], {}), '(self.seed)\n', (3349, 3360), False, 'import random\n'), ((3384, 3409), 'random.randint', 'random.randint', (['(-180)', '(180)'], {}), '(-180, 180)\n', (3398, 3409), False, 'import random\n'), ((3431, 3491), 'cv2.getRotationMatrix2D', 'cv2.getRotationMatrix2D', (['(cols / 2, rows / 2)', 'rand_deg', '(0.7)'], {}), '((cols / 2, rows / 2), rand_deg, 0.7)\n', (3454, 3491), False, 'import cv2\n'), ((3528, 3635), 'cv2.warpAffine', 'cv2.warpAffine', (['data', 'matrix', '(rows, cols)'], {'borderMode': 'cv2.BORDER_CONSTANT', 'borderValue': '(144, 159, 162)'}), '(data, matrix, (rows, cols), borderMode=cv2.BORDER_CONSTANT,\n borderValue=(144, 159, 162))\n', (3542, 3635), False, 'import cv2\n'), ((1975, 2004), 'numpy.dstack', 'np.dstack', (['[gray, gray, gray]'], {}), '([gray, gray, gray])\n', (1984, 2004), True, 'import numpy as np\n'), ((2660, 2701), 'scipy.ndimage.gaussian_filter', 'ndimage.gaussian_filter', (['data'], {'sigma': '(5.11)'}), '(data, sigma=5.11)\n', (2683, 2701), False, 'from scipy import ndimage\n'), ((2479, 2496), 'cv2.flip', 'cv2.flip', (['data', '(0)'], {}), '(data, 0)\n', (2487, 2496), False, 'import cv2\n'), ((2522, 2539), 'cv2.flip', 'cv2.flip', (['data', '(1)'], {}), '(data, 1)\n', (2530, 2539), False, 'import cv2\n'), ((2901, 2937), 'numpy.float32', 'np.float32', (['[[1, 0, 84], [0, 1, 56]]'], {}), '([[1, 0, 84], [0, 1, 56]])\n', (2911, 2937), True, 'import numpy as np\n')]
|
# Program 8_plot_data_perstation.py written by <NAME> (<EMAIL>)
file_name= '8_plot_data_perstation.py'
# Uses receiver functions computed to produce a nice graph for every directory in DATARF
import obspy
from obspy import read
from obspy.core import Stream
from obspy.core import trace
import matplotlib.pyplot as plt
import os.path
import time
import glob
import shutil
import numpy as np
from obspy import UTCDateTime
import receiver_function as rf
direc = 'DataRF'
flag = 'SV'
filt = 'jgf1'
stadirs = glob.glob(direc+'/*')
for stadir in stadirs:
print(stadir)
with open(stadir+'/selected_RFs_jgf1.dat','r') as f:
goodrfs= f.read().replace('\n', '')
# loop through events
stalist=glob.glob(stadir+'/*.PICKLE')
print(stalist)
c=0
# Loop through data
if(len(stalist)>0):
for i in range(len(stalist)): #range(cat.count()):
print(stalist[i])
seis=read(stalist[i],format='PICKLE')
distdg=seis[0].stats['dist']
if stalist[i] in goodrfs:
good=True
print('YAY',seis[0].stats['event'].magnitudes[0].mag)
else:
good=False
print('NO',seis[0].stats['event'].magnitudes[0].mag)
tshift=UTCDateTime(seis[0].stats['starttime'])-seis[0].stats['event'].origins[0].time
#Ptime=Ptime
plt.subplot(1,3,1)
vertical = seis.select(channel='BHZ')[0]
vertical.filter('bandpass', freqmin=0.01,freqmax=.1, corners=2, zerophase=True)
windowed=vertical[np.where(vertical.times()>seis[0].stats.traveltimes['P']-100) and np.where(vertical.times()<seis[0].stats.traveltimes['P']+100)]
norm=np.max(np.abs(windowed))
if good:
plt.plot(vertical.times()-seis[0].stats.traveltimes['P'], vertical.data/norm+np.round(distdg),'k')
else:
plt.plot(vertical.times()-seis[0].stats.traveltimes['P'], vertical.data/norm+np.round(distdg),'r')
#plt.plot(seis[0].stats.traveltimes['P'],np.round(distdg),'.b')
#plt.plot(seis[0].stats.traveltimes['S'],np.round(distdg),'.g')
plt.xlim([-25,150])
plt.ylim([30,92])
plt.subplot(1,3,2)
radial = seis.select(channel='BHR')[0]
radial.filter('bandpass', freqmin=0.01,freqmax=.1, corners=2, zerophase=True)
windowed=vertical[np.where(radial.times()>seis[0].stats.traveltimes['P']-100) and np.where(radial.times()<seis[0].stats.traveltimes['P']+100)]
norm=np.max(np.abs(windowed))
if good:
plt.plot(radial.times()-seis[0].stats.traveltimes['P'], radial.data/norm+np.round(distdg),'k')
else:
plt.plot(radial.times()-seis[0].stats.traveltimes['P'], radial.data/norm+np.round(distdg),'r')
plt.xlim([-25,150])
plt.plot(seis[0].stats.traveltimes['P'],np.round(distdg),'.b')
plt.plot(seis[0].stats.traveltimes['S'],np.round(distdg),'.g')
plt.ylim([30,92])
plt.subplot(1,3,3)
RF=getattr(seis[0],filt)['iterativedeconvolution']
time=getattr(seis[0],filt)['time']
if good:
plt.plot(time, RF/np.max(np.abs(RF))+np.round(distdg),'k')
else:
plt.plot(time, RF/np.max(np.abs(RF))+np.round(distdg),'r')
plt.subplot(1,3,1)
plt.title('vertical')
plt.ylabel('distance')
plt.xlabel('time')
plt.subplot(1,3,2)
plt.title('radial')
plt.ylabel('distance')
plt.xlabel('time')
plt.subplot(1,3,3)
plt.title('receiver functions')
plt.ylabel('distance')
plt.xlabel('time')
#plt.xlim([-150,1000])
plt.show()
|
[
"obspy.read",
"numpy.abs",
"matplotlib.pyplot.ylabel",
"numpy.round",
"matplotlib.pyplot.xlabel",
"obspy.UTCDateTime",
"matplotlib.pyplot.title",
"matplotlib.pyplot.xlim",
"matplotlib.pyplot.ylim",
"matplotlib.pyplot.subplot",
"glob.glob",
"matplotlib.pyplot.show"
] |
[((509, 532), 'glob.glob', 'glob.glob', (["(direc + '/*')"], {}), "(direc + '/*')\n", (518, 532), False, 'import glob\n'), ((713, 744), 'glob.glob', 'glob.glob', (["(stadir + '/*.PICKLE')"], {}), "(stadir + '/*.PICKLE')\n", (722, 744), False, 'import glob\n'), ((3703, 3723), 'matplotlib.pyplot.subplot', 'plt.subplot', (['(1)', '(3)', '(1)'], {}), '(1, 3, 1)\n', (3714, 3723), True, 'import matplotlib.pyplot as plt\n'), ((3730, 3751), 'matplotlib.pyplot.title', 'plt.title', (['"""vertical"""'], {}), "('vertical')\n", (3739, 3751), True, 'import matplotlib.pyplot as plt\n'), ((3760, 3782), 'matplotlib.pyplot.ylabel', 'plt.ylabel', (['"""distance"""'], {}), "('distance')\n", (3770, 3782), True, 'import matplotlib.pyplot as plt\n'), ((3791, 3809), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""time"""'], {}), "('time')\n", (3801, 3809), True, 'import matplotlib.pyplot as plt\n'), ((3818, 3838), 'matplotlib.pyplot.subplot', 'plt.subplot', (['(1)', '(3)', '(2)'], {}), '(1, 3, 2)\n', (3829, 3838), True, 'import matplotlib.pyplot as plt\n'), ((3845, 3864), 'matplotlib.pyplot.title', 'plt.title', (['"""radial"""'], {}), "('radial')\n", (3854, 3864), True, 'import matplotlib.pyplot as plt\n'), ((3873, 3895), 'matplotlib.pyplot.ylabel', 'plt.ylabel', (['"""distance"""'], {}), "('distance')\n", (3883, 3895), True, 'import matplotlib.pyplot as plt\n'), ((3904, 3922), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""time"""'], {}), "('time')\n", (3914, 3922), True, 'import matplotlib.pyplot as plt\n'), ((3931, 3951), 'matplotlib.pyplot.subplot', 'plt.subplot', (['(1)', '(3)', '(3)'], {}), '(1, 3, 3)\n', (3942, 3951), True, 'import matplotlib.pyplot as plt\n'), ((3958, 3989), 'matplotlib.pyplot.title', 'plt.title', (['"""receiver functions"""'], {}), "('receiver functions')\n", (3967, 3989), True, 'import matplotlib.pyplot as plt\n'), ((3998, 4020), 'matplotlib.pyplot.ylabel', 'plt.ylabel', (['"""distance"""'], {}), "('distance')\n", (4008, 4020), True, 'import matplotlib.pyplot as plt\n'), ((4029, 4047), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""time"""'], {}), "('time')\n", (4039, 4047), True, 'import matplotlib.pyplot as plt\n'), ((4095, 4105), 'matplotlib.pyplot.show', 'plt.show', ([], {}), '()\n', (4103, 4105), True, 'import matplotlib.pyplot as plt\n'), ((932, 965), 'obspy.read', 'read', (['stalist[i]'], {'format': '"""PICKLE"""'}), "(stalist[i], format='PICKLE')\n", (936, 965), False, 'from obspy import read\n'), ((1436, 1456), 'matplotlib.pyplot.subplot', 'plt.subplot', (['(1)', '(3)', '(1)'], {}), '(1, 3, 1)\n', (1447, 1456), True, 'import matplotlib.pyplot as plt\n'), ((2298, 2318), 'matplotlib.pyplot.xlim', 'plt.xlim', (['[-25, 150]'], {}), '([-25, 150])\n', (2306, 2318), True, 'import matplotlib.pyplot as plt\n'), ((2334, 2352), 'matplotlib.pyplot.ylim', 'plt.ylim', (['[30, 92]'], {}), '([30, 92])\n', (2342, 2352), True, 'import matplotlib.pyplot as plt\n'), ((2368, 2388), 'matplotlib.pyplot.subplot', 'plt.subplot', (['(1)', '(3)', '(2)'], {}), '(1, 3, 2)\n', (2379, 2388), True, 'import matplotlib.pyplot as plt\n'), ((3035, 3055), 'matplotlib.pyplot.xlim', 'plt.xlim', (['[-25, 150]'], {}), '([-25, 150])\n', (3043, 3055), True, 'import matplotlib.pyplot as plt\n'), ((3247, 3265), 'matplotlib.pyplot.ylim', 'plt.ylim', (['[30, 92]'], {}), '([30, 92])\n', (3255, 3265), True, 'import matplotlib.pyplot as plt\n'), ((3294, 3314), 'matplotlib.pyplot.subplot', 'plt.subplot', (['(1)', '(3)', '(3)'], {}), '(1, 3, 3)\n', (3305, 3314), True, 'import matplotlib.pyplot as plt\n'), ((1309, 1348), 'obspy.UTCDateTime', 'UTCDateTime', (["seis[0].stats['starttime']"], {}), "(seis[0].stats['starttime'])\n", (1320, 1348), False, 'from obspy import UTCDateTime\n'), ((1799, 1815), 'numpy.abs', 'np.abs', (['windowed'], {}), '(windowed)\n', (1805, 1815), True, 'import numpy as np\n'), ((2724, 2740), 'numpy.abs', 'np.abs', (['windowed'], {}), '(windowed)\n', (2730, 2740), True, 'import numpy as np\n'), ((3129, 3145), 'numpy.round', 'np.round', (['distdg'], {}), '(distdg)\n', (3137, 3145), True, 'import numpy as np\n'), ((3208, 3224), 'numpy.round', 'np.round', (['distdg'], {}), '(distdg)\n', (3216, 3224), True, 'import numpy as np\n'), ((1939, 1955), 'numpy.round', 'np.round', (['distdg'], {}), '(distdg)\n', (1947, 1955), True, 'import numpy as np\n'), ((2080, 2096), 'numpy.round', 'np.round', (['distdg'], {}), '(distdg)\n', (2088, 2096), True, 'import numpy as np\n'), ((2860, 2876), 'numpy.round', 'np.round', (['distdg'], {}), '(distdg)\n', (2868, 2876), True, 'import numpy as np\n'), ((2997, 3013), 'numpy.round', 'np.round', (['distdg'], {}), '(distdg)\n', (3005, 3013), True, 'import numpy as np\n'), ((3513, 3529), 'numpy.round', 'np.round', (['distdg'], {}), '(distdg)\n', (3521, 3529), True, 'import numpy as np\n'), ((3614, 3630), 'numpy.round', 'np.round', (['distdg'], {}), '(distdg)\n', (3622, 3630), True, 'import numpy as np\n'), ((3501, 3511), 'numpy.abs', 'np.abs', (['RF'], {}), '(RF)\n', (3507, 3511), True, 'import numpy as np\n'), ((3602, 3612), 'numpy.abs', 'np.abs', (['RF'], {}), '(RF)\n', (3608, 3612), True, 'import numpy as np\n')]
|
import tensorflow as tf
from netensorflow.ann.ANN import ANN
from netensorflow.ann.macro_layer.MacroLayer import MacroLayer
from netensorflow.ann.macro_layer.layer_structure.InputLayerStructure import InputLayerStructure
from netensorflow.ann.macro_layer.layer_structure.LayerStructure import LayerStructure, LayerType
from netensorflow.ann.macro_layer.layer_structure.layers.FullConnected import FullConnected
from netensorflow.ann.macro_layer.layer_structure.layers.FullConnectedWithSoftmaxLayer import FullConnectedWithSoftmaxLayer
'''
ann Creation and simple usage, the goal of this code is simply run the most simpler artificial neural network
'''
def main():
# tensorflow
tf_sess = tf.Session()
# Layers:
input_dim = [None, 3]
hidden_layer = FullConnected(inputs_amount=20)
out_layer = FullConnectedWithSoftmaxLayer(inputs_amount=10)
# Layer Structures
input_layer_structure = InputLayerStructure(input_dim)
hidden_layer_structure = LayerStructure('Hidden', layer_type=LayerType.ONE_DIMENSION, layers=[hidden_layer])
output_layer_structure = LayerStructure('Output', layer_type=LayerType.ONE_DIMENSION,layers=[out_layer])
# Macro Layer
macro_layers = MacroLayer(layers_structure=[input_layer_structure, hidden_layer_structure, output_layer_structure])
# ann
ann = ANN(macro_layers=macro_layers, tf_session=tf_sess, base_folder='./tensorboard_logs/')
ann.connect_and_initialize()
# Execute
for it in range(100):
import numpy as np
input_tensor_value = [np.random.uniform(0.0, 10.0, 3)]
print(ann.run(global_iteration=it, input_tensor_value=input_tensor_value))
if __name__ == '__main__':
main()
|
[
"netensorflow.ann.macro_layer.layer_structure.InputLayerStructure.InputLayerStructure",
"netensorflow.ann.macro_layer.layer_structure.layers.FullConnectedWithSoftmaxLayer.FullConnectedWithSoftmaxLayer",
"tensorflow.Session",
"netensorflow.ann.macro_layer.layer_structure.layers.FullConnected.FullConnected",
"netensorflow.ann.macro_layer.MacroLayer.MacroLayer",
"netensorflow.ann.ANN.ANN",
"numpy.random.uniform",
"netensorflow.ann.macro_layer.layer_structure.LayerStructure.LayerStructure"
] |
[((706, 718), 'tensorflow.Session', 'tf.Session', ([], {}), '()\n', (716, 718), True, 'import tensorflow as tf\n'), ((779, 810), 'netensorflow.ann.macro_layer.layer_structure.layers.FullConnected.FullConnected', 'FullConnected', ([], {'inputs_amount': '(20)'}), '(inputs_amount=20)\n', (792, 810), False, 'from netensorflow.ann.macro_layer.layer_structure.layers.FullConnected import FullConnected\n'), ((827, 874), 'netensorflow.ann.macro_layer.layer_structure.layers.FullConnectedWithSoftmaxLayer.FullConnectedWithSoftmaxLayer', 'FullConnectedWithSoftmaxLayer', ([], {'inputs_amount': '(10)'}), '(inputs_amount=10)\n', (856, 874), False, 'from netensorflow.ann.macro_layer.layer_structure.layers.FullConnectedWithSoftmaxLayer import FullConnectedWithSoftmaxLayer\n'), ((927, 957), 'netensorflow.ann.macro_layer.layer_structure.InputLayerStructure.InputLayerStructure', 'InputLayerStructure', (['input_dim'], {}), '(input_dim)\n', (946, 957), False, 'from netensorflow.ann.macro_layer.layer_structure.InputLayerStructure import InputLayerStructure\n'), ((987, 1075), 'netensorflow.ann.macro_layer.layer_structure.LayerStructure.LayerStructure', 'LayerStructure', (['"""Hidden"""'], {'layer_type': 'LayerType.ONE_DIMENSION', 'layers': '[hidden_layer]'}), "('Hidden', layer_type=LayerType.ONE_DIMENSION, layers=[\n hidden_layer])\n", (1001, 1075), False, 'from netensorflow.ann.macro_layer.layer_structure.LayerStructure import LayerStructure, LayerType\n'), ((1100, 1185), 'netensorflow.ann.macro_layer.layer_structure.LayerStructure.LayerStructure', 'LayerStructure', (['"""Output"""'], {'layer_type': 'LayerType.ONE_DIMENSION', 'layers': '[out_layer]'}), "('Output', layer_type=LayerType.ONE_DIMENSION, layers=[out_layer]\n )\n", (1114, 1185), False, 'from netensorflow.ann.macro_layer.layer_structure.LayerStructure import LayerStructure, LayerType\n'), ((1218, 1322), 'netensorflow.ann.macro_layer.MacroLayer.MacroLayer', 'MacroLayer', ([], {'layers_structure': '[input_layer_structure, hidden_layer_structure, output_layer_structure]'}), '(layers_structure=[input_layer_structure, hidden_layer_structure,\n output_layer_structure])\n', (1228, 1322), False, 'from netensorflow.ann.macro_layer.MacroLayer import MacroLayer\n'), ((1340, 1430), 'netensorflow.ann.ANN.ANN', 'ANN', ([], {'macro_layers': 'macro_layers', 'tf_session': 'tf_sess', 'base_folder': '"""./tensorboard_logs/"""'}), "(macro_layers=macro_layers, tf_session=tf_sess, base_folder=\n './tensorboard_logs/')\n", (1343, 1430), False, 'from netensorflow.ann.ANN import ANN\n'), ((1557, 1588), 'numpy.random.uniform', 'np.random.uniform', (['(0.0)', '(10.0)', '(3)'], {}), '(0.0, 10.0, 3)\n', (1574, 1588), True, 'import numpy as np\n')]
|
# import modules
import numpy as np
import argparse
import cv2
# construct the argument parse and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-b", "--buffer", type=int, default=64,
help="max buffer size")
args = vars(ap.parse_args())
# define the lower and upper boundaries of the colors in the HSV color space
lower = {'red': (166, 84, 141), 'green': (66, 122, 129), 'blue': (97, 100, 117), 'yellow': (23, 59, 119), 'orange': (0, 50, 80)} # assign new item lower['blue'] = (93, 10, 0)
upper = {'red': (186, 255, 255), 'green': (86, 255, 255), 'blue': (117, 255, 255), 'yellow': (54, 255, 255), 'orange': (20, 255, 255)}
# define standard colors for circle around the object
colors = {'red': (0, 0, 255), 'green': (0, 255, 0), 'blue': (255, 0, 0), 'yellow': (0, 255, 217), 'orange': (0, 140, 255)}
camera = cv2.VideoCapture(0 + cv2.CAP_DSHOW)
# keep looping
while True:
# grab the current frame
(grabbed, frame) = camera.read()
# resize the frame, blur it, and convert it to the HSV
# color space
frame = cv2.resize(frame, (640, 480))
blurred = cv2.GaussianBlur(frame, (11, 11), 0)
hsv = cv2.cvtColor(blurred, cv2.COLOR_BGR2HSV)
# for each color in dictionary check object in frame
for key, value in upper.items():
# construct a mask for the color from dictionary`1, then perform
# a series of dilations and erosions to remove any small
# blobs left in the mask
kernel = np.ones((9, 9), np.uint8)
mask = cv2.inRange(hsv, lower[key], upper[key])
mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel)
mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
# find contours in the mask and initialize the current
# (x, y) center of the ball
cnts = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)[-2]
center = None
# only proceed if at least one contour was found
if len(cnts) > 0:
# find the largest contour in the mask, then use
# it to compute the minimum enclosing circle and
# centroid
c = max(cnts, key=cv2.contourArea)
((x, y), radius) = cv2.minEnclosingCircle(c)
M = cv2.moments(c)
center = (int(M["m10"] / M["m00"]), int(M["m01"] / M["m00"]))
# only proceed if the radius meets a minimum size. Correct this value for your obect's size
if radius > 0.5:
# draw the circle and centroid on the frame,
# then update the list of tracked points
cv2.circle(frame, (int(x), int(y)), int(radius), colors[key], 2)
cv2.putText(frame, key, (int(x - radius), int(y - radius)), cv2.FONT_HERSHEY_SIMPLEX, 0.6, colors[key], 2)
# show the frame to our screen
cv2.imshow("Frame", frame)
key = cv2.waitKey(1) & 0xFF
# if the 'q' key is pressed, stop the loop
if key == ord("q"):
break
# cleanup the camera and close any open windows
camera.release()
cv2.destroyAllWindows()
|
[
"numpy.ones",
"argparse.ArgumentParser",
"cv2.inRange",
"cv2.minEnclosingCircle",
"cv2.imshow",
"cv2.morphologyEx",
"cv2.destroyAllWindows",
"cv2.VideoCapture",
"cv2.cvtColor",
"cv2.moments",
"cv2.resize",
"cv2.GaussianBlur",
"cv2.waitKey"
] |
[((125, 150), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (148, 150), False, 'import argparse\n'), ((853, 888), 'cv2.VideoCapture', 'cv2.VideoCapture', (['(0 + cv2.CAP_DSHOW)'], {}), '(0 + cv2.CAP_DSHOW)\n', (869, 888), False, 'import cv2\n'), ((3087, 3110), 'cv2.destroyAllWindows', 'cv2.destroyAllWindows', ([], {}), '()\n', (3108, 3110), False, 'import cv2\n'), ((1073, 1102), 'cv2.resize', 'cv2.resize', (['frame', '(640, 480)'], {}), '(frame, (640, 480))\n', (1083, 1102), False, 'import cv2\n'), ((1118, 1154), 'cv2.GaussianBlur', 'cv2.GaussianBlur', (['frame', '(11, 11)', '(0)'], {}), '(frame, (11, 11), 0)\n', (1134, 1154), False, 'import cv2\n'), ((1165, 1205), 'cv2.cvtColor', 'cv2.cvtColor', (['blurred', 'cv2.COLOR_BGR2HSV'], {}), '(blurred, cv2.COLOR_BGR2HSV)\n', (1177, 1205), False, 'import cv2\n'), ((2876, 2902), 'cv2.imshow', 'cv2.imshow', (['"""Frame"""', 'frame'], {}), "('Frame', frame)\n", (2886, 2902), False, 'import cv2\n'), ((1488, 1513), 'numpy.ones', 'np.ones', (['(9, 9)', 'np.uint8'], {}), '((9, 9), np.uint8)\n', (1495, 1513), True, 'import numpy as np\n'), ((1529, 1569), 'cv2.inRange', 'cv2.inRange', (['hsv', 'lower[key]', 'upper[key]'], {}), '(hsv, lower[key], upper[key])\n', (1540, 1569), False, 'import cv2\n'), ((1585, 1631), 'cv2.morphologyEx', 'cv2.morphologyEx', (['mask', 'cv2.MORPH_OPEN', 'kernel'], {}), '(mask, cv2.MORPH_OPEN, kernel)\n', (1601, 1631), False, 'import cv2\n'), ((1647, 1694), 'cv2.morphologyEx', 'cv2.morphologyEx', (['mask', 'cv2.MORPH_CLOSE', 'kernel'], {}), '(mask, cv2.MORPH_CLOSE, kernel)\n', (1663, 1694), False, 'import cv2\n'), ((2914, 2928), 'cv2.waitKey', 'cv2.waitKey', (['(1)'], {}), '(1)\n', (2925, 2928), False, 'import cv2\n'), ((2249, 2274), 'cv2.minEnclosingCircle', 'cv2.minEnclosingCircle', (['c'], {}), '(c)\n', (2271, 2274), False, 'import cv2\n'), ((2291, 2305), 'cv2.moments', 'cv2.moments', (['c'], {}), '(c)\n', (2302, 2305), False, 'import cv2\n')]
|
from CHECLabPy.plotting.setup import Plotter
from CHECLabPy.plotting.camera import CameraImage
from CHECLabPy.utils.files import create_directory
from CHECLabPy.utils.mapping import get_ctapipe_camera_geometry
from sstcam_sandbox import get_plot, get_data
from os.path import join
from matplotlib import pyplot as plt
from tqdm import tqdm
import numpy as np
import pandas as pd
import warnings
from CHECOnsky.calib import obtain_cleaning_mask
from CHECLabPy.calib import TimeCalibrator
from mpl_toolkits.axes_grid1 import make_axes_locatable
from IPython import embed
def colorbar(mappable, label):
ax = mappable.axes
fig = ax.figure
divider = make_axes_locatable(ax)
_ = divider.append_axes("right", size="10%", pad=0.15)
cax = divider.append_axes("right", size="10%", pad=0.15)
return fig.colorbar(mappable, label=label, cax=cax, aspect=20)
class CameraMovie(Plotter):
def __init__(self, mapping, output_path):
super().__init__()
self.fig = plt.figure(figsize=(8, 3))
self.ax_goldfish = self.fig.add_axes([0, 0, 0.4, 1])
self.ax_image = self.fig.add_axes([0.4, 0, 0.4, 1])
self.ax_cb = self.fig.add_axes([0.68, 0, 0.15, 1])
self.ax_image.patch.set_alpha(0)
self.ax_cb.patch.set_alpha(0)
self.ax_cb.axis('off')
self.ci_image = CameraImage.from_mapping(mapping, ax=self.ax_image)
self.ci_image.add_colorbar(
"Pixel Amplitude (p.e.)", ax=self.ax_cb, pad=-0.5
)
self.ci_goldfish = CameraImage.from_mapping(mapping, ax=self.ax_goldfish)
self.output_path = output_path
self.source_point_image = None
self.source_point_goldfish = None
self.source_label_image = None
self.source_label_goldfish = None
self.alpha_line = None
self.timestamp = None
self.iframe = 0
def set_source_position(self, x_src, y_src):
offset = 0.004
if self.source_point_image is None:
self.source_point_image, = self.ax_image.plot(
x_src, y_src, 'x', c='red'
)
self.source_label_image = self.ax_image.text(
x_src+offset, y_src+offset, "Mrk421", color='red', size=10
)
else:
self.source_point_image.set_xdata(x_src)
self.source_point_image.set_ydata(y_src)
self.source_label_image.set_position((x_src+offset, y_src+offset))
if self.source_point_goldfish is None:
self.source_point_goldfish, = self.ax_goldfish.plot(
x_src, y_src, 'x', c='red'
)
self.source_label_goldfish = self.ax_goldfish.text(
x_src+offset, y_src+offset, "Mrk421", color='red', size=10
)
else:
self.source_point_goldfish.set_xdata(x_src)
self.source_point_goldfish.set_ydata(y_src)
self.source_label_goldfish.set_position((x_src+offset, y_src+offset))
def set_timestamp(self, timestamp):
timestamp_str = str(timestamp)
timestamp_len = len(timestamp_str)
missing = 29 - timestamp_len
timestamp_str += "0" * missing
if self.timestamp is None:
self.timestamp = self.fig.text(
0.4, -0.1, timestamp_str, horizontalalignment='center', size=12
)
else:
self.timestamp.set_text(timestamp_str)
def set_image(self, image, min_=None, max_=None):
self.ci_image.image = image
self.ci_image.set_limits_minmax(min_, max_)
def set_goldfish(self, slice, min_=None, max_=None):
self.ci_goldfish.image = slice
self.ci_goldfish.set_limits_minmax(min_, max_)
def set_alpha_line(self, cog_x, cog_y, psi):
y_min, y_max = self.ax_image.get_ylim()
x_min = cog_x - (cog_y - y_min) / np.tan(psi)
x_max = cog_x - (cog_y - y_max) / np.tan(psi)
if self.alpha_line is None:
self.alpha_line, = self.ax_image.plot(
[x_min, x_max], [y_min, y_max], ls="--", c='red'
)
else:
self.alpha_line.set_xdata([x_min, x_max])
self.alpha_line.set_ydata([y_min, y_max])
def save_frame(self):
path = self.output_path.format(self.iframe)
self.fig.savefig(path, bbox_inches='tight')
self.iframe += 1
def main():
path = get_data("d190717_alpha/wobble.h5")
with pd.HDFStore(path, mode='r') as store:
df = store['data'].loc[::4]
mapping = store['mapping']
with warnings.catch_warnings():
warnings.simplefilter('ignore', UserWarning)
mapping.metadata = store.get_storer('mapping').attrs.metadata
tc = TimeCalibrator()
geom = get_ctapipe_camera_geometry(mapping)
n_row = df.index.size
p_camera = CameraMovie(mapping, get_plot(
"d190717_alpha/wobble_animation_goldfish/frames/{:04d}.png"
))
for _, row in tqdm(df.iterrows(), total=n_row):
timestamp = row['timestamp']
iobs = row['iobs']
iev = row['iev']
x_src = row['x_src']
y_src = row['y_src']
dl1 = row['dl1'].values
time = row['dl1_pulse_time'].values
r1 = row['r1']
x_cog = row['x_cog']
y_cog = row['y_cog']
psi = row['psi']
p_camera.set_source_position(x_src, y_src)
n_pixels, n_samples = r1.shape
shifted = tc(r1)
mask = obtain_cleaning_mask(geom, dl1, time)
if not mask.any():
msg = f"No pixels survived cleaning for: RUN {iobs} IEV {iev}"
print(msg)
continue
# raise ValueError(msg)
dl1_ma = np.ma.masked_array(dl1, mask=~mask)
min_pixel = dl1_ma.argmin()
max_pixel = dl1_ma.argmax()
min_image = -4
max_image = 0.7 * dl1.max()
min_gf = shifted[max_pixel, :20].min()
max_gf = shifted[max_pixel].max() * 0.8
st = int(np.min(time[mask]) - 3)
et = int(np.max(time[mask]) + 6)
st = st if st > 0 else 0
et = et if et < n_samples else n_samples
# embed()
p_camera.set_image(dl1, min_image, max_image)
for t in range(st, et, 3):
slice_ = shifted[:, t]
p_camera.set_timestamp(timestamp + pd.Timedelta(f"{t}ns"))
p_camera.set_goldfish(slice_, min_gf, max_gf)
p_camera.save_frame()
if __name__ == '__main__':
main()
|
[
"CHECLabPy.plotting.camera.CameraImage.from_mapping",
"sstcam_sandbox.get_plot",
"CHECOnsky.calib.obtain_cleaning_mask",
"numpy.tan",
"CHECLabPy.utils.mapping.get_ctapipe_camera_geometry",
"CHECLabPy.calib.TimeCalibrator",
"pandas.Timedelta",
"warnings.catch_warnings",
"numpy.max",
"sstcam_sandbox.get_data",
"matplotlib.pyplot.figure",
"mpl_toolkits.axes_grid1.make_axes_locatable",
"numpy.min",
"warnings.simplefilter",
"numpy.ma.masked_array",
"pandas.HDFStore"
] |
[((659, 682), 'mpl_toolkits.axes_grid1.make_axes_locatable', 'make_axes_locatable', (['ax'], {}), '(ax)\n', (678, 682), False, 'from mpl_toolkits.axes_grid1 import make_axes_locatable\n'), ((4380, 4415), 'sstcam_sandbox.get_data', 'get_data', (['"""d190717_alpha/wobble.h5"""'], {}), "('d190717_alpha/wobble.h5')\n", (4388, 4415), False, 'from sstcam_sandbox import get_plot, get_data\n'), ((4715, 4731), 'CHECLabPy.calib.TimeCalibrator', 'TimeCalibrator', ([], {}), '()\n', (4729, 4731), False, 'from CHECLabPy.calib import TimeCalibrator\n'), ((4743, 4779), 'CHECLabPy.utils.mapping.get_ctapipe_camera_geometry', 'get_ctapipe_camera_geometry', (['mapping'], {}), '(mapping)\n', (4770, 4779), False, 'from CHECLabPy.utils.mapping import get_ctapipe_camera_geometry\n'), ((993, 1019), 'matplotlib.pyplot.figure', 'plt.figure', ([], {'figsize': '(8, 3)'}), '(figsize=(8, 3))\n', (1003, 1019), True, 'from matplotlib import pyplot as plt\n'), ((1334, 1385), 'CHECLabPy.plotting.camera.CameraImage.from_mapping', 'CameraImage.from_mapping', (['mapping'], {'ax': 'self.ax_image'}), '(mapping, ax=self.ax_image)\n', (1358, 1385), False, 'from CHECLabPy.plotting.camera import CameraImage\n'), ((1521, 1575), 'CHECLabPy.plotting.camera.CameraImage.from_mapping', 'CameraImage.from_mapping', (['mapping'], {'ax': 'self.ax_goldfish'}), '(mapping, ax=self.ax_goldfish)\n', (1545, 1575), False, 'from CHECLabPy.plotting.camera import CameraImage\n'), ((4425, 4452), 'pandas.HDFStore', 'pd.HDFStore', (['path'], {'mode': '"""r"""'}), "(path, mode='r')\n", (4436, 4452), True, 'import pandas as pd\n'), ((4843, 4912), 'sstcam_sandbox.get_plot', 'get_plot', (['"""d190717_alpha/wobble_animation_goldfish/frames/{:04d}.png"""'], {}), "('d190717_alpha/wobble_animation_goldfish/frames/{:04d}.png')\n", (4851, 4912), False, 'from sstcam_sandbox import get_plot, get_data\n'), ((5442, 5479), 'CHECOnsky.calib.obtain_cleaning_mask', 'obtain_cleaning_mask', (['geom', 'dl1', 'time'], {}), '(geom, dl1, time)\n', (5462, 5479), False, 'from CHECOnsky.calib import obtain_cleaning_mask\n'), ((5680, 5715), 'numpy.ma.masked_array', 'np.ma.masked_array', (['dl1'], {'mask': '(~mask)'}), '(dl1, mask=~mask)\n', (5698, 5715), True, 'import numpy as np\n'), ((4547, 4572), 'warnings.catch_warnings', 'warnings.catch_warnings', ([], {}), '()\n', (4570, 4572), False, 'import warnings\n'), ((4586, 4630), 'warnings.simplefilter', 'warnings.simplefilter', (['"""ignore"""', 'UserWarning'], {}), "('ignore', UserWarning)\n", (4607, 4630), False, 'import warnings\n'), ((3845, 3856), 'numpy.tan', 'np.tan', (['psi'], {}), '(psi)\n', (3851, 3856), True, 'import numpy as np\n'), ((3899, 3910), 'numpy.tan', 'np.tan', (['psi'], {}), '(psi)\n', (3905, 3910), True, 'import numpy as np\n'), ((5963, 5981), 'numpy.min', 'np.min', (['time[mask]'], {}), '(time[mask])\n', (5969, 5981), True, 'import numpy as np\n'), ((6004, 6022), 'numpy.max', 'np.max', (['time[mask]'], {}), '(time[mask])\n', (6010, 6022), True, 'import numpy as np\n'), ((6301, 6323), 'pandas.Timedelta', 'pd.Timedelta', (['f"""{t}ns"""'], {}), "(f'{t}ns')\n", (6313, 6323), True, 'import pandas as pd\n')]
|
import argparse
import numpy as np
import os
import random
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from datasets import custom_collate_fn, load_data, WebDataset
from models import WebObjExtractionNet
from train import train_model, evaluate_model
from utils import print_and_log
########## CMDLINE ARGS ##########
parser = argparse.ArgumentParser('Train Model')
parser.add_argument('-d', '--device', type=int, default=0)
parser.add_argument('-e', '--n_epochs', type=int, default=100)
parser.add_argument('-bb', '--backbone', type=str, default='alexnet', choices=['alexnet', 'resnet'])
parser.add_argument('-tc', '--trainable_convnet', type=int, default=1, choices=[0,1])
parser.add_argument('-lr', '--learning_rate', type=float, default=0.0005)
parser.add_argument('-bs', '--batch_size', type=int, default=25)
parser.add_argument('-cs', '--context_size', type=int, default=6)
parser.add_argument('-att', '--attention', type=int, default=1, choices=[0,1])
parser.add_argument('-hd', '--hidden_dim', type=int, default=300)
parser.add_argument('-r', '--roi', type=int, default=1)
parser.add_argument('-bbf', '--bbox_feat', type=int, default=1, choices=[0,1])
parser.add_argument('-wd', '--weight_decay', type=float, default=0)
parser.add_argument('-dp', '--drop_prob', type=float, default=0.5)
parser.add_argument('-mbb', '--max_bg_boxes', type=int, default=-1)
parser.add_argument('-nw', '--num_workers', type=int, default=8)
args = parser.parse_args()
device = torch.device('cuda:%d' % args.device if torch.cuda.is_available() else 'cpu')
########## MAKING RESULTS REPRODUCIBLE ##########
seed = 1
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
# torch.backends.cudnn.deterministic = True
# torch.backends.cudnn.benchmark = False
########## PARAMETERS ##########
N_CLASSES = 4
CLASS_NAMES = ['BG', 'Price', 'Title', 'Image']
IMG_HEIGHT = 1280 # Image assumed to have same height and width
EVAL_INTERVAL = 3 # Number of Epochs after which model is evaluated
NUM_WORKERS = args.num_workers # multithreaded data loading
DATA_DIR = '/shared/data_product_info/v2_8.3k/' # Contains .png and .pkl files for train and test data
OUTPUT_DIR = 'results_attn' # logs are saved here!
# NOTE: if same hyperparameter configuration is run again, previous log file and saved model will be overwritten
if not os.path.exists(OUTPUT_DIR):
os.makedirs(OUTPUT_DIR)
SPLIT_DIR = 'splits'
train_img_ids = np.loadtxt('%s/train_imgs.txt' % SPLIT_DIR, dtype=np.int32)
val_img_ids = np.loadtxt('%s/val_imgs.txt' % SPLIT_DIR, dtype=np.int32)
test_img_ids = np.loadtxt('%s/test_imgs.txt' % SPLIT_DIR, dtype=np.int32)
test_domains = np.loadtxt('%s/test_domains.txt' % SPLIT_DIR, dtype=str) # for calculating macro accuracy
########## HYPERPARAMETERS ##########
N_EPOCHS = args.n_epochs
BACKBONE = args.backbone
TRAINABLE_CONVNET = bool(args.trainable_convnet)
LEARNING_RATE = args.learning_rate
BATCH_SIZE = args.batch_size
CONTEXT_SIZE = args.context_size
USE_ATTENTION = bool(args.attention)
HIDDEN_DIM = args.hidden_dim
ROI_POOL_OUTPUT_SIZE = (args.roi, args.roi)
USE_BBOX_FEAT = bool(args.bbox_feat)
WEIGHT_DECAY = args.weight_decay
DROP_PROB = args.drop_prob
MAX_BG_BOXES = args.max_bg_boxes if args.max_bg_boxes > 0 else -1
params = '%s lr-%.0e batch-%d cs-%d att-%d hd-%d roi-%d bbf-%d wd-%.0e dp-%.2f mbb-%d' % (BACKBONE, LEARNING_RATE, BATCH_SIZE, CONTEXT_SIZE, USE_ATTENTION,
HIDDEN_DIM, ROI_POOL_OUTPUT_SIZE[0], USE_BBOX_FEAT, WEIGHT_DECAY, DROP_PROB, MAX_BG_BOXES)
log_file = '%s/%s logs.txt' % (OUTPUT_DIR, params)
test_acc_domainwise_file = '%s/%s test_acc_domainwise.csv' % (OUTPUT_DIR, params)
model_save_file = '%s/%s saved_model.pth' % (OUTPUT_DIR, params)
print('logs will be saved in \"%s\"' % (log_file))
print_and_log('Backbone Convnet: %s' % (BACKBONE), log_file, 'w')
print_and_log('Trainable Convnet: %s' % (TRAINABLE_CONVNET), log_file)
print_and_log('Learning Rate: %.0e' % (LEARNING_RATE), log_file)
print_and_log('Batch Size: %d' % (BATCH_SIZE), log_file)
print_and_log('Context Size: %d' % (CONTEXT_SIZE), log_file)
print_and_log('Attention: %s' % (USE_ATTENTION), log_file)
print_and_log('Hidden Dim: %d' % (HIDDEN_DIM), log_file)
print_and_log('RoI Pool Output Size: (%d, %d)' % ROI_POOL_OUTPUT_SIZE, log_file)
print_and_log('BBox Features: %s' % (USE_BBOX_FEAT), log_file)
print_and_log('Weight Decay: %.0e' % (WEIGHT_DECAY), log_file)
print_and_log('Dropout Probability: %.2f' % (DROP_PROB), log_file)
print_and_log('Max BG Boxes: %d\n' % (MAX_BG_BOXES), log_file)
########## DATA LOADERS ##########
train_loader, val_loader, test_loader = load_data(DATA_DIR, train_img_ids, val_img_ids, test_img_ids, CONTEXT_SIZE, BATCH_SIZE, NUM_WORKERS, MAX_BG_BOXES)
########## CREATE MODEL & LOSS FN ##########
model = WebObjExtractionNet(ROI_POOL_OUTPUT_SIZE, IMG_HEIGHT, N_CLASSES, BACKBONE, USE_ATTENTION, HIDDEN_DIM, TRAINABLE_CONVNET, DROP_PROB,
USE_BBOX_FEAT, CLASS_NAMES).to(device)
optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE, weight_decay=WEIGHT_DECAY)
criterion = nn.CrossEntropyLoss(reduction='sum').to(device)
########## TRAIN MODEL ##########
train_model(model, train_loader, optimizer, criterion, N_EPOCHS, device, val_loader, EVAL_INTERVAL, log_file, 'ckpt_%d.pth' % args.device)
########## EVALUATE TEST PERFORMANCE ##########
print('Evaluating test data class wise accuracies...')
evaluate_model(model, test_loader, criterion, device, 'TEST', log_file)
with open (test_acc_domainwise_file, 'w') as f:
f.write('Domain,N_examples,%s,%s,%s\n' % (CLASS_NAMES[1], CLASS_NAMES[2], CLASS_NAMES[3]))
print('Evaluating per domain accuracy for %d test domains...' % len(test_domains))
for domain in test_domains:
print('\n---> Domain:', domain)
test_dataset = WebDataset(DATA_DIR, np.loadtxt('%s/domain_wise_imgs/%s.txt' % (SPLIT_DIR, domain), np.int32).reshape(-1), CONTEXT_SIZE, max_bg_boxes=-1)
test_loader = DataLoader(test_dataset, batch_size=1, shuffle=False, num_workers=NUM_WORKERS, collate_fn=custom_collate_fn, drop_last=False)
per_class_acc = evaluate_model(model, test_loader, criterion, device, 'TEST')
with open (test_acc_domainwise_file, 'a') as f:
f.write('%s,%d,%.2f,%.2f,%.2f\n' % (domain, len(test_dataset), 100*per_class_acc[1], 100*per_class_acc[2], 100*per_class_acc[3]))
macro_acc_test = np.loadtxt(test_acc_domainwise_file, delimiter=',', skiprows=1, dtype=str)[:,2:].astype(np.float32).mean(0)
for i in range(1, len(CLASS_NAMES)):
print_and_log('%s Macro Acc: %.2f%%' % (CLASS_NAMES[i], macro_acc_test[i-1]), log_file)
########## SAVE MODEL ##########
torch.save(model.state_dict(), model_save_file)
print_and_log('Model can be restored from \"%s\"' % (model_save_file), log_file)
|
[
"torch.manual_seed",
"os.path.exists",
"train.train_model",
"argparse.ArgumentParser",
"os.makedirs",
"utils.print_and_log",
"models.WebObjExtractionNet",
"torch.nn.CrossEntropyLoss",
"random.seed",
"numpy.loadtxt",
"torch.cuda.is_available",
"numpy.random.seed",
"torch.utils.data.DataLoader",
"torch.cuda.manual_seed",
"datasets.load_data",
"train.evaluate_model"
] |
[((388, 426), 'argparse.ArgumentParser', 'argparse.ArgumentParser', (['"""Train Model"""'], {}), "('Train Model')\n", (411, 426), False, 'import argparse\n'), ((1664, 1681), 'random.seed', 'random.seed', (['seed'], {}), '(seed)\n', (1675, 1681), False, 'import random\n'), ((1682, 1702), 'numpy.random.seed', 'np.random.seed', (['seed'], {}), '(seed)\n', (1696, 1702), True, 'import numpy as np\n'), ((1703, 1726), 'torch.manual_seed', 'torch.manual_seed', (['seed'], {}), '(seed)\n', (1720, 1726), False, 'import torch\n'), ((1727, 1755), 'torch.cuda.manual_seed', 'torch.cuda.manual_seed', (['seed'], {}), '(seed)\n', (1749, 1755), False, 'import torch\n'), ((2499, 2558), 'numpy.loadtxt', 'np.loadtxt', (["('%s/train_imgs.txt' % SPLIT_DIR)"], {'dtype': 'np.int32'}), "('%s/train_imgs.txt' % SPLIT_DIR, dtype=np.int32)\n", (2509, 2558), True, 'import numpy as np\n'), ((2573, 2630), 'numpy.loadtxt', 'np.loadtxt', (["('%s/val_imgs.txt' % SPLIT_DIR)"], {'dtype': 'np.int32'}), "('%s/val_imgs.txt' % SPLIT_DIR, dtype=np.int32)\n", (2583, 2630), True, 'import numpy as np\n'), ((2646, 2704), 'numpy.loadtxt', 'np.loadtxt', (["('%s/test_imgs.txt' % SPLIT_DIR)"], {'dtype': 'np.int32'}), "('%s/test_imgs.txt' % SPLIT_DIR, dtype=np.int32)\n", (2656, 2704), True, 'import numpy as np\n'), ((2721, 2777), 'numpy.loadtxt', 'np.loadtxt', (["('%s/test_domains.txt' % SPLIT_DIR)"], {'dtype': 'str'}), "('%s/test_domains.txt' % SPLIT_DIR, dtype=str)\n", (2731, 2777), True, 'import numpy as np\n'), ((3821, 3884), 'utils.print_and_log', 'print_and_log', (["('Backbone Convnet: %s' % BACKBONE)", 'log_file', '"""w"""'], {}), "('Backbone Convnet: %s' % BACKBONE, log_file, 'w')\n", (3834, 3884), False, 'from utils import print_and_log\n'), ((3887, 3955), 'utils.print_and_log', 'print_and_log', (["('Trainable Convnet: %s' % TRAINABLE_CONVNET)", 'log_file'], {}), "('Trainable Convnet: %s' % TRAINABLE_CONVNET, log_file)\n", (3900, 3955), False, 'from utils import print_and_log\n'), ((3958, 4020), 'utils.print_and_log', 'print_and_log', (["('Learning Rate: %.0e' % LEARNING_RATE)", 'log_file'], {}), "('Learning Rate: %.0e' % LEARNING_RATE, log_file)\n", (3971, 4020), False, 'from utils import print_and_log\n'), ((4023, 4077), 'utils.print_and_log', 'print_and_log', (["('Batch Size: %d' % BATCH_SIZE)", 'log_file'], {}), "('Batch Size: %d' % BATCH_SIZE, log_file)\n", (4036, 4077), False, 'from utils import print_and_log\n'), ((4080, 4138), 'utils.print_and_log', 'print_and_log', (["('Context Size: %d' % CONTEXT_SIZE)", 'log_file'], {}), "('Context Size: %d' % CONTEXT_SIZE, log_file)\n", (4093, 4138), False, 'from utils import print_and_log\n'), ((4141, 4197), 'utils.print_and_log', 'print_and_log', (["('Attention: %s' % USE_ATTENTION)", 'log_file'], {}), "('Attention: %s' % USE_ATTENTION, log_file)\n", (4154, 4197), False, 'from utils import print_and_log\n'), ((4200, 4254), 'utils.print_and_log', 'print_and_log', (["('Hidden Dim: %d' % HIDDEN_DIM)", 'log_file'], {}), "('Hidden Dim: %d' % HIDDEN_DIM, log_file)\n", (4213, 4254), False, 'from utils import print_and_log\n'), ((4257, 4342), 'utils.print_and_log', 'print_and_log', (["('RoI Pool Output Size: (%d, %d)' % ROI_POOL_OUTPUT_SIZE)", 'log_file'], {}), "('RoI Pool Output Size: (%d, %d)' % ROI_POOL_OUTPUT_SIZE, log_file\n )\n", (4270, 4342), False, 'from utils import print_and_log\n'), ((4338, 4398), 'utils.print_and_log', 'print_and_log', (["('BBox Features: %s' % USE_BBOX_FEAT)", 'log_file'], {}), "('BBox Features: %s' % USE_BBOX_FEAT, log_file)\n", (4351, 4398), False, 'from utils import print_and_log\n'), ((4401, 4461), 'utils.print_and_log', 'print_and_log', (["('Weight Decay: %.0e' % WEIGHT_DECAY)", 'log_file'], {}), "('Weight Decay: %.0e' % WEIGHT_DECAY, log_file)\n", (4414, 4461), False, 'from utils import print_and_log\n'), ((4464, 4528), 'utils.print_and_log', 'print_and_log', (["('Dropout Probability: %.2f' % DROP_PROB)", 'log_file'], {}), "('Dropout Probability: %.2f' % DROP_PROB, log_file)\n", (4477, 4528), False, 'from utils import print_and_log\n'), ((4531, 4591), 'utils.print_and_log', 'print_and_log', (["('Max BG Boxes: %d\\n' % MAX_BG_BOXES)", 'log_file'], {}), "('Max BG Boxes: %d\\n' % MAX_BG_BOXES, log_file)\n", (4544, 4591), False, 'from utils import print_and_log\n'), ((4670, 4788), 'datasets.load_data', 'load_data', (['DATA_DIR', 'train_img_ids', 'val_img_ids', 'test_img_ids', 'CONTEXT_SIZE', 'BATCH_SIZE', 'NUM_WORKERS', 'MAX_BG_BOXES'], {}), '(DATA_DIR, train_img_ids, val_img_ids, test_img_ids, CONTEXT_SIZE,\n BATCH_SIZE, NUM_WORKERS, MAX_BG_BOXES)\n', (4679, 4788), False, 'from datasets import custom_collate_fn, load_data, WebDataset\n'), ((5222, 5364), 'train.train_model', 'train_model', (['model', 'train_loader', 'optimizer', 'criterion', 'N_EPOCHS', 'device', 'val_loader', 'EVAL_INTERVAL', 'log_file', "('ckpt_%d.pth' % args.device)"], {}), "(model, train_loader, optimizer, criterion, N_EPOCHS, device,\n val_loader, EVAL_INTERVAL, log_file, 'ckpt_%d.pth' % args.device)\n", (5233, 5364), False, 'from train import train_model, evaluate_model\n'), ((5465, 5536), 'train.evaluate_model', 'evaluate_model', (['model', 'test_loader', 'criterion', 'device', '"""TEST"""', 'log_file'], {}), "(model, test_loader, criterion, device, 'TEST', log_file)\n", (5479, 5536), False, 'from train import train_model, evaluate_model\n'), ((6741, 6817), 'utils.print_and_log', 'print_and_log', (['(\'Model can be restored from "%s"\' % model_save_file)', 'log_file'], {}), '(\'Model can be restored from "%s"\' % model_save_file, log_file)\n', (6754, 6817), False, 'from utils import print_and_log\n'), ((2405, 2431), 'os.path.exists', 'os.path.exists', (['OUTPUT_DIR'], {}), '(OUTPUT_DIR)\n', (2419, 2431), False, 'import os\n'), ((2437, 2460), 'os.makedirs', 'os.makedirs', (['OUTPUT_DIR'], {}), '(OUTPUT_DIR)\n', (2448, 2460), False, 'import os\n'), ((6004, 6134), 'torch.utils.data.DataLoader', 'DataLoader', (['test_dataset'], {'batch_size': '(1)', 'shuffle': '(False)', 'num_workers': 'NUM_WORKERS', 'collate_fn': 'custom_collate_fn', 'drop_last': '(False)'}), '(test_dataset, batch_size=1, shuffle=False, num_workers=\n NUM_WORKERS, collate_fn=custom_collate_fn, drop_last=False)\n', (6014, 6134), False, 'from torch.utils.data import DataLoader\n'), ((6151, 6212), 'train.evaluate_model', 'evaluate_model', (['model', 'test_loader', 'criterion', 'device', '"""TEST"""'], {}), "(model, test_loader, criterion, device, 'TEST')\n", (6165, 6212), False, 'from train import train_model, evaluate_model\n'), ((6571, 6665), 'utils.print_and_log', 'print_and_log', (["('%s Macro Acc: %.2f%%' % (CLASS_NAMES[i], macro_acc_test[i - 1]))", 'log_file'], {}), "('%s Macro Acc: %.2f%%' % (CLASS_NAMES[i], macro_acc_test[i - \n 1]), log_file)\n", (6584, 6665), False, 'from utils import print_and_log\n'), ((1566, 1591), 'torch.cuda.is_available', 'torch.cuda.is_available', ([], {}), '()\n', (1589, 1591), False, 'import torch\n'), ((4839, 5006), 'models.WebObjExtractionNet', 'WebObjExtractionNet', (['ROI_POOL_OUTPUT_SIZE', 'IMG_HEIGHT', 'N_CLASSES', 'BACKBONE', 'USE_ATTENTION', 'HIDDEN_DIM', 'TRAINABLE_CONVNET', 'DROP_PROB', 'USE_BBOX_FEAT', 'CLASS_NAMES'], {}), '(ROI_POOL_OUTPUT_SIZE, IMG_HEIGHT, N_CLASSES, BACKBONE,\n USE_ATTENTION, HIDDEN_DIM, TRAINABLE_CONVNET, DROP_PROB, USE_BBOX_FEAT,\n CLASS_NAMES)\n', (4858, 5006), False, 'from models import WebObjExtractionNet\n'), ((5139, 5175), 'torch.nn.CrossEntropyLoss', 'nn.CrossEntropyLoss', ([], {'reduction': '"""sum"""'}), "(reduction='sum')\n", (5158, 5175), True, 'import torch.nn as nn\n'), ((5869, 5941), 'numpy.loadtxt', 'np.loadtxt', (["('%s/domain_wise_imgs/%s.txt' % (SPLIT_DIR, domain))", 'np.int32'], {}), "('%s/domain_wise_imgs/%s.txt' % (SPLIT_DIR, domain), np.int32)\n", (5879, 5941), True, 'import numpy as np\n'), ((6422, 6496), 'numpy.loadtxt', 'np.loadtxt', (['test_acc_domainwise_file'], {'delimiter': '""","""', 'skiprows': '(1)', 'dtype': 'str'}), "(test_acc_domainwise_file, delimiter=',', skiprows=1, dtype=str)\n", (6432, 6496), True, 'import numpy as np\n')]
|
import numpy as np
from typing import Union, Optional, List, Dict, Any
from buffers.chunk_buffer import ChunkReplayBuffer
class IntrospectiveChunkReplayBuffer(ChunkReplayBuffer):
def __init__(self, buffer_size: int, *args, **kwargs):
super().__init__(buffer_size, *args, **kwargs)
self.sample_counts = np.zeros((buffer_size,), dtype=np.int)
self.first_access = np.zeros((buffer_size,), dtype=np.int) - 1
def _log_indices(self, indices):
self.sample_counts[indices] += 1
mask = np.zeros_like(self.first_access, dtype=bool)
mask[indices] = 1
self.first_access[(self.first_access == -1) & mask] = self.pos
def add(self,
obs: np.ndarray,
next_obs: np.ndarray,
action: np.ndarray,
reward: np.ndarray,
done: np.ndarray,
infos: List[Dict[str, Any]]
):
super().add(obs, next_obs, action, reward, done, infos)
def _get_chunk_batches(self, beginnings):
sampled_indices = super()._get_chunk_batches(beginnings)
self._log_indices(sampled_indices.flatten())
return sampled_indices
|
[
"numpy.zeros",
"numpy.zeros_like"
] |
[((333, 371), 'numpy.zeros', 'np.zeros', (['(buffer_size,)'], {'dtype': 'np.int'}), '((buffer_size,), dtype=np.int)\n', (341, 371), True, 'import numpy as np\n'), ((537, 581), 'numpy.zeros_like', 'np.zeros_like', (['self.first_access'], {'dtype': 'bool'}), '(self.first_access, dtype=bool)\n', (550, 581), True, 'import numpy as np\n'), ((400, 438), 'numpy.zeros', 'np.zeros', (['(buffer_size,)'], {'dtype': 'np.int'}), '((buffer_size,), dtype=np.int)\n', (408, 438), True, 'import numpy as np\n')]
|
""" Identify low-level jets in wind profile data.
<NAME>
December 2020
"""
import numpy as np
import xarray as xr
def detect_llj(x, axis=None, falloff=0, output='strength', inverse=False):
""" Identify maxima in wind profiles.
args:
- x : ndarray with wind profile data
- axis : specifies the vertical dimension
is internally used with np.apply_along_axis
- falloff : threshold for labeling as low-level jet
default 0; can be masked later, e.g. llj[falloff>2.0]
- output : specifiy return type: 'strength' or 'index'
returns (depending on <output> argument):
- strength : 0 if no maximum identified, otherwise falloff strength
- index : nan if no maximum identified, otherwise index along
<axis>, to get the height of the jet etc.
"""
def inner(x, output):
if inverse:
x = x[::-1, ...]
# Identify local maxima
x = x[~np.isnan(x)]
dx = x[1:] - x[:-1]
ind = np.where((np.hstack((dx, 0)) < 0) & (np.hstack((0, dx)) >= 0))[0]
# Last value of x cannot be llj
if ind.size and ind[-1] == x.size - 1:
ind = ind[:-1]
# Compute the falloff strength for each local maxima
if ind.size: # this assumes height increases along axis!!!
strength = np.array([x[i] - min(x[i:]) for i in ind])
imax = np.argmax(strength)
# Return jet_strength and index of maximum:
if output == 'strength':
r = max(strength) if ind.size else 0
elif output == 'index':
r = ind[imax] if ind.size else 0
return r
# Wrapper interface to apply 1d function to ndarray
return np.apply_along_axis(inner, axis, x, output=output)
def detect_llj_vectorized(xs,
axis=-1,
output='falloff',
mask_inv=False,
inverse=False):
""" Identify local maxima in wind profiles.
args:
- x : ndarray with wind profile data
- axis : specifies the vertical dimension
- output : specifiy return type: 'falloff', 'strength' or 'index'
- mask_inv : use np.ma to mask nan values
returns (depending on <output> argument and whether llj is identified):
- falloff : 0 or largest difference between local max and subseq min
- strength : 0 or wind speed at jet height
- index : -1 or index along <axis>
"""
# Move <axis> to first dimension, to easily index and iterate over it.
xv = np.rollaxis(xs, axis)
if inverse:
xv = xv[::-1, ...]
if mask_inv:
xv = np.ma.masked_invalid(xv)
# Set initial arrays
min_elem = xv[-1].copy()
max_elem = np.zeros(min_elem.shape)
max_diff = np.zeros(min_elem.shape)
max_idx = np.ones(min_elem.shape, dtype=int) * (-1)
# Start at end of array and search backwards for larger differences.
for i, elem in reversed(list(enumerate(xv))):
min_elem = np.minimum(elem, min_elem)
new_max_identified = elem - min_elem > max_diff
max_diff = np.where(new_max_identified, elem - min_elem, max_diff)
max_elem = np.where(new_max_identified, elem, max_elem)
max_idx = np.where(new_max_identified, i, max_idx)
if output == 'falloff':
r = max_diff
elif output == 'strength':
r = max_elem
elif output == 'index':
r = max_idx
else:
raise ValueError('Invalid argument for <output>: %s' % output)
return r
def detect_llj_xarray(da, inverse=False):
""" Identify local maxima in wind profiles.
args:
- da : xarray.DataArray with wind profile data
- inverse : to flip the array if the data is stored upside down
returns: : xarray.Dataset with vertical dimension removed containing:
- falloff : 0 or largest difference between local max and subseq min
- strength : 0 or wind speed at jet height
- index : -1 or index along <axis>
Note: vertical dimension should be labeled 'level' and axis=1
"""
# Move <axis> to first dimension, to easily index and iterate over it.
xv = np.rollaxis(da.values, 1)
if inverse:
xv = xv[::-1, ...]
# Set initial arrays
min_elem = xv[-1].copy()
max_elem = np.zeros(min_elem.shape)
max_diff = np.zeros(min_elem.shape)
max_idx = np.ones(min_elem.shape, dtype=int) * (-1)
# Start at end of array and search backwards for larger differences.
for i, elem in reversed(list(enumerate(xv))):
min_elem = np.minimum(elem, min_elem)
new_max_identified = elem - min_elem > max_diff
max_diff = np.where(new_max_identified, elem - min_elem, max_diff)
max_elem = np.where(new_max_identified, elem, max_elem)
max_idx = np.where(new_max_identified, i, max_idx)
# Combine the results in a dataframe
get_height = lambda i: np.where(i > 0, da.level.values[i], da.level.values[
-1])
dims = da.isel(level=0).drop('level').dims
coords = da.isel(level=0).drop('level').coords
lljs = xr.Dataset(
{
'falloff': (dims, max_diff),
'strength': (dims, max_elem),
'level': (dims, get_height(max_idx)),
},
coords=coords)
print(
'Beware! Level is also filled if no jet is detected! '
'Use ds.sel(level=lljs.level).where(lljs.falloff>0) to get rid of them'
)
return lljs
|
[
"numpy.ones",
"numpy.minimum",
"numpy.hstack",
"numpy.where",
"numpy.rollaxis",
"numpy.argmax",
"numpy.zeros",
"numpy.apply_along_axis",
"numpy.isnan",
"numpy.ma.masked_invalid"
] |
[((1794, 1844), 'numpy.apply_along_axis', 'np.apply_along_axis', (['inner', 'axis', 'x'], {'output': 'output'}), '(inner, axis, x, output=output)\n', (1813, 1844), True, 'import numpy as np\n'), ((2690, 2711), 'numpy.rollaxis', 'np.rollaxis', (['xs', 'axis'], {}), '(xs, axis)\n', (2701, 2711), True, 'import numpy as np\n'), ((2882, 2906), 'numpy.zeros', 'np.zeros', (['min_elem.shape'], {}), '(min_elem.shape)\n', (2890, 2906), True, 'import numpy as np\n'), ((2922, 2946), 'numpy.zeros', 'np.zeros', (['min_elem.shape'], {}), '(min_elem.shape)\n', (2930, 2946), True, 'import numpy as np\n'), ((4338, 4363), 'numpy.rollaxis', 'np.rollaxis', (['da.values', '(1)'], {}), '(da.values, 1)\n', (4349, 4363), True, 'import numpy as np\n'), ((4478, 4502), 'numpy.zeros', 'np.zeros', (['min_elem.shape'], {}), '(min_elem.shape)\n', (4486, 4502), True, 'import numpy as np\n'), ((4518, 4542), 'numpy.zeros', 'np.zeros', (['min_elem.shape'], {}), '(min_elem.shape)\n', (4526, 4542), True, 'import numpy as np\n'), ((2787, 2811), 'numpy.ma.masked_invalid', 'np.ma.masked_invalid', (['xv'], {}), '(xv)\n', (2807, 2811), True, 'import numpy as np\n'), ((2961, 2995), 'numpy.ones', 'np.ones', (['min_elem.shape'], {'dtype': 'int'}), '(min_elem.shape, dtype=int)\n', (2968, 2995), True, 'import numpy as np\n'), ((3146, 3172), 'numpy.minimum', 'np.minimum', (['elem', 'min_elem'], {}), '(elem, min_elem)\n', (3156, 3172), True, 'import numpy as np\n'), ((3248, 3303), 'numpy.where', 'np.where', (['new_max_identified', '(elem - min_elem)', 'max_diff'], {}), '(new_max_identified, elem - min_elem, max_diff)\n', (3256, 3303), True, 'import numpy as np\n'), ((3323, 3367), 'numpy.where', 'np.where', (['new_max_identified', 'elem', 'max_elem'], {}), '(new_max_identified, elem, max_elem)\n', (3331, 3367), True, 'import numpy as np\n'), ((3386, 3426), 'numpy.where', 'np.where', (['new_max_identified', 'i', 'max_idx'], {}), '(new_max_identified, i, max_idx)\n', (3394, 3426), True, 'import numpy as np\n'), ((4557, 4591), 'numpy.ones', 'np.ones', (['min_elem.shape'], {'dtype': 'int'}), '(min_elem.shape, dtype=int)\n', (4564, 4591), True, 'import numpy as np\n'), ((4742, 4768), 'numpy.minimum', 'np.minimum', (['elem', 'min_elem'], {}), '(elem, min_elem)\n', (4752, 4768), True, 'import numpy as np\n'), ((4844, 4899), 'numpy.where', 'np.where', (['new_max_identified', '(elem - min_elem)', 'max_diff'], {}), '(new_max_identified, elem - min_elem, max_diff)\n', (4852, 4899), True, 'import numpy as np\n'), ((4919, 4963), 'numpy.where', 'np.where', (['new_max_identified', 'elem', 'max_elem'], {}), '(new_max_identified, elem, max_elem)\n', (4927, 4963), True, 'import numpy as np\n'), ((4982, 5022), 'numpy.where', 'np.where', (['new_max_identified', 'i', 'max_idx'], {}), '(new_max_identified, i, max_idx)\n', (4990, 5022), True, 'import numpy as np\n'), ((5092, 5148), 'numpy.where', 'np.where', (['(i > 0)', 'da.level.values[i]', 'da.level.values[-1]'], {}), '(i > 0, da.level.values[i], da.level.values[-1])\n', (5100, 5148), True, 'import numpy as np\n'), ((1476, 1495), 'numpy.argmax', 'np.argmax', (['strength'], {}), '(strength)\n', (1485, 1495), True, 'import numpy as np\n'), ((1025, 1036), 'numpy.isnan', 'np.isnan', (['x'], {}), '(x)\n', (1033, 1036), True, 'import numpy as np\n'), ((1090, 1108), 'numpy.hstack', 'np.hstack', (['(dx, 0)'], {}), '((dx, 0))\n', (1099, 1108), True, 'import numpy as np\n'), ((1117, 1135), 'numpy.hstack', 'np.hstack', (['(0, dx)'], {}), '((0, dx))\n', (1126, 1135), True, 'import numpy as np\n')]
|
import time
import sys
import numpy as np
from local_search import kmedian_local_search
import feasibility
from kmedkpm import k_median_k_partitions_LS
import psutil
from sklearn.datasets import make_blobs
import generator
import random
test = False
def lp_ls_complete(data, color_mat, rvec, k, logfile):
############################################################################
# INPUT
# data: N X d numpy array
# color_mat: N*t numpy array representing groups' memberships
# rvec: requirements vector of t size
# k: number of clusters
# OUTPUT
# Object with stats, i.e, with "cost" that is a cost of the solution
############################################################################
(N, d) = data.shape
many_solutions_lp_only = True
command = 'linear-program'
return_solution = False
process = psutil.Process()
tstart = time.time()
time_buf = time.time()
perf_stats = feasibility.calculate(k, rvec, color_mat,
command, return_solution,
logfile, many_solutions_lp_only)
set_mappings = perf_stats["subset_map"]
solution = perf_stats["solution"]
set_to_indices = {}
for (idx, _id) in enumerate(sorted(set_mappings.keys())):
set_to_indices[idx] = _id
#end for
unique_solutions = solution if len(solution) == 0 else np.unique(np.stack(solution, axis=0), axis=0)
print('solutions: ', 0 if len(solution) == 0 else unique_solutions.shape[0])
total_cost = sys.maxsize
time_buf = time.time()
for (_, s) in enumerate(unique_solutions):
E = {}
i = 0
for (idx, e) in enumerate(s):
for _ in range(e):
#E[i] = (idx, set_to_indices[idx])
E[i] = data[set_mappings[set_to_indices[idx]], :]
i = i + 1
#end for
#end for
if k > i:
continue
statc = k_median_k_partitions_LS(E, data, None, N, d, k, is_coreset=False)
total_cost = min(total_cost, statc["cost"])
# print(set_to_indices)
kmedkpmtime = time.time() - time_buf
total_time = time.time() - tstart
stats_total = {}
opt_ls_cost = kmedian_local_search(data, k)["cost"]
stats_total['opt_ls_cost'] = opt_ls_cost
stats_total["lp_time"] = perf_stats["total_time"]
stats_total["total_time"] = total_time
stats_total["ls_time"] = kmedkpmtime
stats_total['peak_memory'] = process.memory_info().rss/(1024*1024)
stats_total['virtual_memory'] = process.memory_info().vms/(1024*1024)
stats_total['cost'] = total_cost
return stats_total
#end lp_ls_complete()
def test_lp_ls_complete():
#random number generator seeds
gen_seed = 12312321
dist_matrix_seed = random.randint(1, int(pow(2, 32)-1))
local_search_seed = random.randint(1, int(pow(2, 32)-1))
#initialize
logfile = sys.stdout
n = 100
t = 3
k = 3
d = 2
r_max = 3
r_min = 1
max_freq = 3
data, _ = make_blobs(n_samples=n, centers=k, n_features=d,
random_state=12312, cluster_std=0.8)
#generate instance and time it
time_buf = time.time()
color_mat, rvec, _ = generator.get_feasible_instance(
t,
n,
r_max,
r_min,
max_freq,
k,
gen_seed,
unique=False)
lp_ls_complete(data, color_mat, rvec, k, logfile)
#end es_fpt_3apx_complete_test()
################################################################################
if __name__ == '__main__':
test_lp_ls_complete()
|
[
"feasibility.calculate",
"kmedkpm.k_median_k_partitions_LS",
"psutil.Process",
"sklearn.datasets.make_blobs",
"generator.get_feasible_instance",
"numpy.stack",
"local_search.kmedian_local_search",
"time.time"
] |
[((865, 881), 'psutil.Process', 'psutil.Process', ([], {}), '()\n', (879, 881), False, 'import psutil\n'), ((895, 906), 'time.time', 'time.time', ([], {}), '()\n', (904, 906), False, 'import time\n'), ((922, 933), 'time.time', 'time.time', ([], {}), '()\n', (931, 933), False, 'import time\n'), ((952, 1056), 'feasibility.calculate', 'feasibility.calculate', (['k', 'rvec', 'color_mat', 'command', 'return_solution', 'logfile', 'many_solutions_lp_only'], {}), '(k, rvec, color_mat, command, return_solution, logfile,\n many_solutions_lp_only)\n', (973, 1056), False, 'import feasibility\n'), ((1588, 1599), 'time.time', 'time.time', ([], {}), '()\n', (1597, 1599), False, 'import time\n'), ((3053, 3142), 'sklearn.datasets.make_blobs', 'make_blobs', ([], {'n_samples': 'n', 'centers': 'k', 'n_features': 'd', 'random_state': '(12312)', 'cluster_std': '(0.8)'}), '(n_samples=n, centers=k, n_features=d, random_state=12312,\n cluster_std=0.8)\n', (3063, 3142), False, 'from sklearn.datasets import make_blobs\n'), ((3218, 3229), 'time.time', 'time.time', ([], {}), '()\n', (3227, 3229), False, 'import time\n'), ((3255, 3347), 'generator.get_feasible_instance', 'generator.get_feasible_instance', (['t', 'n', 'r_max', 'r_min', 'max_freq', 'k', 'gen_seed'], {'unique': '(False)'}), '(t, n, r_max, r_min, max_freq, k, gen_seed,\n unique=False)\n', (3286, 3347), False, 'import generator\n'), ((1982, 2048), 'kmedkpm.k_median_k_partitions_LS', 'k_median_k_partitions_LS', (['E', 'data', 'None', 'N', 'd', 'k'], {'is_coreset': '(False)'}), '(E, data, None, N, d, k, is_coreset=False)\n', (2006, 2048), False, 'from kmedkpm import k_median_k_partitions_LS\n'), ((2147, 2158), 'time.time', 'time.time', ([], {}), '()\n', (2156, 2158), False, 'import time\n'), ((2187, 2198), 'time.time', 'time.time', ([], {}), '()\n', (2196, 2198), False, 'import time\n'), ((2249, 2278), 'local_search.kmedian_local_search', 'kmedian_local_search', (['data', 'k'], {}), '(data, k)\n', (2269, 2278), False, 'from local_search import kmedian_local_search\n'), ((1427, 1453), 'numpy.stack', 'np.stack', (['solution'], {'axis': '(0)'}), '(solution, axis=0)\n', (1435, 1453), True, 'import numpy as np\n')]
|
import numpy as np
import pandas as pd
import datetime
import json
class DateTimeTransformer(object):
def __init__(self):
self._new_columns = []
self._old_column = None
self._min_datetime = None
self._transforms = []
def fit(self, X, column):
self._old_column = column
self._min_datetime = np.min(X[column])
values = X[column].dt.year
if len(np.unique(values)) > 1:
self._transforms += ["year"]
new_column = column + "_Year"
self._new_columns += [new_column]
values = X[column].dt.month
if len(np.unique(values)) > 1:
self._transforms += ["month"]
new_column = column + "_Month"
self._new_columns += [new_column]
values = X[column].dt.day
if len(np.unique(values)) > 1:
self._transforms += ["day"]
new_column = column + "_Day"
self._new_columns += [new_column]
values = X[column].dt.weekday
if len(np.unique(values)) > 1:
self._transforms += ["weekday"]
new_column = column + "_WeekDay"
self._new_columns += [new_column]
values = X[column].dt.dayofyear
if len(np.unique(values)) > 1:
self._transforms += ["dayofyear"]
new_column = column + "_DayOfYear"
self._new_columns += [new_column]
values = X[column].dt.hour
if len(np.unique(values)) > 1:
self._transforms += ["hour"]
new_column = column + "_Hour"
self._new_columns += [new_column]
values = (X[column] - self._min_datetime).dt.days
if len(np.unique(values)) > 1:
self._transforms += ["days_diff"]
new_column = column + "_Days_Diff_To_Min"
self._new_columns += [new_column]
def transform(self, X):
column = self._old_column
if "year" in self._transforms:
new_column = column + "_Year"
X[new_column] = X[column].dt.year
if "month" in self._transforms:
new_column = column + "_Month"
X[new_column] = X[column].dt.month
if "day" in self._transforms:
new_column = column + "_Day"
X[new_column] = X[column].dt.day
if "weekday" in self._transforms:
new_column = column + "_WeekDay"
X[new_column] = X[column].dt.weekday
if "dayofyear" in self._transforms:
new_column = column + "_DayOfYear"
X[new_column] = X[column].dt.dayofyear
if "hour" in self._transforms:
new_column = column + "_Hour"
X[new_column] = X[column].dt.hour
if "days_diff" in self._transforms:
new_column = column + "_Days_Diff_To_Min"
X[new_column] = (X[column] - self._min_datetime).dt.days
X.drop(column, axis=1, inplace=True)
return X
def to_json(self):
return {
"new_columns": list(self._new_columns),
"old_column": self._old_column,
"min_datetime": str(self._min_datetime),
"transforms": list(self._transforms),
}
def from_json(self, data_json):
self._new_columns = data_json.get("new_columns", None)
self._old_column = data_json.get("old_column", None)
d = data_json.get("min_datetime", None)
self._min_datetime = None if d is None else pd.to_datetime(d)
self._transforms = data_json.get("transforms", [])
|
[
"numpy.unique",
"pandas.to_datetime",
"numpy.min"
] |
[((349, 366), 'numpy.min', 'np.min', (['X[column]'], {}), '(X[column])\n', (355, 366), True, 'import numpy as np\n'), ((3456, 3473), 'pandas.to_datetime', 'pd.to_datetime', (['d'], {}), '(d)\n', (3470, 3473), True, 'import pandas as pd\n'), ((418, 435), 'numpy.unique', 'np.unique', (['values'], {}), '(values)\n', (427, 435), True, 'import numpy as np\n'), ((623, 640), 'numpy.unique', 'np.unique', (['values'], {}), '(values)\n', (632, 640), True, 'import numpy as np\n'), ((828, 845), 'numpy.unique', 'np.unique', (['values'], {}), '(values)\n', (837, 845), True, 'import numpy as np\n'), ((1033, 1050), 'numpy.unique', 'np.unique', (['values'], {}), '(values)\n', (1042, 1050), True, 'import numpy as np\n'), ((1248, 1265), 'numpy.unique', 'np.unique', (['values'], {}), '(values)\n', (1257, 1265), True, 'import numpy as np\n'), ((1462, 1479), 'numpy.unique', 'np.unique', (['values'], {}), '(values)\n', (1471, 1479), True, 'import numpy as np\n'), ((1689, 1706), 'numpy.unique', 'np.unique', (['values'], {}), '(values)\n', (1698, 1706), True, 'import numpy as np\n')]
|
from flask import Flask, request, render_template, send_file, Response
import io
import base64
import csv
import json
import time
from collections import OrderedDict
import numpy
import pandas as pd
from numpy import genfromtxt
from flask import jsonify
from flask_cors import CORS
from LoadingNetwork import EchoWebSocket
import shutil
import gc
from tornado.wsgi import WSGIContainer
from tornado.web import Application, FallbackHandler
from tornado.websocket import WebSocketHandler
from tornado.ioloop import IOLoop
app = Flask('flasknado')
#app = Flask(__name__)
app.debug = True
CORS(app)
##initial netwrok csv data############################
rawdata = open('NetworkWithDistance.txt')
with open('NetworkWithDistance.txt') as f:
rawdata = f.readlines()
# you may also want to remove whitespace characters like `\n` at the end
# of each line
rawdata = [x.strip() for x in rawdata]
my_data = genfromtxt('networkwithdist.csv', delimiter=',')
# my_data=numpy.delete(my_data,(0),axis=0)
header = ['id', 'id_to', 'lon', 'lat', 'basinid']
frame = pd.DataFrame(my_data, columns=header)
data = []
MY_GLOBAL = []
with open('tempcsv.csv') as f:
for line in f:
temp = line.strip().split(',')
data.append(temp)
#############################
data1 = []
with open('MyFile1.txt') as f:
r = 0
for line in f:
if(r > 0):
data2 = []
# print(line)
temp = line.split("\",")
data2.append(temp[0][1:])
temp1 = temp[1].split(",[")
data2.append(temp1[0])
data2.append(temp1[1][:-2])
data1.append(data2)
r += 1
header = ['celllist', 'cellid', 'cellto']
frame_celllist = pd.DataFrame(data1, columns=header)
frame_celllist = frame_celllist.drop_duplicates()
del data1[:]
##################
data_c = []
with open('powerplant_cell_loc.csv') as f:
r = 0
for line in f:
if(r > 0):
data_cc = line.split(",")
data_c.append(data_cc)
# print(line)
r += 1
header = ['cellid', 'loc']
frame_cell = pd.DataFrame(data_c, columns=header)
frame_cell = frame_cell.drop_duplicates()
del data_c[:]
########################################################
import os
import sys
from SimpleHTTPServer import SimpleHTTPRequestHandler
import BaseHTTPServer
# class MyHTTPRequestHandler(SimpleHTTPRequestHandler):
# def translate_path(self,path):
# path = SimpleHTTPRequestHandler.translate_path(self,path)
# if os.path.isdir(path):
# for base in "index", "default":
# for ext in ".html", ".htm", ".txt":
# index = path + "/" + base + ext
# if os.path.exists(index):
# return index
# return path
# def test(HandlerClass = MyHTTPRequestHandler,
# ServerClass = BaseHTTPServer.HTTPServer):
# BaseHTTPServer.test(HandlerClass, ServerClass)
##################travesal network upstream############
'''def find_upstream(value):
gc.collect()
ii=0
li = []
temp=[]
a=frame.ix[int(value)]
temp.append(a)
#print(MY_GLOBAL)
MY_GLOBAL[:]=[]
#x=data[int(value)]
#x=frame[frame['id']==a['id_to']]
#print x
i=0
z=0
zz=0
while zz<len(temp):
item=temp[zz]
zz+=1
##print(z,len(temp))
## item=temp.pop()
## print item
#x=frame[frame['id_to']==item['id']]
x=data[int(float(item['id']))]
#print x
i=1
while i<len(x) :
# d = OrderedDict()
# xx=x.loc[x.index[i]]
xx=frame.ix[int(float(x[i]))]
# d['type'] = 'Feature'
# d['geometry'] = {
# 'type': 'MultiLineString',
# 'coordinates': [[[float(xx['lon']),float(xx['lat'])],[float(item['lon']), float(item['lat'])]]]
# }
# d['properties'] = { "id":int(xx['id']),"id_to":int(xx['id_to']),"lon": float(xx['lon']),"lat": float(xx['lat'])
# }
# li.append(d)
i+=1
# ii+=1
##if ii%1000==0:
## print ii
temp.append(xx)
print(len(temp))
while z<len(temp):
item=temp[z]
z+=1
##print(z,len(temp))
## item=temp.pop()
## print item
#x=frame[frame['id_to']==item['id']]
x=data[int(float(item['id']))]
#print x
i=1
while i<len(x) :
d = OrderedDict()
#xx=x.loc[x.index[i]]
xx=frame.ix[int(float(x[i]))]
d['type'] = 'Feature'
d['geometry'] = {
'type': 'MultiLineString',
'coordinates': [[[float(xx['lon']),float(xx['lat'])],[float(item['lon']), float(item['lat'])]]]
}
d['properties'] = { "id":int(xx['id']),"id_to":int(xx['id_to']),"lon": float(xx['lon']),"lat": float(xx['lat'])
}
li.append(d)
d = OrderedDict()
#xx=x.loc[x.index[i]]
# xx=frame.ix[int(float(x[i]))]
i+=1
ii+=1
if ii%1000==0 or (ii+1)/len(temp)==1:
MY_GLOBAL.append((int)((ii+1)/(len(temp)* 1.0)*100))
## print(checkInt,ii,len(temp))
## print ii
# temp.append(xx)
#d = OrderedDict()
#d['type'] = 'FeatureCollection'
#d['features'] = li
#print li
print(ii)
return li,200'''
def find_upstream(value):
gc.collect()
ii = 0
li = []
temp = []
a = frame.ix[int(value)]
temp.append(int(value))
MY_GLOBAL[:] = []
i = 0
z = 0
zz = 0
jstring = ''
while z < len(temp):
item = frame.ix[temp[z]]
z += 1
x = data[int(float(item['id']))]
#print x
i = 1
while i < len(x):
xx = frame.ix[int(float(x[i]))]
jstring += '{"type": "Feature","geometry": { "type": "MultiLineString", "coordinates": [[[' + str(float(xx['lon'])) + ',' + str(float(xx['lat'])) + '],[' + str(float(item['lon'])) + ',' + str(
float(item['lat'])) + ']]]},"properties": {"id_to": ' + str(int(xx['id_to'])) + ',"id":' + str(int(xx['id'])) + ',"lat":' + str(float(xx['lat'])) + ',"lon": ' + str(float(xx['lon'])) + '}},'
ii += 1
temp.append(int(float(x[i])))
i += 1
if ii % 1000 == 0:
# print(ii)
MY_GLOBAL.append((int)((ii + 1) / (200000 * 1.0) * 100))
# print(checkInt,ii,len(temp))
## print ii
# temp.append(xx)
#d = OrderedDict()
#d['type'] = 'FeatureCollection'
#d['features'] = li
#print li
# print(jstring)
MY_GLOBAL.append(100)
return jstring[:-1], 200
##################travesal network downstream############
def find_downstream(value, sourceid):
#print value,sourceid
ii = 0
li = []
temp = []
jstring = ''
# MY_GLOBAL[:]=[]
a = frame.ix[int(value)]
temp.append(a)
check = True
z = 0
while z < len(temp) and check:
item = temp[z]
z += 1
if(item['id_to'] == sourceid):
check = False
# break
## print item
# if(item['id']==sourceid):
# check=False
x = frame.ix[frame['id'] == item['id_to']]
#print x
i = 0
while i < len(x):
# d = OrderedDict()
xx = x.ix[x.index[i]]
jstring += '{"type": "Feature","geometry": { "type": "MultiLineString", "coordinates": [[[' + str(float(xx['lon'])) + ',' + str(float(xx['lat'])) + '],[' + str(float(item['lon'])) + ',' + str(
float(item['lat'])) + ']]]},"properties": {"id_to": ' + str(int(xx['id_to'])) + ',"id":' + str(int(xx['id'])) + ',"lat":' + str(float(xx['lat'])) + ',"lon": ' + str(float(xx['lon'])) + '}},'
# d['type'] = 'Feature'
# d['geometry'] = {
# 'type': 'MultiLineString',
# 'coordinates': [[[float(xx['lon']),float(xx['lat'])],[float(item['lon']), float(item['lat'])]]]
# }
# d['properties'] = { "id":int(xx['id']),"id_to":int(xx['id_to']),"lon": float(xx['lon']),"lat": float(xx['lat'])
# }
# li.append(d)
# d=OrderedDict()
i += 1
ii += 1
temp.append(xx)
# if(item['id']==sourceid):
# check=False
# MY_GLOBAL.append(100)
# d = OrderedDict()
# d['type'] = 'FeatureCollection'
# d['features'] = li
# print li
# if (check==False):
return jstring[:-1], 200
##################travesal network downstream############
def find_downstream1(value):
#print value,sourceid
ii = 0
li = []
temp = []
jstring = ''
# MY_GLOBAL[:]=[]
a = frame.ix[int(value)]
temp.append(a)
check = True
z = 0
while z < len(temp) and check:
item = temp[z]
z += 1
## print item
# if(item['id']==sourceid):
# check=False
x = frame.ix[frame['id'] == item['id_to']]
#print x
i = 0
while i < len(x):
# d = OrderedDict()
xx = x.ix[x.index[i]]
jstring += '{"type": "Feature","geometry": { "type": "MultiLineString", "coordinates": [[[' + str(float(xx['lon'])) + ',' + str(float(xx['lat'])) + '],[' + str(float(item['lon'])) + ',' + str(
float(item['lat'])) + ']]]},"properties": {"id_to": ' + str(int(xx['id_to'])) + ',"id":' + str(int(xx['id'])) + ',"lat":' + str(float(xx['lat'])) + ',"lon": ' + str(float(xx['lon'])) + '}},'
# d['type'] = 'Feature'
# d['geometry'] = {
# 'type': 'MultiLineString',
# 'coordinates': [[[float(xx['lon']),float(xx['lat'])],[float(item['lon']), float(item['lat'])]]]
# }
# d['properties'] = { "id":int(xx['id']),"id_to":int(xx['id_to']),"lon": float(xx['lon']),"lat": float(xx['lat'])
# }
# li.append(d)
# d=OrderedDict()
i += 1
ii += 1
temp.append(xx)
# if(item['id']==sourceid):
# check=False
# MY_GLOBAL.append(100)
# d = OrderedDict()
# d['type'] = 'FeatureCollection'
# d['features'] = li
# print li
# if (check==False):
return jstring[:-1], 200
#######################pp upstream#######################
def find_upstream_pp(cellid):
gc.collect()
# header=['celllist','cellid','cellto']
# header=['cellid','loc']
templi = frame_celllist[frame_celllist['cellid']
== cellid]['celllist'].tolist()
templist = templi[0][1:-1].split(",")
z = 0
jstring = ''
while z < len(templist):
curid = templist[z].strip()
# print(curid,templist)
curidloc = frame_cell[frame_cell['cellid'] == curid]['loc'].tolist()
curidloc1 = curidloc[0].split("_")
# print(curidloc1[0],curidloc1[1][:-1],curidloc[0])
z += 1
temp = frame_celllist[frame_celllist['cellid']
== curid]['cellto'].tolist()
print(temp)
temp = temp[0].split(",")
if len(temp) == 1 and temp[0][:-1] == "none":
# print(temp[0])
continue
else:
zz = 0
while zz < len(temp):
# print(temp[zz],temp)
x = temp[zz]
zz += 1
if zz == len(temp):
nextloc = frame_cell[frame_cell['cellid']
== x[:-1]]['loc'].tolist()
else:
nextloc = frame_cell[frame_cell['cellid']
== x]['loc'].tolist()
nextloc1 = nextloc[0].split("_")
# print(nextloc1[0],nextloc1[1][:-1],nextloc1)
jstring += '{"type": "Feature","geometry": { "type": "MultiLineString", "coordinates": [[[' + str(curidloc1[0]) + ',' + str(curidloc1[1][:-1]) + '],[' + str(
nextloc1[0]) + ',' + str(nextloc1[1][:-1]) + ']]]},"properties": {"lat":' + str(curidloc1[1][:-1]) + ',"lon": ' + str(curidloc1[0]) + '}},'
# jstring+='{"type": "Feature","geometry": { "type": "MultiLineString", "coordinates": [[['+str(float(xx['lon']))+','+str(float(xx['lat']))+'],['+str(float(item['lon']))+','+str(float(item['lat']))+']]]},"properties": {"id_to": '+str(int(xx['id_to']))+',"id":'+str(int(xx['id']))+',"lat":'+str(float(xx['lat']))+',"lon": '+str(float(xx['lon']))+'}},';
return jstring[:-1], 200
#######################pp downstream#######################
def find_downstream_pp(cellid, dcellid):
gc.collect()
# header=['celllist','cellid','cellto']
# header=['cellid','loc']
print(cellid, dcellid)
templi = frame_celllist[frame_celllist['cellid']
== cellid]['celllist'].tolist()
templist = templi[0][1:-1].split(",")
z = len(templist) - 1
jstring = ''
while z > 0:
print(templist[z].strip())
curid = templist[z].strip()
if curid != str(dcellid):
z -= 1
else:
print(z)
break
while z > 0:
curid = templist[z].strip()
# print(curid,templist)
curidloc = frame_cell[frame_cell['cellid'] == curid]['loc'].tolist()
curidloc1 = curidloc[0].split("_")
# print(curidloc1[0],curidloc1[1][:-1],curidloc[0])
temp = frame_celllist[frame_celllist['cellid']
== templist[z].strip()]['cellto'].tolist()
z -= 1
print(temp)
temp = temp[0].split(",")
if len(temp) == 1 and temp[0][:-1] == "none":
# print(temp[0])
z -= 1
continue
else:
zz = 0
aaaa = 'false'
while zz < len(temp):
# print(temp[zz],temp)
x = temp[zz]
zz += 1
if zz == len(temp):
if x[:-1] == curid:
aaaa = 'true'
nextloc = frame_cell[frame_cell['cellid']
== x[:-1]]['loc'].tolist()
else:
if x == curid:
aaaa = 'true'
nextloc = frame_cell[frame_cell['cellid']
== x]['loc'].tolist()
if aaaa == 'true':
nextloc1 = nextloc[0].split("_")
# print(nextloc1[0],nextloc1[1][:-1],nextloc1)
jstring += '{"type": "Feature","geometry": { "type": "MultiLineString", "coordinates": [[[' + str(curidloc1[0]) + ',' + str(curidloc1[1][:-1]) + '],[' + str(
nextloc1[0]) + ',' + str(nextloc1[1][:-1]) + ']]]},"properties": {"lat":' + str(curidloc1[1][:-1]) + ',"lon": ' + str(curidloc1[0]) + '}},'
# jstring+='{"type": "Feature","geometry": { "type": "MultiLineString", "coordinates": [[['+str(float(xx['lon']))+','+str(float(xx['lat']))+'],['+str(float(item['lon']))+','+str(float(item['lat']))+']]]},"properties": {"id_to": '+str(int(xx['id_to']))+',"id":'+str(int(xx['id']))+',"lat":'+str(float(xx['lat']))+',"lon": '+str(float(xx['lon']))+'}},';
print(jstring)
if len(jstring) > 0:
return jstring[:-1], 200
else:
return jstring, 200
@app.route("/", methods=['GET', 'POST'])
def index():
print(request)
return render_template('test1.html')
@app.route("/api/", methods=['GET', 'POST'])
def update():
print(request.method)
if request.method == "POST":
source = request.form["source"]
dist = request.form["dist"]
pic = request.form["pic"]
downfirst = request.form["downfirst"]
pp = request.form["pp"]
print(pp, source, dist, downfirst, pic)
if(pp == 'yes'):
upstream = request.form["upstream"]
if(upstream == 'yes'):
ucellid = request.form["ucellid"]
re, ii = find_upstream_pp(ucellid)
# print(re)
return json.dumps(re), ii
# if(upstream=='no'):
### ucellid = request.form["ucellid"]
# dcellid = request.form["dcellid"]
# re,ii=find_downstream_pp(ucellid,dcellid)
# print(re)
# if(pp=='no'):
source = request.form["source"]
dist = request.form["dist"]
pic = request.form["pic"]
downfirst = request.form["downfirst"]
#print dist
if(downfirst == 'no'):
if(source == 'yes'):
sourceid = request.form["sourceid"]
#print sourceid
import time
start = time. time()
re, ii = find_upstream(sourceid)
end = time. time()
#print ii,(end-start)
# print(re)
# print(MY_GLOBAL)
return json.dumps(re), ii
if(dist == 'yes'):
distid = request.form["distid"]
sourceid = request.form["sourceid"]
MY_GLOBAL[:] = []
#print distid,sourceid
re, ii = find_downstream(int(distid), int(sourceid))
print (re)
gc.collect()
MY_GLOBAL.append(100)
return json.dumps(re, sort_keys=False, indent=4), ii
if(downfirst == 'yes'):
if(dist == 'yes'):
distid = request.form["distid"]
sourceid = request.form["sourceid"]
MY_GLOBAL[:] = []
#print distid,sourceid
re, ii = find_downstream1(int(distid))
print (re)
gc.collect()
MY_GLOBAL.append(100)
return json.dumps(re, sort_keys=False, indent=4), ii
if(pic == 'yes'):
#print request.form
MY_GLOBAL[:] = []
start1 = request.form["dist_lat"]
start2 = request.form["dist_lon"]
goal1 = request.form["source_lat"]
goal2 = request.form["source_lon"]
fromdate = request.form["from"]
todate = request.form["to"]
import time
before = time.time()
output, str1, str2, str3 = LoadingNetwork.main(
[start1, start2], [goal1, goal2], fromdate, todate, rawdata)
#print str1,str2,str3
after = time.time()
print ("time,", after - before)
if(isinstance(output, str)):
return output, 201
else:
# gc.collect()
#print base64.b64encode(output.getvalue())
return base64.b64encode(
output.getvalue()) + "***" + str1 + "***" + str2 + "***" + str3, 200
class WebSocket(WebSocketHandler):
def on_message(self, message):
# self.write_message("Received: " + message)
# self.write_message("Received2: " + message)
# m=message.split("&")
print("Received message: " + m[0])
print("Received message: " + m[1])
print("Received message: " + m[2])
print("Received message: " + m[3])
print("Received message: " + m[4])
print("Received message: " + m[5])
print("Received message: " + m[6])
m=message[1:-1].split("&")
source = m[0].split("=")[1]
value = m[1].split("=")[1]
dist = m[2].split("=")[1]
value1 = m[3].split("=")[1]
pic = m[4].split("=")[1]
downfirst = m[5].split("=")[1]
pp = m[6].split("=")
print(pp, source, dist, downfirst, pic,value,value1)
###################################upstram##########################3
if(downfirst == 'no'):
if(source == 'yes'):
##################
gc.collect()
ii = 0
li = []
temp = []
a = frame.ix[int(value)]
temp.append(int(value))
i = 0
z = 0
zz = 0
jstring = ''
while z < len(temp):
item = frame.ix[temp[z]]
z += 1
x = data[int(float(item['id']))]
#print x
i = 1
while i < len(x):
xx = frame.ix[int(float(x[i]))]
jstring += '{"type": "Feature","geometry": { "type": "MultiLineString", "coordinates": [[[' + str(float(xx['lon'])) + ',' + str(float(xx['lat'])) + '],[' + str(float(item['lon'])) + ',' + str(
float(item['lat'])) + ']]]},"properties": {"id_to": ' + str(int(xx['id_to'])) + ',"id":' + str(int(xx['id'])) + ',"lat":' + str(float(xx['lat'])) + ',"lon": ' + str(float(xx['lon'])) + '}},'
ii += 1
temp.append(int(float(x[i])))
i += 1
if(len(jstring)>1500000):
zz+=5
self.write_message( jstring[:-1])
self.write_message( '~'+str(zz*1.0/100))
jstring = ''
self.write_message( jstring[:-1])
self.write_message( '~1')
############################downstream#########################
if(dist == 'yes'):
########################################################################
ii = 0
li = []
temp = []
jstring = ''
# MY_GLOBAL[:]=[]
a = frame.ix[int(value1)]
temp.append(a)
check = True
z = 0
zz=0
while z < len(temp) and check:
item = temp[z]
z += 1
if(item['id_to'] == int(value)):
check = False
x = frame.ix[frame['id'] == item['id_to']]
#print x
i = 0
while i < len(x):
# d = OrderedDict()
xx = x.ix[x.index[i]]
jstring += '{"type": "Feature","geometry": { "type": "MultiLineString", "coordinates": [[[' + str(float(xx['lon'])) + ',' + str(float(xx['lat'])) + '],[' + str(float(item['lon'])) + ',' + str(
float(item['lat'])) + ']]]},"properties": {"id_to": ' + str(int(xx['id_to'])) + ',"id":' + str(int(xx['id'])) + ',"lat":' + str(float(xx['lat'])) + ',"lon": ' + str(float(xx['lon'])) + '}},'
i += 1
ii += 1
temp.append(xx)
if(len(jstring)>150000):
zz+=5
self.write_message( jstring[:-1])
self.write_message( '~'+str(zz*1.0/100))
jstring = ''
self.write_message( jstring[:-1])
self.write_message( '~1')
##########################downfirst##############################################
if(downfirst == 'yes'):
if(dist == 'yes'):
ii = 0
li = []
temp = []
jstring = ''
# MY_GLOBAL[:]=[]
a = frame.ix[int(value1)]
temp.append(a)
z = 0
zz=0
while z < len(temp) :
item = temp[z]
z += 1
# break
## print item
# if(item['id']==sourceid):
# check=False
x = frame.ix[frame['id'] == item['id_to']]
#print x
i = 0
while i < len(x):
# d = OrderedDict()
xx = x.ix[x.index[i]]
jstring += '{"type": "Feature","geometry": { "type": "MultiLineString", "coordinates": [[[' + str(float(xx['lon'])) + ',' + str(float(xx['lat'])) + '],[' + str(float(item['lon'])) + ',' + str(
float(item['lat'])) + ']]]},"properties": {"id_to": ' + str(int(xx['id_to'])) + ',"id":' + str(int(xx['id'])) + ',"lat":' + str(float(xx['lat'])) + ',"lon": ' + str(float(xx['lon'])) + '}},'
# d['type'] = 'Feature'
# d['geometry'] = {
# 'type': 'MultiLineString',
# 'coordinates': [[[float(xx['lon']),float(xx['lat'])],[float(item['lon']), float(item['lat'])]]]
# }
# d['properties'] = { "id":int(xx['id']),"id_to":int(xx['id_to']),"lon": float(xx['lon']),"lat": float(xx['lat'])
# }
# li.append(d)
# d=OrderedDict()
i += 1
ii += 1
temp.append(xx)
# if(item['id']==sourceid):
# check=False
# MY_GLOBAL.append(100)
# d = OrderedDict()
# d['type'] = 'FeatureCollection'
# d['features'] = li
# print li
# if (check==False):
if(len(jstring)>150000):
zz+=5
self.write_message( jstring[:-1])
self.write_message( '~'+str(zz*1.0/100))
jstring = ''
self.write_message( jstring[:-1])
self.write_message( '~1')
# if(downfirst == 'yes'):
if(pic == 'yes'):
#print request.form
#"&dist_lat="+dist_lat+"&dist_lon="+dist_lon+"&source_lat="+source_lat+"&source_lon="+source_lon+"&from="+value3.value+"&to="+value4.value);
#m[6].split("=")
# start1 = request.form["dist_lat"]
# start2 = request.form["dist_lon"]
# goal1 = request.form["source_lat"]
# goal2 = request.form["source_lon"]
# fromdate = request.form["from"]
# todate = request.form["to"]
start1 = m[7].split("=")[1]
start2 = m[8].split("=")[1]
goal1 =m[9].split("=")[1]
goal2 = m[10].split("=")[1]
fromdate = m[11].split("=")[1]
todate = m[12].split("=")[1]
print(start1,start2,goal1,goal2,fromdate,todate)
import time
before = time.time()
output, str1, str2, str3 = LoadingNetwork.main(
[start1, start2], [goal1, goal2], fromdate, todate, rawdata)
#print str1,str2,str3
# print(output)
after = time.time()
print ("time,", after - before)
# if(isinstance(output, str)):
# return output, 201
# else:
# gc.collect()
#print base64.b64encode(output.getvalue())
# return base64.b64encode(
# output.getvalue()) + "***" + str1 + "***" + str2 + "***" + str3, 200
#
if __name__ == "__main__":
container = WSGIContainer(app)
server = Application([
(r'/websocket/', WebSocket),
(r'/we/', EchoWebSocket),
(r'.*', FallbackHandler, dict(fallback=container))
])
server.listen(5000)
IOLoop.instance().start()
# test()
|
[
"flask.render_template",
"flask_cors.CORS",
"flask.Flask",
"json.dumps",
"tornado.ioloop.IOLoop.instance",
"gc.collect",
"time.time",
"pandas.DataFrame",
"tornado.wsgi.WSGIContainer",
"numpy.genfromtxt"
] |
[((547, 565), 'flask.Flask', 'Flask', (['"""flasknado"""'], {}), "('flasknado')\n", (552, 565), False, 'from flask import Flask, request, render_template, send_file, Response\n'), ((609, 618), 'flask_cors.CORS', 'CORS', (['app'], {}), '(app)\n', (613, 618), False, 'from flask_cors import CORS\n'), ((936, 984), 'numpy.genfromtxt', 'genfromtxt', (['"""networkwithdist.csv"""'], {'delimiter': '""","""'}), "('networkwithdist.csv', delimiter=',')\n", (946, 984), False, 'from numpy import genfromtxt\n'), ((1089, 1126), 'pandas.DataFrame', 'pd.DataFrame', (['my_data'], {'columns': 'header'}), '(my_data, columns=header)\n', (1101, 1126), True, 'import pandas as pd\n'), ((1751, 1786), 'pandas.DataFrame', 'pd.DataFrame', (['data1'], {'columns': 'header'}), '(data1, columns=header)\n', (1763, 1786), True, 'import pandas as pd\n'), ((2140, 2176), 'pandas.DataFrame', 'pd.DataFrame', (['data_c'], {'columns': 'header'}), '(data_c, columns=header)\n', (2152, 2176), True, 'import pandas as pd\n'), ((5483, 5495), 'gc.collect', 'gc.collect', ([], {}), '()\n', (5493, 5495), False, 'import gc\n'), ((10571, 10583), 'gc.collect', 'gc.collect', ([], {}), '()\n', (10581, 10583), False, 'import gc\n'), ((12856, 12868), 'gc.collect', 'gc.collect', ([], {}), '()\n', (12866, 12868), False, 'import gc\n'), ((15728, 15757), 'flask.render_template', 'render_template', (['"""test1.html"""'], {}), "('test1.html')\n", (15743, 15757), False, 'from flask import Flask, request, render_template, send_file, Response\n'), ((27708, 27726), 'tornado.wsgi.WSGIContainer', 'WSGIContainer', (['app'], {}), '(app)\n', (27721, 27726), False, 'from tornado.wsgi import WSGIContainer\n'), ((18608, 18619), 'time.time', 'time.time', ([], {}), '()\n', (18617, 18619), False, 'import time\n'), ((18815, 18826), 'time.time', 'time.time', ([], {}), '()\n', (18824, 18826), False, 'import time\n'), ((27035, 27046), 'time.time', 'time.time', ([], {}), '()\n', (27044, 27046), False, 'import time\n'), ((27269, 27280), 'time.time', 'time.time', ([], {}), '()\n', (27278, 27280), False, 'import time\n'), ((27931, 27948), 'tornado.ioloop.IOLoop.instance', 'IOLoop.instance', ([], {}), '()\n', (27946, 27948), False, 'from tornado.ioloop import IOLoop\n'), ((17046, 17057), 'time.time', 'time.time', ([], {}), '()\n', (17055, 17057), False, 'import time\n'), ((17134, 17145), 'time.time', 'time.time', ([], {}), '()\n', (17143, 17145), False, 'import time\n'), ((17606, 17618), 'gc.collect', 'gc.collect', ([], {}), '()\n', (17616, 17618), False, 'import gc\n'), ((18057, 18069), 'gc.collect', 'gc.collect', ([], {}), '()\n', (18067, 18069), False, 'import gc\n'), ((20267, 20279), 'gc.collect', 'gc.collect', ([], {}), '()\n', (20277, 20279), False, 'import gc\n'), ((16394, 16408), 'json.dumps', 'json.dumps', (['re'], {}), '(re)\n', (16404, 16408), False, 'import json\n'), ((17277, 17291), 'json.dumps', 'json.dumps', (['re'], {}), '(re)\n', (17287, 17291), False, 'import json\n'), ((17682, 17723), 'json.dumps', 'json.dumps', (['re'], {'sort_keys': '(False)', 'indent': '(4)'}), '(re, sort_keys=False, indent=4)\n', (17692, 17723), False, 'import json\n'), ((18133, 18174), 'json.dumps', 'json.dumps', (['re'], {'sort_keys': '(False)', 'indent': '(4)'}), '(re, sort_keys=False, indent=4)\n', (18143, 18174), False, 'import json\n')]
|
# Copyright (C) 2021 <NAME>
#
# SPDX-License-Identifier: MIT
from typing import Callable, Tuple, Union
import dolfinx.common as _common
import dolfinx.fem as _fem
import dolfinx.log as _log
import dolfinx.mesh as _mesh
import dolfinx_cuas
import numpy as np
import ufl
from dolfinx.cpp.graph import AdjacencyList_int32
from dolfinx.cpp.mesh import MeshTags_int32
from petsc4py import PETSc as _PETSc
import dolfinx_contact
import dolfinx_contact.cpp
from dolfinx_contact.helpers import (epsilon, lame_parameters,
rigid_motions_nullspace, sigma_func)
kt = dolfinx_contact.cpp.Kernel
__all__ = ["nitsche_unbiased"]
def nitsche_unbiased(mesh: _mesh.Mesh, mesh_tags: list[MeshTags_int32],
domain_marker: MeshTags_int32,
surfaces: AdjacencyList_int32,
dirichlet: list[Tuple[int, Callable[[np.ndarray], np.ndarray]]],
neumann: list[Tuple[int, Callable[[np.ndarray], np.ndarray]]],
contact_pairs: list[Tuple[int, int]],
body_forces: list[Tuple[int, Callable[[np.ndarray], np.ndarray]]],
physical_parameters: dict[str, Union[bool, np.float64, int]],
nitsche_parameters: dict[str, np.float64],
quadrature_degree: int = 5, form_compiler_params: dict = None, jit_params: dict = None,
petsc_options: dict = None, newton_options: dict = None, initial_guess=None,
outfile: str = None, order: int = 1) -> Tuple[_fem.Function, int, int, float]:
"""
Use custom kernel to compute the contact problem with two elastic bodies coming into contact.
Parameters
==========
mesh
The input mesh
mesh_tags
A list of meshtags. The first element must contain the mesh_tags for all puppet surfaces,
Dirichlet-surfaces and Neumann-surfaces
All further elements may contain candidate_surfaces
domain_marker
marker for subdomains where a body force is applied
surfaces
Adjacency list. Links of i are meshtag values for contact surfaces in ith mesh_tag in mesh_tags
dirichlet
List of Dirichlet boundary conditions as pairs of (meshtag value, function), where function
is a function to be interpolated into the dolfinx function space
neumann
Same as dirichlet for Neumann boundary conditions
contact_pairs:
list of pairs (i, j) marking the ith surface as a puppet surface and the jth surface
as the corresponding candidate surface
physical_parameters
Optional dictionary with information about the linear elasticity problem.
Valid (key, value) tuples are: ('E': float), ('nu', float), ('strain', bool)
nitsche_parameters
Optional dictionary with information about the Nitsche configuration.
Valid (keu, value) tuples are: ('gamma', float), ('theta', float) where theta can be -1, 0 or 1 for
skew-symmetric, penalty like or symmetric enforcement of Nitsche conditions
displacement
The displacement enforced on Dirichlet boundary
quadrature_degree
The quadrature degree to use for the custom contact kernels
form_compiler_params
Parameters used in FFCX compilation of this form. Run `ffcx --help` at
the commandline to see all available options. Takes priority over all
other parameter values, except for `scalar_type` which is determined by
DOLFINX.
jit_params
Parameters used in CFFI JIT compilation of C code generated by FFCX.
See https://github.com/FEniCS/dolfinx/blob/main/python/dolfinx/jit.py
for all available parameters. Takes priority over all other parameter values.
petsc_options
Parameters that is passed to the linear algebra backend
PETSc. For available choices for the 'petsc_options' kwarg,
see the `PETSc-documentation
<https://petsc4py.readthedocs.io/en/stable/manual/ksp/>`
newton_options
Dictionary with Newton-solver options. Valid (key, item) tuples are:
("atol", float), ("rtol", float), ("convergence_criterion", "str"),
("max_it", int), ("error_on_nonconvergence", bool), ("relaxation_parameter", float)
initial_guess
A functon containing an intial guess to use for the Newton-solver
outfile
File to append solver summary
order
The order of mesh and function space
"""
form_compiler_params = {} if form_compiler_params is None else form_compiler_params
jit_params = {} if jit_params is None else jit_params
petsc_options = {} if petsc_options is None else petsc_options
newton_options = {} if newton_options is None else newton_options
strain = physical_parameters.get("strain")
if strain is None:
raise RuntimeError("Need to supply if problem is plane strain (True) or plane stress (False)")
else:
plane_strain = bool(strain)
_E = physical_parameters.get("E")
if _E is not None:
E = np.float64(_E)
else:
raise RuntimeError("Need to supply Youngs modulus")
if physical_parameters.get("nu") is None:
raise RuntimeError("Need to supply Poisson's ratio")
else:
nu = physical_parameters.get("nu")
# Compute lame parameters
mu_func, lambda_func = lame_parameters(plane_strain)
mu = mu_func(E, nu)
lmbda = lambda_func(E, nu)
sigma = sigma_func(mu, lmbda)
# Nitche parameters and variables
theta = nitsche_parameters.get("theta")
if theta is None:
raise RuntimeError("Need to supply theta for Nitsche imposition of boundary conditions")
_gamma = nitsche_parameters.get("gamma")
if _gamma is None:
raise RuntimeError("Need to supply Coercivity/Stabilization parameter for Nitsche condition")
else:
gamma: np.float64 = _gamma * E
lifting = nitsche_parameters.get("lift_bc", False)
# Functions space and FEM functions
V = _fem.VectorFunctionSpace(mesh, ("CG", order))
u = _fem.Function(V)
v = ufl.TestFunction(V)
du = ufl.TrialFunction(V)
h = ufl.CellDiameter(mesh)
n = ufl.FacetNormal(mesh)
# Integration measure and ufl part of linear/bilinear form
# metadata = {"quadrature_degree": quadrature_degree}
dx = ufl.Measure("dx", domain=mesh, subdomain_data=domain_marker)
ds = ufl.Measure("ds", domain=mesh, # metadata=metadata,
subdomain_data=mesh_tags[0])
J = ufl.inner(sigma(du), epsilon(v)) * dx
F = ufl.inner(sigma(u), epsilon(v)) * dx
for contact_pair in contact_pairs:
surface_value = int(surfaces.links(0)[contact_pair[0]])
J += - 0.5 * theta * h / gamma * ufl.inner(sigma(du) * n, sigma(v) * n) * \
ds(surface_value)
F += - 0.5 * theta * h / gamma * ufl.inner(sigma(u) * n, sigma(v) * n) * \
ds(surface_value)
# Dirichle boundary conditions
bcs = []
if lifting:
tdim = mesh.topology.dim
for bc in dirichlet:
facets = mesh_tags[0].find(bc[0])
cells = _mesh.compute_incident_entities(mesh, facets, tdim - 1, tdim)
u_bc = _fem.Function(V)
u_bc.interpolate(bc[1], cells)
u_bc.x.scatter_forward()
bcs.append(_fem.dirichletbc(u_bc, _fem.locate_dofs_topological(V, tdim - 1, facets)))
else:
for bc in dirichlet:
f = _fem.Function(V)
f.interpolate(bc[1])
F += - ufl.inner(sigma(u) * n, v) * ds(bc[0])\
- theta * ufl.inner(sigma(v) * n, u - f) * \
ds(bc[0]) + gamma / h * ufl.inner(u - f, v) * ds(bc[0])
J += - ufl.inner(sigma(du) * n, v) * ds(bc[0])\
- theta * ufl.inner(sigma(v) * n, du) * \
ds(bc[0]) + gamma / h * ufl.inner(du, v) * ds(bc[0])
# Neumann boundary conditions
for bc in neumann:
g = _fem.Function(V)
g.interpolate(bc[1])
F -= ufl.inner(g, v) * ds(bc[0])
# body forces
for bf in body_forces:
f = _fem.Function(V)
f.interpolate(bf[1])
F -= ufl.inner(f, v) * dx(bf[0])
# Custom assembly
# create contact class
with _common.Timer("~Contact: Init"):
contact = dolfinx_contact.cpp.Contact(mesh_tags, surfaces, contact_pairs,
V._cpp_object, quadrature_degree=quadrature_degree)
with _common.Timer("~Contact: Distance maps"):
for i in range(len(contact_pairs)):
contact.create_distance_map(i)
# pack constants
consts = np.array([gamma, theta])
# Pack material parameters mu and lambda on each contact surface
with _common.Timer("~Contact: Interpolate coeffs (mu, lmbda)"):
V2 = _fem.FunctionSpace(mesh, ("DG", 0))
lmbda2 = _fem.Function(V2)
lmbda2.interpolate(lambda x: np.full((1, x.shape[1]), lmbda))
mu2 = _fem.Function(V2)
mu2.interpolate(lambda x: np.full((1, x.shape[1]), mu))
entities = []
with _common.Timer("~Contact: Compute active entities"):
for pair in contact_pairs:
entities.append(contact.active_entities(pair[0]))
material = []
with _common.Timer("~Contact: Pack coeffs (mu, lmbda"):
for i in range(len(contact_pairs)):
material.append(dolfinx_cuas.pack_coefficients([mu2, lmbda2], entities[i]))
# Pack celldiameter on each surface
h_packed = []
with _common.Timer("~Contact: Compute and pack celldiameter"):
surface_cells = np.unique(np.hstack([entities[i][:, 0] for i in range(len(contact_pairs))]))
h_int = _fem.Function(V2)
expr = _fem.Expression(h, V2.element.interpolation_points)
h_int.interpolate(expr, surface_cells)
for i in range(len(contact_pairs)):
h_packed.append(dolfinx_cuas.pack_coefficients([h_int], entities[i]))
# Pack gap, normals and test functions on each surface
gaps = []
normals = []
test_fns = []
with _common.Timer("~Contact: Pack gap, normals, testfunction"):
for i in range(len(contact_pairs)):
gaps.append(contact.pack_gap(i))
normals.append(contact.pack_ny(i, gaps[i]))
test_fns.append(contact.pack_test_functions(i, gaps[i]))
# Concatenate all coeffs
coeffs_const = []
for i in range(len(contact_pairs)):
coeffs_const.append(np.hstack([material[i], h_packed[i], gaps[i], normals[i], test_fns[i]]))
# Generate Jacobian data structures
J_custom = _fem.form(J, form_compiler_params=form_compiler_params, jit_params=jit_params)
with _common.Timer("~Contact: Generate Jacobian kernel"):
kernel_jac = contact.generate_kernel(kt.Jac)
with _common.Timer("~Contact: Create matrix"):
J = contact.create_matrix(J_custom)
# Generate residual data structures
F_custom = _fem.form(F, form_compiler_params=form_compiler_params, jit_params=jit_params)
with _common.Timer("~Contact: Generate residual kernel"):
kernel_rhs = contact.generate_kernel(kt.Rhs)
with _common.Timer("~Contact: Create vector"):
b = _fem.petsc.create_vector(F_custom)
@_common.timed("~Contact: Update coefficients")
def compute_coefficients(x, coeffs):
u.vector[:] = x.array
u_candidate = []
with _common.Timer("~~Contact: Pack u contact"):
for i in range(len(contact_pairs)):
u_candidate.append(contact.pack_u_contact(i, u._cpp_object, gaps[i]))
u_puppet = []
with _common.Timer("~~Contact: Pack u"):
for i in range(len(contact_pairs)):
u_puppet.append(dolfinx_cuas.pack_coefficients([u], entities[i]))
for i in range(len(contact_pairs)):
c_0 = np.hstack([coeffs_const[i], u_puppet[i], u_candidate[i]])
coeffs[i][:, :] = c_0[:, :]
@_common.timed("~Contact: Assemble residual")
def compute_residual(x, b, coeffs):
b.zeroEntries()
with _common.Timer("~~Contact: Contact contributions (in assemble vector)"):
for i in range(len(contact_pairs)):
contact.assemble_vector(b, i, kernel_rhs, coeffs[i], consts)
with _common.Timer("~~Contact: Standard contributions (in assemble vector)"):
_fem.petsc.assemble_vector(b, F_custom)
# Apply boundary condition
if lifting:
_fem.petsc.apply_lifting(b, [J_custom], bcs=[bcs], x0=[x], scale=-1.0)
b.ghostUpdate(addv=_PETSc.InsertMode.ADD, mode=_PETSc.ScatterMode.REVERSE)
_fem.petsc.set_bc(b, bcs, x, -1.0)
@_common.timed("~Contact: Assemble matrix")
def compute_jacobian_matrix(x, A, coeffs):
A.zeroEntries()
with _common.Timer("~~Contact: Contact contributions (in assemble matrix)"):
for i in range(len(contact_pairs)):
contact.assemble_matrix(A, [], i, kernel_jac, coeffs[i], consts)
with _common.Timer("~~Contact: Standard contributions (in assemble matrix)"):
_fem.petsc.assemble_matrix(A, J_custom, bcs=bcs)
A.assemble()
# coefficient arrays
num_coeffs = contact.coefficients_size()
coeffs = np.array([np.zeros((len(entities[i]), num_coeffs)) for i in range(len(contact_pairs))])
newton_solver = dolfinx_contact.NewtonSolver(mesh.comm, J, b, coeffs)
# Set matrix-vector computations
newton_solver.set_residual(compute_residual)
newton_solver.set_jacobian(compute_jacobian_matrix)
newton_solver.set_coefficients(compute_coefficients)
# Set rigid motion nullspace
null_space = rigid_motions_nullspace(V)
newton_solver.A.setNearNullSpace(null_space)
# Set Newton solver options
newton_solver.set_newton_options(newton_options)
# Set initial guess
if initial_guess is None:
u.x.array[:] = 0
else:
u.x.array[:] = initial_guess.x.array[:]
# Set Krylov solver options
newton_solver.set_krylov_options(petsc_options)
dofs_global = V.dofmap.index_map_bs * V.dofmap.index_map.size_global
_log.set_log_level(_log.LogLevel.OFF)
# Solve non-linear problem
timing_str = f"~Contact: {id(dofs_global)} Solve Nitsche"
with _common.Timer(timing_str):
n, converged = newton_solver.solve(u)
if outfile is not None:
viewer = _PETSc.Viewer().createASCII(outfile, "a")
newton_solver.krylov_solver.view(viewer)
newton_time = _common.timing(timing_str)
if not converged:
raise RuntimeError("Newton solver did not converge")
u.x.scatter_forward()
print(f"{dofs_global}\n Number of Newton iterations: {n:d}\n",
f"Number of Krylov iterations {newton_solver.krylov_iterations}\n", flush=True)
return u, n, newton_solver.krylov_iterations, newton_time[1]
|
[
"dolfinx.common.timing",
"ufl.Measure",
"numpy.hstack",
"ufl.FacetNormal",
"numpy.array",
"dolfinx.fem.petsc.set_bc",
"dolfinx_contact.NewtonSolver",
"dolfinx.fem.petsc.apply_lifting",
"dolfinx.fem.petsc.assemble_matrix",
"dolfinx_contact.cpp.Contact",
"dolfinx.fem.Expression",
"dolfinx.fem.locate_dofs_topological",
"dolfinx.fem.petsc.create_vector",
"numpy.float64",
"dolfinx_contact.helpers.sigma_func",
"ufl.inner",
"dolfinx.fem.petsc.assemble_vector",
"dolfinx.fem.VectorFunctionSpace",
"dolfinx.log.set_log_level",
"petsc4py.PETSc.Viewer",
"ufl.TestFunction",
"ufl.CellDiameter",
"dolfinx.common.Timer",
"dolfinx_contact.helpers.rigid_motions_nullspace",
"ufl.TrialFunction",
"dolfinx_contact.helpers.epsilon",
"dolfinx.fem.form",
"dolfinx.mesh.compute_incident_entities",
"dolfinx.fem.Function",
"dolfinx.fem.FunctionSpace",
"dolfinx_contact.helpers.lame_parameters",
"dolfinx_cuas.pack_coefficients",
"numpy.full",
"dolfinx.common.timed"
] |
[((5390, 5419), 'dolfinx_contact.helpers.lame_parameters', 'lame_parameters', (['plane_strain'], {}), '(plane_strain)\n', (5405, 5419), False, 'from dolfinx_contact.helpers import epsilon, lame_parameters, rigid_motions_nullspace, sigma_func\n'), ((5487, 5508), 'dolfinx_contact.helpers.sigma_func', 'sigma_func', (['mu', 'lmbda'], {}), '(mu, lmbda)\n', (5497, 5508), False, 'from dolfinx_contact.helpers import epsilon, lame_parameters, rigid_motions_nullspace, sigma_func\n'), ((6033, 6078), 'dolfinx.fem.VectorFunctionSpace', '_fem.VectorFunctionSpace', (['mesh', "('CG', order)"], {}), "(mesh, ('CG', order))\n", (6057, 6078), True, 'import dolfinx.fem as _fem\n'), ((6087, 6103), 'dolfinx.fem.Function', '_fem.Function', (['V'], {}), '(V)\n', (6100, 6103), True, 'import dolfinx.fem as _fem\n'), ((6112, 6131), 'ufl.TestFunction', 'ufl.TestFunction', (['V'], {}), '(V)\n', (6128, 6131), False, 'import ufl\n'), ((6141, 6161), 'ufl.TrialFunction', 'ufl.TrialFunction', (['V'], {}), '(V)\n', (6158, 6161), False, 'import ufl\n'), ((6171, 6193), 'ufl.CellDiameter', 'ufl.CellDiameter', (['mesh'], {}), '(mesh)\n', (6187, 6193), False, 'import ufl\n'), ((6202, 6223), 'ufl.FacetNormal', 'ufl.FacetNormal', (['mesh'], {}), '(mesh)\n', (6217, 6223), False, 'import ufl\n'), ((6355, 6415), 'ufl.Measure', 'ufl.Measure', (['"""dx"""'], {'domain': 'mesh', 'subdomain_data': 'domain_marker'}), "('dx', domain=mesh, subdomain_data=domain_marker)\n", (6366, 6415), False, 'import ufl\n'), ((6425, 6484), 'ufl.Measure', 'ufl.Measure', (['"""ds"""'], {'domain': 'mesh', 'subdomain_data': 'mesh_tags[0]'}), "('ds', domain=mesh, subdomain_data=mesh_tags[0])\n", (6436, 6484), False, 'import ufl\n'), ((8650, 8674), 'numpy.array', 'np.array', (['[gamma, theta]'], {}), '([gamma, theta])\n', (8658, 8674), True, 'import numpy as np\n'), ((10593, 10671), 'dolfinx.fem.form', '_fem.form', (['J'], {'form_compiler_params': 'form_compiler_params', 'jit_params': 'jit_params'}), '(J, form_compiler_params=form_compiler_params, jit_params=jit_params)\n', (10602, 10671), True, 'import dolfinx.fem as _fem\n'), ((10938, 11016), 'dolfinx.fem.form', '_fem.form', (['F'], {'form_compiler_params': 'form_compiler_params', 'jit_params': 'jit_params'}), '(F, form_compiler_params=form_compiler_params, jit_params=jit_params)\n', (10947, 11016), True, 'import dolfinx.fem as _fem\n'), ((11236, 11282), 'dolfinx.common.timed', '_common.timed', (['"""~Contact: Update coefficients"""'], {}), "('~Contact: Update coefficients')\n", (11249, 11282), True, 'import dolfinx.common as _common\n'), ((11937, 11981), 'dolfinx.common.timed', '_common.timed', (['"""~Contact: Assemble residual"""'], {}), "('~Contact: Assemble residual')\n", (11950, 11981), True, 'import dolfinx.common as _common\n'), ((12673, 12715), 'dolfinx.common.timed', '_common.timed', (['"""~Contact: Assemble matrix"""'], {}), "('~Contact: Assemble matrix')\n", (12686, 12715), True, 'import dolfinx.common as _common\n'), ((13361, 13414), 'dolfinx_contact.NewtonSolver', 'dolfinx_contact.NewtonSolver', (['mesh.comm', 'J', 'b', 'coeffs'], {}), '(mesh.comm, J, b, coeffs)\n', (13389, 13414), False, 'import dolfinx_contact\n'), ((13666, 13692), 'dolfinx_contact.helpers.rigid_motions_nullspace', 'rigid_motions_nullspace', (['V'], {}), '(V)\n', (13689, 13692), False, 'from dolfinx_contact.helpers import epsilon, lame_parameters, rigid_motions_nullspace, sigma_func\n'), ((14129, 14166), 'dolfinx.log.set_log_level', '_log.set_log_level', (['_log.LogLevel.OFF'], {}), '(_log.LogLevel.OFF)\n', (14147, 14166), True, 'import dolfinx.log as _log\n'), ((14497, 14523), 'dolfinx.common.timing', '_common.timing', (['timing_str'], {}), '(timing_str)\n', (14511, 14523), True, 'import dolfinx.common as _common\n'), ((5086, 5100), 'numpy.float64', 'np.float64', (['_E'], {}), '(_E)\n', (5096, 5100), True, 'import numpy as np\n'), ((7974, 7990), 'dolfinx.fem.Function', '_fem.Function', (['V'], {}), '(V)\n', (7987, 7990), True, 'import dolfinx.fem as _fem\n'), ((8119, 8135), 'dolfinx.fem.Function', '_fem.Function', (['V'], {}), '(V)\n', (8132, 8135), True, 'import dolfinx.fem as _fem\n'), ((8265, 8296), 'dolfinx.common.Timer', '_common.Timer', (['"""~Contact: Init"""'], {}), "('~Contact: Init')\n", (8278, 8296), True, 'import dolfinx.common as _common\n'), ((8316, 8436), 'dolfinx_contact.cpp.Contact', 'dolfinx_contact.cpp.Contact', (['mesh_tags', 'surfaces', 'contact_pairs', 'V._cpp_object'], {'quadrature_degree': 'quadrature_degree'}), '(mesh_tags, surfaces, contact_pairs, V.\n _cpp_object, quadrature_degree=quadrature_degree)\n', (8343, 8436), False, 'import dolfinx_contact\n'), ((8487, 8527), 'dolfinx.common.Timer', '_common.Timer', (['"""~Contact: Distance maps"""'], {}), "('~Contact: Distance maps')\n", (8500, 8527), True, 'import dolfinx.common as _common\n'), ((8754, 8811), 'dolfinx.common.Timer', '_common.Timer', (['"""~Contact: Interpolate coeffs (mu, lmbda)"""'], {}), "('~Contact: Interpolate coeffs (mu, lmbda)')\n", (8767, 8811), True, 'import dolfinx.common as _common\n'), ((8826, 8861), 'dolfinx.fem.FunctionSpace', '_fem.FunctionSpace', (['mesh', "('DG', 0)"], {}), "(mesh, ('DG', 0))\n", (8844, 8861), True, 'import dolfinx.fem as _fem\n'), ((8879, 8896), 'dolfinx.fem.Function', '_fem.Function', (['V2'], {}), '(V2)\n', (8892, 8896), True, 'import dolfinx.fem as _fem\n'), ((8981, 8998), 'dolfinx.fem.Function', '_fem.Function', (['V2'], {}), '(V2)\n', (8994, 8998), True, 'import dolfinx.fem as _fem\n'), ((9091, 9141), 'dolfinx.common.Timer', '_common.Timer', (['"""~Contact: Compute active entities"""'], {}), "('~Contact: Compute active entities')\n", (9104, 9141), True, 'import dolfinx.common as _common\n'), ((9268, 9317), 'dolfinx.common.Timer', '_common.Timer', (['"""~Contact: Pack coeffs (mu, lmbda"""'], {}), "('~Contact: Pack coeffs (mu, lmbda')\n", (9281, 9317), True, 'import dolfinx.common as _common\n'), ((9519, 9575), 'dolfinx.common.Timer', '_common.Timer', (['"""~Contact: Compute and pack celldiameter"""'], {}), "('~Contact: Compute and pack celldiameter')\n", (9532, 9575), True, 'import dolfinx.common as _common\n'), ((9694, 9711), 'dolfinx.fem.Function', '_fem.Function', (['V2'], {}), '(V2)\n', (9707, 9711), True, 'import dolfinx.fem as _fem\n'), ((9727, 9778), 'dolfinx.fem.Expression', '_fem.Expression', (['h', 'V2.element.interpolation_points'], {}), '(h, V2.element.interpolation_points)\n', (9742, 9778), True, 'import dolfinx.fem as _fem\n'), ((10070, 10128), 'dolfinx.common.Timer', '_common.Timer', (['"""~Contact: Pack gap, normals, testfunction"""'], {}), "('~Contact: Pack gap, normals, testfunction')\n", (10083, 10128), True, 'import dolfinx.common as _common\n'), ((10681, 10732), 'dolfinx.common.Timer', '_common.Timer', (['"""~Contact: Generate Jacobian kernel"""'], {}), "('~Contact: Generate Jacobian kernel')\n", (10694, 10732), True, 'import dolfinx.common as _common\n'), ((10796, 10836), 'dolfinx.common.Timer', '_common.Timer', (['"""~Contact: Create matrix"""'], {}), "('~Contact: Create matrix')\n", (10809, 10836), True, 'import dolfinx.common as _common\n'), ((11026, 11077), 'dolfinx.common.Timer', '_common.Timer', (['"""~Contact: Generate residual kernel"""'], {}), "('~Contact: Generate residual kernel')\n", (11039, 11077), True, 'import dolfinx.common as _common\n'), ((11141, 11181), 'dolfinx.common.Timer', '_common.Timer', (['"""~Contact: Create vector"""'], {}), "('~Contact: Create vector')\n", (11154, 11181), True, 'import dolfinx.common as _common\n'), ((11195, 11229), 'dolfinx.fem.petsc.create_vector', '_fem.petsc.create_vector', (['F_custom'], {}), '(F_custom)\n', (11219, 11229), True, 'import dolfinx.fem as _fem\n'), ((14269, 14294), 'dolfinx.common.Timer', '_common.Timer', (['timing_str'], {}), '(timing_str)\n', (14282, 14294), True, 'import dolfinx.common as _common\n'), ((6558, 6568), 'dolfinx_contact.helpers.epsilon', 'epsilon', (['v'], {}), '(v)\n', (6565, 6568), False, 'from dolfinx_contact.helpers import epsilon, lame_parameters, rigid_motions_nullspace, sigma_func\n'), ((6603, 6613), 'dolfinx_contact.helpers.epsilon', 'epsilon', (['v'], {}), '(v)\n', (6610, 6613), False, 'from dolfinx_contact.helpers import epsilon, lame_parameters, rigid_motions_nullspace, sigma_func\n'), ((7144, 7205), 'dolfinx.mesh.compute_incident_entities', '_mesh.compute_incident_entities', (['mesh', 'facets', '(tdim - 1)', 'tdim'], {}), '(mesh, facets, tdim - 1, tdim)\n', (7175, 7205), True, 'import dolfinx.mesh as _mesh\n'), ((7225, 7241), 'dolfinx.fem.Function', '_fem.Function', (['V'], {}), '(V)\n', (7238, 7241), True, 'import dolfinx.fem as _fem\n'), ((7475, 7491), 'dolfinx.fem.Function', '_fem.Function', (['V'], {}), '(V)\n', (7488, 7491), True, 'import dolfinx.fem as _fem\n'), ((8033, 8048), 'ufl.inner', 'ufl.inner', (['g', 'v'], {}), '(g, v)\n', (8042, 8048), False, 'import ufl\n'), ((8178, 8193), 'ufl.inner', 'ufl.inner', (['f', 'v'], {}), '(f, v)\n', (8187, 8193), False, 'import ufl\n'), ((10464, 10535), 'numpy.hstack', 'np.hstack', (['[material[i], h_packed[i], gaps[i], normals[i], test_fns[i]]'], {}), '([material[i], h_packed[i], gaps[i], normals[i], test_fns[i]])\n', (10473, 10535), True, 'import numpy as np\n'), ((11392, 11434), 'dolfinx.common.Timer', '_common.Timer', (['"""~~Contact: Pack u contact"""'], {}), "('~~Contact: Pack u contact')\n", (11405, 11434), True, 'import dolfinx.common as _common\n'), ((11605, 11639), 'dolfinx.common.Timer', '_common.Timer', (['"""~~Contact: Pack u"""'], {}), "('~~Contact: Pack u')\n", (11618, 11639), True, 'import dolfinx.common as _common\n'), ((11833, 11890), 'numpy.hstack', 'np.hstack', (['[coeffs_const[i], u_puppet[i], u_candidate[i]]'], {}), '([coeffs_const[i], u_puppet[i], u_candidate[i]])\n', (11842, 11890), True, 'import numpy as np\n'), ((12059, 12129), 'dolfinx.common.Timer', '_common.Timer', (['"""~~Contact: Contact contributions (in assemble vector)"""'], {}), "('~~Contact: Contact contributions (in assemble vector)')\n", (12072, 12129), True, 'import dolfinx.common as _common\n'), ((12269, 12340), 'dolfinx.common.Timer', '_common.Timer', (['"""~~Contact: Standard contributions (in assemble vector)"""'], {}), "('~~Contact: Standard contributions (in assemble vector)')\n", (12282, 12340), True, 'import dolfinx.common as _common\n'), ((12354, 12393), 'dolfinx.fem.petsc.assemble_vector', '_fem.petsc.assemble_vector', (['b', 'F_custom'], {}), '(b, F_custom)\n', (12380, 12393), True, 'import dolfinx.fem as _fem\n'), ((12462, 12532), 'dolfinx.fem.petsc.apply_lifting', '_fem.petsc.apply_lifting', (['b', '[J_custom]'], {'bcs': '[bcs]', 'x0': '[x]', 'scale': '(-1.0)'}), '(b, [J_custom], bcs=[bcs], x0=[x], scale=-1.0)\n', (12486, 12532), True, 'import dolfinx.fem as _fem\n'), ((12632, 12666), 'dolfinx.fem.petsc.set_bc', '_fem.petsc.set_bc', (['b', 'bcs', 'x', '(-1.0)'], {}), '(b, bcs, x, -1.0)\n', (12649, 12666), True, 'import dolfinx.fem as _fem\n'), ((12800, 12870), 'dolfinx.common.Timer', '_common.Timer', (['"""~~Contact: Contact contributions (in assemble matrix)"""'], {}), "('~~Contact: Contact contributions (in assemble matrix)')\n", (12813, 12870), True, 'import dolfinx.common as _common\n'), ((13014, 13085), 'dolfinx.common.Timer', '_common.Timer', (['"""~~Contact: Standard contributions (in assemble matrix)"""'], {}), "('~~Contact: Standard contributions (in assemble matrix)')\n", (13027, 13085), True, 'import dolfinx.common as _common\n'), ((13099, 13147), 'dolfinx.fem.petsc.assemble_matrix', '_fem.petsc.assemble_matrix', (['A', 'J_custom'], {'bcs': 'bcs'}), '(A, J_custom, bcs=bcs)\n', (13125, 13147), True, 'import dolfinx.fem as _fem\n'), ((8934, 8965), 'numpy.full', 'np.full', (['(1, x.shape[1])', 'lmbda'], {}), '((1, x.shape[1]), lmbda)\n', (8941, 8965), True, 'import numpy as np\n'), ((9033, 9061), 'numpy.full', 'np.full', (['(1, x.shape[1])', 'mu'], {}), '((1, x.shape[1]), mu)\n', (9040, 9061), True, 'import numpy as np\n'), ((9391, 9449), 'dolfinx_cuas.pack_coefficients', 'dolfinx_cuas.pack_coefficients', (['[mu2, lmbda2]', 'entities[i]'], {}), '([mu2, lmbda2], entities[i])\n', (9421, 9449), False, 'import dolfinx_cuas\n'), ((9898, 9950), 'dolfinx_cuas.pack_coefficients', 'dolfinx_cuas.pack_coefficients', (['[h_int]', 'entities[i]'], {}), '([h_int], entities[i])\n', (9928, 9950), False, 'import dolfinx_cuas\n'), ((14388, 14403), 'petsc4py.PETSc.Viewer', '_PETSc.Viewer', ([], {}), '()\n', (14401, 14403), True, 'from petsc4py import PETSc as _PETSc\n'), ((7368, 7417), 'dolfinx.fem.locate_dofs_topological', '_fem.locate_dofs_topological', (['V', '(tdim - 1)', 'facets'], {}), '(V, tdim - 1, facets)\n', (7396, 7417), True, 'import dolfinx.fem as _fem\n'), ((11721, 11769), 'dolfinx_cuas.pack_coefficients', 'dolfinx_cuas.pack_coefficients', (['[u]', 'entities[i]'], {}), '([u], entities[i])\n', (11751, 11769), False, 'import dolfinx_cuas\n'), ((7685, 7704), 'ufl.inner', 'ufl.inner', (['(u - f)', 'v'], {}), '(u - f, v)\n', (7694, 7704), False, 'import ufl\n'), ((7875, 7891), 'ufl.inner', 'ufl.inner', (['du', 'v'], {}), '(du, v)\n', (7884, 7891), False, 'import ufl\n')]
|
import numpy as np
from sklearn.metrics import average_precision_score as ap
from sklearn.metrics import roc_auc_score
"""
each row is an instance
each column is the prediction of a class
"""
def _score_to_rank(score_list):
rank_array = np.zeros([len(score_list)])
score_array = np.array(score_list)
idx_sorted = (-score_array).argsort()
rank_array[idx_sorted] = np.arange(len(score_list))+1
rank_list = rank_array.tolist()
return rank_list
# For clip evaluation
def auc_y_classwise(Y_target, Y_score):
"""
Y_target: list of lists. {0, 1}
real labels
Y_score: list of lists. real values
prediction values
"""
# Y_target = np.squeeze(np.array(Y_target))
# Y_score = np.squeeze(np.array(Y_score))
Y_target = np.array(Y_target)
Y_score = np.array(Y_score)
auc_list = roc_auc_score(Y_target, Y_score, average=None)
return auc_list
def ap_y_classwise(Y_target, Y_score):
"""
Y_target: list of lists. {0, 1}
real labels
Y_score: list of lists. real values
prediction values
"""
# Y_target = np.squeeze(np.array(Y_target))
# Y_score = np.squeeze(np.array(Y_score))
Y_target = np.array(Y_target)
Y_score = np.array(Y_score)
ap_list = ap(Y_target, Y_score, average=None)
return ap_list
def auc(Y_target, Y_score):
"""
Y_target: list of lists. {0, 1}
real labels
Y_score: list of lists. real values
prediction values
"""
Y_target = np.array(Y_target)
Y_score = np.array(Y_score)
auc_list = []
for i in range(Y_score.shape[1]):
try:
auc = roc_auc_score(Y_target[:, i], Y_score[:, i])
except:
continue
auc_list.append(auc)
return auc_list
def mean_auc(Y_target, Y_score):
auc_list = auc(Y_target, Y_score)
mean_auc = np.mean(auc_list)
return mean_auc
def mean_auc_y(Y_target, Y_score):
'''
along y-axis
'''
return mean_auc(Y_target, Y_score)
def mean_auc_x(Y_target, Y_score):
'''
along x-axis
'''
return mean_auc(np.array(Y_target).T, np.array(Y_score).T)
def mean_average_precision(Y_target, Y_score):
"""
mean average precision
raw-based operation
Y_target: list of lists. {0, 1}
real labels
Y_score: list of lists. real values
prediction values
"""
p = float(len(Y_target))
temp_sum = 0
for y_target, y_score in zip(Y_target, Y_score):
y_target = np.array(y_target)
y_score = np.array(y_score)
if (y_target == 0).all() or (y_target == 1).all():
p -= 1
continue
idx_target = np.nonzero(y_target > 0)[0]
n_target = float(len(idx_target))
rank_list = np.array(_score_to_rank(y_score))
target_rank_list = rank_list[idx_target]
temp_sum_2 = 0
for target_rank in target_rank_list:
mm = sum([1 for ii in idx_target
if rank_list[ii] <= target_rank])/float(target_rank)
temp_sum_2 += mm
temp_sum += temp_sum_2/n_target
measure = temp_sum/p
return measure
def map(Y_target, Y_score):
return mean_average_precision(Y_target, Y_score)
def map_x(Y_target, Y_score):
return mean_average_precision(Y_target, Y_score)
def map_y(Y_target, Y_score):
return mean_average_precision(np.array(Y_target).T,
np.array(Y_score).T)
|
[
"numpy.mean",
"sklearn.metrics.average_precision_score",
"sklearn.metrics.roc_auc_score",
"numpy.array",
"numpy.nonzero"
] |
[((289, 309), 'numpy.array', 'np.array', (['score_list'], {}), '(score_list)\n', (297, 309), True, 'import numpy as np\n'), ((780, 798), 'numpy.array', 'np.array', (['Y_target'], {}), '(Y_target)\n', (788, 798), True, 'import numpy as np\n'), ((813, 830), 'numpy.array', 'np.array', (['Y_score'], {}), '(Y_score)\n', (821, 830), True, 'import numpy as np\n'), ((846, 892), 'sklearn.metrics.roc_auc_score', 'roc_auc_score', (['Y_target', 'Y_score'], {'average': 'None'}), '(Y_target, Y_score, average=None)\n', (859, 892), False, 'from sklearn.metrics import roc_auc_score\n'), ((1202, 1220), 'numpy.array', 'np.array', (['Y_target'], {}), '(Y_target)\n', (1210, 1220), True, 'import numpy as np\n'), ((1235, 1252), 'numpy.array', 'np.array', (['Y_score'], {}), '(Y_score)\n', (1243, 1252), True, 'import numpy as np\n'), ((1267, 1302), 'sklearn.metrics.average_precision_score', 'ap', (['Y_target', 'Y_score'], {'average': 'None'}), '(Y_target, Y_score, average=None)\n', (1269, 1302), True, 'from sklearn.metrics import average_precision_score as ap\n'), ((1506, 1524), 'numpy.array', 'np.array', (['Y_target'], {}), '(Y_target)\n', (1514, 1524), True, 'import numpy as np\n'), ((1539, 1556), 'numpy.array', 'np.array', (['Y_score'], {}), '(Y_score)\n', (1547, 1556), True, 'import numpy as np\n'), ((1863, 1880), 'numpy.mean', 'np.mean', (['auc_list'], {}), '(auc_list)\n', (1870, 1880), True, 'import numpy as np\n'), ((2501, 2519), 'numpy.array', 'np.array', (['y_target'], {}), '(y_target)\n', (2509, 2519), True, 'import numpy as np\n'), ((2538, 2555), 'numpy.array', 'np.array', (['y_score'], {}), '(y_score)\n', (2546, 2555), True, 'import numpy as np\n'), ((1644, 1688), 'sklearn.metrics.roc_auc_score', 'roc_auc_score', (['Y_target[:, i]', 'Y_score[:, i]'], {}), '(Y_target[:, i], Y_score[:, i])\n', (1657, 1688), False, 'from sklearn.metrics import roc_auc_score\n'), ((2100, 2118), 'numpy.array', 'np.array', (['Y_target'], {}), '(Y_target)\n', (2108, 2118), True, 'import numpy as np\n'), ((2122, 2139), 'numpy.array', 'np.array', (['Y_score'], {}), '(Y_score)\n', (2130, 2139), True, 'import numpy as np\n'), ((2676, 2700), 'numpy.nonzero', 'np.nonzero', (['(y_target > 0)'], {}), '(y_target > 0)\n', (2686, 2700), True, 'import numpy as np\n'), ((3386, 3404), 'numpy.array', 'np.array', (['Y_target'], {}), '(Y_target)\n', (3394, 3404), True, 'import numpy as np\n'), ((3442, 3459), 'numpy.array', 'np.array', (['Y_score'], {}), '(Y_score)\n', (3450, 3459), True, 'import numpy as np\n')]
|
"""
:filename transformations.py
:author <NAME>
:email <EMAIL>
from
Classes of custom transformations that are applied during the training as additional augmentation of the depth maps.
"""
import torch
import random
import numpy as np
import torch.nn.functional as F
from random import randrange
from skimage.transform import resize, warp, AffineTransform
class Normalize(object):
"""Normalization of a depth map in the value of [0, 1] for each pixel."""
def __init__(self, input_type):
self.input_type = input_type
def __call__(self, sample):
if self.input_type == 'geom':
image, landmarks, label = sample['image'], sample['landmarks'], sample['label']
mean, std = image.mean([1, 2]), image.std([1, 2])
# TODO?
return {'image': image,
'landmarks': landmarks,
'label': label}
class ToTensor(object):
"""Transformation of a training sample into a torch tensor instance."""
def __init__(self, input_type):
self.input_type = input_type
def __call__(self, sample):
image, landmarks, label = sample['image'], sample['landmarks'], sample['label']
image = torch.from_numpy(image.copy())
if self.input_type != 'depth+geom':
image = image.unsqueeze(1)
image = image.permute(1, 0, 2)
else:
image = image.permute(2, 0, 1)
landmarks = np.asarray(landmarks)
landmarks = torch.from_numpy(landmarks.copy())
return {'image': image,
'landmarks': landmarks,
'label': label}
class Resize(object):
"""Resizing of the input sample into provided dimensions."""
def __init__(self, width, height, input_type='image'):
assert isinstance(width, int)
assert isinstance(height, int)
self.width = width
self.height = height
self.type = input_type
def __call__(self, sample):
image, landmarks, label = sample['image'], sample['landmarks'], sample['label']
resized_landmarks = landmarks.copy()
if self.type == 'image':
image = resize(image, (self.height, self.width), anti_aliasing=True)
if self.type == 'landmarks':
resized_landmarks = []
for landmark in landmarks:
landmark_resized = resize(landmark, (self.height, self.width), anti_aliasing=True)
resized_landmarks.append(landmark_resized)
return {'image': image,
'landmarks': resized_landmarks,
'label': label}
class RandomTranslating(object):
"""Randomly translate the input sample from range [-10 px, 10 px] with provided probability."""
def __init__(self, p=0.5):
assert isinstance(p, float)
self.p = p
def __call__(self, sample):
image, landmarks, label = sample['image'], sample['landmarks'], sample['label']
translated_landmarks = landmarks.copy()
if np.random.rand(1) < self.p:
n1 = randrange(-10, 10)
n2 = randrange(-10, 10)
t = AffineTransform(translation=(n1, n2))
image = warp(image, t.inverse)
translated_landmarks = []
for landmark in landmarks:
translated_landmarks.append(warp(landmark, t.inverse))
return {'image': image,
'landmarks': translated_landmarks,
'label': label}
class RandomScaling(object):
"""Randomly scales the input sample with scale index from range [0.90, 1.10] with provided probability."""
def __init__(self, p=0.5):
assert isinstance(p, float)
self.p = p
def __call__(self, sample):
image, landmarks, label = sample['image'], sample['landmarks'], sample['label']
scaled_landmarks = landmarks.copy()
if np.random.rand(1) < self.p:
n = random.uniform(0.90, 1.10)
t = AffineTransform(scale=(n, n))
image = warp(image, t.inverse)
scaled_landmarks = []
for landmark in landmarks:
scaled_landmarks.append(warp(landmark, t.inverse))
return {'image': image,
'landmarks': scaled_landmarks,
'label': label}
class RandomRotation(object):
"""Randomly rotates the input sample from range [−11.25 deg, 11.25 deg] with provided probability."""
def __init__(self, p=0.5):
assert isinstance(p, float)
self.p = p
def __call__(self, sample):
image, landmarks, label = sample['image'], sample['landmarks'], sample['label']
rnd_num1 = randrange(-32, -6)
rnd_num2 = randrange(6, 32)
rnd_num = random.choice([rnd_num1, rnd_num2])
if np.random.rand(1) < self.p:
rotated_image = self.rotate(x=image.unsqueeze(0).type(torch.FloatTensor), theta=np.pi/rnd_num)
rotated_landmarks = []
for _, landmark in enumerate(landmarks):
rotated_landmark = self.rotate(x=landmark.unsqueeze(0).unsqueeze(0).type(torch.FloatTensor), theta=np.pi/rnd_num)
rotated_landmarks.append(rotated_landmark.squeeze(0))
result = torch.cat(rotated_landmarks, dim=0)
return {'image': rotated_image.squeeze(0),
'landmarks': result,
'label': label}
return {'image': image,
'landmarks': landmarks,
'label': label}
@staticmethod
def get_rotation_matrix(theta):
"""Returns a tensor rotation matrix with given theta value."""
theta = torch.tensor(theta)
return torch.tensor([[torch.cos(theta), -torch.sin(theta), 0],
[torch.sin(theta), torch.cos(theta), 0]])
def rotate(self, x, theta):
rot_mat = self.get_rotation_matrix(theta)[None, ...].repeat(x.shape[0], 1, 1)
grid = F.affine_grid(rot_mat, x.size(), align_corners=False)
x = F.grid_sample(x, grid, align_corners=False)
return x
|
[
"torch.nn.functional.grid_sample",
"random.uniform",
"random.choice",
"numpy.random.rand",
"random.randrange",
"skimage.transform.AffineTransform",
"numpy.asarray",
"skimage.transform.warp",
"torch.sin",
"torch.tensor",
"torch.cos",
"skimage.transform.resize",
"torch.cat"
] |
[((1466, 1487), 'numpy.asarray', 'np.asarray', (['landmarks'], {}), '(landmarks)\n', (1476, 1487), True, 'import numpy as np\n'), ((4681, 4699), 'random.randrange', 'randrange', (['(-32)', '(-6)'], {}), '(-32, -6)\n', (4690, 4699), False, 'from random import randrange\n'), ((4719, 4735), 'random.randrange', 'randrange', (['(6)', '(32)'], {}), '(6, 32)\n', (4728, 4735), False, 'from random import randrange\n'), ((4754, 4789), 'random.choice', 'random.choice', (['[rnd_num1, rnd_num2]'], {}), '([rnd_num1, rnd_num2])\n', (4767, 4789), False, 'import random\n'), ((5665, 5684), 'torch.tensor', 'torch.tensor', (['theta'], {}), '(theta)\n', (5677, 5684), False, 'import torch\n'), ((6028, 6071), 'torch.nn.functional.grid_sample', 'F.grid_sample', (['x', 'grid'], {'align_corners': '(False)'}), '(x, grid, align_corners=False)\n', (6041, 6071), True, 'import torch.nn.functional as F\n'), ((2182, 2242), 'skimage.transform.resize', 'resize', (['image', '(self.height, self.width)'], {'anti_aliasing': '(True)'}), '(image, (self.height, self.width), anti_aliasing=True)\n', (2188, 2242), False, 'from skimage.transform import resize, warp, AffineTransform\n'), ((3029, 3046), 'numpy.random.rand', 'np.random.rand', (['(1)'], {}), '(1)\n', (3043, 3046), True, 'import numpy as np\n'), ((3074, 3092), 'random.randrange', 'randrange', (['(-10)', '(10)'], {}), '(-10, 10)\n', (3083, 3092), False, 'from random import randrange\n'), ((3110, 3128), 'random.randrange', 'randrange', (['(-10)', '(10)'], {}), '(-10, 10)\n', (3119, 3128), False, 'from random import randrange\n'), ((3146, 3183), 'skimage.transform.AffineTransform', 'AffineTransform', ([], {'translation': '(n1, n2)'}), '(translation=(n1, n2))\n', (3161, 3183), False, 'from skimage.transform import resize, warp, AffineTransform\n'), ((3205, 3227), 'skimage.transform.warp', 'warp', (['image', 't.inverse'], {}), '(image, t.inverse)\n', (3209, 3227), False, 'from skimage.transform import resize, warp, AffineTransform\n'), ((3900, 3917), 'numpy.random.rand', 'np.random.rand', (['(1)'], {}), '(1)\n', (3914, 3917), True, 'import numpy as np\n'), ((3944, 3968), 'random.uniform', 'random.uniform', (['(0.9)', '(1.1)'], {}), '(0.9, 1.1)\n', (3958, 3968), False, 'import random\n'), ((3987, 4016), 'skimage.transform.AffineTransform', 'AffineTransform', ([], {'scale': '(n, n)'}), '(scale=(n, n))\n', (4002, 4016), False, 'from skimage.transform import resize, warp, AffineTransform\n'), ((4038, 4060), 'skimage.transform.warp', 'warp', (['image', 't.inverse'], {}), '(image, t.inverse)\n', (4042, 4060), False, 'from skimage.transform import resize, warp, AffineTransform\n'), ((4802, 4819), 'numpy.random.rand', 'np.random.rand', (['(1)'], {}), '(1)\n', (4816, 4819), True, 'import numpy as np\n'), ((5248, 5283), 'torch.cat', 'torch.cat', (['rotated_landmarks'], {'dim': '(0)'}), '(rotated_landmarks, dim=0)\n', (5257, 5283), False, 'import torch\n'), ((2389, 2452), 'skimage.transform.resize', 'resize', (['landmark', '(self.height, self.width)'], {'anti_aliasing': '(True)'}), '(landmark, (self.height, self.width), anti_aliasing=True)\n', (2395, 2452), False, 'from skimage.transform import resize, warp, AffineTransform\n'), ((3350, 3375), 'skimage.transform.warp', 'warp', (['landmark', 't.inverse'], {}), '(landmark, t.inverse)\n', (3354, 3375), False, 'from skimage.transform import resize, warp, AffineTransform\n'), ((4175, 4200), 'skimage.transform.warp', 'warp', (['landmark', 't.inverse'], {}), '(landmark, t.inverse)\n', (4179, 4200), False, 'from skimage.transform import resize, warp, AffineTransform\n'), ((5716, 5732), 'torch.cos', 'torch.cos', (['theta'], {}), '(theta)\n', (5725, 5732), False, 'import torch\n'), ((5787, 5803), 'torch.sin', 'torch.sin', (['theta'], {}), '(theta)\n', (5796, 5803), False, 'import torch\n'), ((5805, 5821), 'torch.cos', 'torch.cos', (['theta'], {}), '(theta)\n', (5814, 5821), False, 'import torch\n'), ((5735, 5751), 'torch.sin', 'torch.sin', (['theta'], {}), '(theta)\n', (5744, 5751), False, 'import torch\n')]
|
import astropy.units as u
import numpy as np
from lofti_gaia.loftitools import *
from lofti_gaia.cFunctions import calcOFTI_C
#from loftitools import *
import pickle
import time
import matplotlib.pyplot as plt
# Astroquery throws some warnings we can ignore:
import warnings
warnings.filterwarnings("ignore")
'''This module obtaines measurements from Gaia EDR3 (Gaia DR2 is also available as a secondary option) and runs through the LOFTI Gaia/OFTI
wide stellar binary orbit fitting technique.
'''
class Fitter(object):
'''Initialize the Fitter object for the binary system, and compute observational constraints
to be used in the orbit fit. User must provide Gaia source ids, tuples of mass estimates for
both objects, specify the number of desired orbits in posterior sample. Fit will be
for object 2 relative to object 1.
Attributes are tuples of (value,uncertainty) unless otherwise indicated. Attributes
with astropy units are retrieved from Gaia archive, attributes without units are
computed from Gaia values. All relative values are for object 2 relative to object 1.
Args:
sourceid1, sourceid2 (int): Gaia source ids for the two objects, fit will be for motion of \
object 2 relative to object 1
mass1, mass2 (tuple, flt): tuple os mass estimate for object 1 and 2, of the form (value, uncertainty)
Norbits (int): Number of desired orbits in posterior sample. Default = 100000
results_filename (str): Filename for fit results files. If none, results will be written to files \
named FitResults.yr.mo.day.hr.min.s
astrometry (dict): User-supplied astrometric measurements. Must be dictionary or table or pandas dataframe with\
column names "sep,seperr,pa,paerr,dates" or "ra,raerr,dec,decerr,dates". May be same as the rv table. \
Sep, deltaRA, and deltaDEC must be in arcseconds, PA in degrees, dates in decimal years. \
Default = None
user_rv (dict): User-supplied radial velocity measurements. Must be dictionary or table or pandas dataframe with\
column names "rv,rverr,rv_dates". May be same as the astrometry table. Default = None.
catalog (str): name of Gaia catalog to query. Default = 'gaiaedr3.gaia_source'
ruwe1, ruwe2 (flt): RUWE value from Gaia archive
ref_epoch (flt): reference epoch in decimal years. For Gaia DR2 this is 2015.5, for Gaia EDR3 it is 2016.0
plx1, plx2 (flt): parallax from Gaia in mas
RA1, RA2 (flt): right ascension from Gaia; RA in deg, uncertainty in mas
Dec1, Dec2 (flt): declination from Gaia; Dec in deg, uncertainty in mas
pmRA1, pmRA2 (flt): proper motion in RA in mas yr^-1 from Gaia
pmDec1, pmDec2 (flt): proper motion in DEC in mas yr^-1 from Gaia
rv1, rv2 (flt, optional): radial velocity in km s^-1 from Gaia
rv (flt, optional): relative RV of 2 relative to 1, if both are present in Gaia
plx (flt): weighted mean parallax for the binary system in mas
distance (flt): distance of system in pc, computed from Gaia parallax using method \
of Bailer-Jones et. al 2018.
deltaRA, deltaDec (flt): relative separation in RA and Dec directions, in mas
pmRA, pmDec (flt): relative proper motion in RA/Dec directions in km s^-1
sep (flt): total separation vector in mas
pa (flt): postion angle of separation vector in degrees from North
sep_au (flt): separation in AU
sep_km (flt): separation in km
total_vel (flt): total velocity vector in km s^-1. If RV is available for both, \
this is the 3d velocity vector; if not it is just the plane of sky velocity.
total_planeofsky_vel (flt): total velocity in the plane of sky in km s^-1. \
In the absence of RV this is equivalent to the total velocity vector.
deltaGmag (flt): relative contrast in Gaia G magnitude. Does not include uncertainty.
inflateProperMOtionError (flt): an optional factor to mulitply default gaia proper motion error by.
Written by <NAME>, 2020
'''
def __init__(self, sourceid1, sourceid2, mass1, mass2, Norbits = 100000, \
results_filename = None,
astrometry = None,
user_rv = None,
catalog = 'gaiaedr3.gaia_source',
inflateProperMotionError=1
):
self.sourceid1 = sourceid1
self.sourceid2 = sourceid2
try:
self.mass1 = mass1[0]
self.mass1err = mass1[1]
self.mass2 = mass2[0]
self.mass2err = mass2[1]
self.mtot = [self.mass1 + self.mass2, np.sqrt((self.mass1err**2) + (self.mass2err**2))]
except:
raise ValueError('Masses must be tuples of (value,error), ex: mass1 = (1.0,0.05)')
self.Norbits = Norbits
if not results_filename:
self.results_filename = 'FitResults.'+time.strftime("%Y.%m.%d.%H.%M.%S")+'.txt'
self.stats_filename = 'FitResults.Stats.'+time.strftime("%Y.%m.%d.%H.%M.%S")+'.txt'
else:
self.results_filename = results_filename
self.stats_filename = results_filename+'.Stats.txt'
self.astrometry = False
# check if user supplied astrometry:
if astrometry is not None:
# if so, set astrometric flag to True:
self.astrometry = True
# store observation dates:
self.astrometric_dates = astrometry['dates']
# if in sep/pa, convert to ra/dec:
if 'sep' in astrometry:
try:
astr_ra = [MonteCarloIt([astrometry['sep'][i],astrometry['seperr'][i]]) * \
np.sin(np.radians(MonteCarloIt([astrometry['pa'][i],astrometry['paerr'][i]]))) \
for i in range(len(astrometry['sep']))]
astr_dec = [MonteCarloIt([astrometry['sep'][i],astrometry['seperr'][i]]) * \
np.cos(np.radians(MonteCarloIt([astrometry['pa'][i],astrometry['paerr'][i]]))) \
for i in range(len(astrometry['sep']))]
self.astrometric_ra = np.array([
[np.mean(astr_ra[i]) for i in range(len(astrometry['sep']))],
[np.std(astr_ra[i]) for i in range(len(astrometry['sep']))]
])
self.astrometric_dec = np.array([
[np.mean(astr_dec[i]) for i in range(len(astrometry['sep']))],
[np.std(astr_dec[i]) for i in range(len(astrometry['sep']))]
])
except:
raise ValueError('Astrometry keys not recognized. Please provide dictionary or table or pandas dataframe with\
column names "sep,seperr,pa,paerr,dates" or "ra,raerr,dec,decerr,dates"')
elif 'ra' in astrometry:
# else store the ra/dec as attributes:
try:
self.astrometric_ra = np.array([astrometry['ra'], astrometry['raerr']])
self.astrometric_dec = np.array([astrometry['dec'], astrometry['decerr']])
except:
raise ValueError('Astrometry keys not recognized. Please provide dictionary or table or pandas dataframe with\
column names "sep,seperr,pa,paerr,dates" or "ra,raerr,dec,decerr,dates"')
else:
raise ValueError('Astrometry keys not recognized. Please provide dictionary or table or pandas dataframe with\
column names "sep,seperr,pa,paerr,dates" or "ra,raerr,dec,decerr,dates"')
# Check if user supplied rv:
self.use_user_rv = False
if user_rv is not None:
# set user rv flag to true:
self.use_user_rv = True
try:
# set attributes; multiply rv by -1 due to difference in coordinate systems:
self.user_rv = np.array([user_rv['rv']*-1,user_rv['rverr']])
self.user_rv_dates = np.array(user_rv['rv_dates'])
except:
raise ValueError('RV keys not recognized. Please use column names "rv,rverr,rv_dates"')
self.catalog = catalog
# Get Gaia measurements, compute needed constraints, and add to object:
self.PrepareConstraints(catalog=self.catalog,inflateFactor=inflateProperMotionError)
def edr3ToICRF(self,pmra,pmdec,ra,dec,G):
''' Corrects for biases in proper motion. The function is from https://arxiv.org/pdf/2103.07432.pdf
Args:
pmra,pmdec (float): proper motion
ra, dec (float): right ascension and declination
G (float): G magnitude
Written by <NAME>, 2021
'''
if G>=13:
return pmra , pmdec
import numpy as np
def sind(x):
return np.sin(np.radians(x))
def cosd(x):
return np.cos(np.radians(x))
table1="""
0.0 9.0 9.0 9.5 9.5 10.0 10.0 10.5 10.5 11.0 11.0 11.5 11.5 11.75 11.75 12.0 12.0 12.25 12.25 12.5 12.5 12.75 12.75 13.0
18.4 33.8 -11.3 14.0 30.7 -19.4 12.8 31.4 -11.8 13.6 35.7 -10.5 16.2 50.0 2.1 19.4 59.9 0.2 21.8 64.2 1.0 17.7 65.6 -1.9 21.3 74.8 2.1 25.7 73.6 1.0 27.3 76.6 0.5
34.9 68.9 -2.9 """
table1 = np.fromstring(table1,sep=" ").reshape((12,5)).T
Gmin = table1[0]
Gmax = table1[1]
#pick the appropriate omegaXYZ for the source’s magnitude:
omegaX = table1[2][(Gmin<=G)&(Gmax>G)][0]
omegaY = table1[3][(Gmin<=G)&(Gmax>G)][0]
omegaZ = table1[4][(Gmin<=G)&(Gmax>G)][0]
pmraCorr = -1*sind(dec)*cosd(ra)*omegaX -sind(dec)*sind(ra)*omegaY + cosd(dec)*omegaZ
pmdecCorr = sind(ra)*omegaX -cosd(ra)*omegaY
return pmra-pmraCorr/1000., pmdec-pmdecCorr/1000.
def PrepareConstraints(self, rv=False, catalog='gaiaedr3.gaia_source', inflateFactor=1.):
'''Retrieves parameters for both objects from Gaia EDR3 archive and computes system attriubtes,
and assigns them to the Fitter object class.
Args:
rv (bool): flag for handling the presence or absence of RV measurements for both objects \
in EDR3. Gets set to True if both objects have Gaia RV measurements. Default = False
catalog (str): name of Gaia catalog to query. Default = 'gaiaedr3.gaia_source'
inflateFactor (flt): Factor by which to inflate the errors on Gaia proper motions to \
account for improper uncertainty estimates. Default = 1.0
Written by <NAME>, 2020
'''
from astroquery.gaia import Gaia
deg_to_mas = 3600000.
mas_to_deg = 1./3600000.
# Retrieve astrometric solution from Gaia EDR3
job = Gaia.launch_job("SELECT * FROM "+catalog+" WHERE source_id = "+str(self.sourceid1))
j = job.get_results()
job = Gaia.launch_job("SELECT * FROM "+catalog+" WHERE source_id = "+str(self.sourceid2))
k = job.get_results()
if catalog == 'gaiadr2.gaia_source':
# Retrieve RUWE from RUWE catalog for both sources and add to object state:
job = Gaia.launch_job("SELECT * FROM gaiadr2.ruwe WHERE source_id = "+str(self.sourceid1))
jruwe = job.get_results()
job = Gaia.launch_job("SELECT * FROM gaiadr2.ruwe WHERE source_id = "+str(self.sourceid2))
kruwe = job.get_results()
self.ruwe1 = jruwe['ruwe'][0]
self.ruwe2 = kruwe['ruwe'][0]
else:
# EDR3 contains ruwe in the main catalog:
self.ruwe1 = j['ruwe'][0]
self.ruwe2 = k['ruwe'][0]
# Check RUWE for both objects and warn if too high:
if self.ruwe1>1.2 or self.ruwe2>1.2:
print('''WARNING: RUWE for one or more of your solutions is greater than 1.2. This indicates
that the source might be an unresolved binary or experiencing acceleration
during the observation. Orbit fit results may not be trustworthy.''')
# reference epoch:
self.ref_epoch = j['ref_epoch'][0]
# parallax:
self.plx1 = [j[0]['parallax']*u.mas, j[0]['parallax_error']*u.mas]
self.plx2 = [k[0]['parallax']*u.mas, k[0]['parallax_error']*u.mas]
# RA/DEC
self.RA1 = [j[0]['ra']*u.deg, j[0]['ra_error']*mas_to_deg*u.deg]
self.RA2 = [k[0]['ra']*u.deg, k[0]['ra_error']*mas_to_deg*u.deg]
self.Dec1 = [j[0]['dec']*u.deg, j[0]['dec_error']*mas_to_deg*u.deg]
self.Dec2 = [k[0]['dec']*u.deg, k[0]['dec_error']*mas_to_deg*u.deg]
# Proper motions
pmRACorrected1,pmDecCorrected1 = self.edr3ToICRF(j[0]['pmra'],j[0]['pmdec'],j[0]['ra'],j[0]['dec'],j[0]["phot_g_mean_mag"])
pmRACorrected2,pmDecCorrected2 = self.edr3ToICRF(k[0]['pmra'],k[0]['pmdec'],k[0]['ra'],k[0]['dec'],k[0]["phot_g_mean_mag"])
self.pmRA1 = [pmRACorrected1*u.mas/u.yr, j[0]['pmra_error']*u.mas/u.yr*inflateFactor]
self.pmRA2 = [pmRACorrected2*u.mas/u.yr, k[0]['pmra_error']*u.mas/u.yr*inflateFactor]
self.pmDec1 = [pmDecCorrected1*u.mas/u.yr, j[0]['pmdec_error']*u.mas/u.yr*inflateFactor]
self.pmDec2 = [pmDecCorrected2*u.mas/u.yr, k[0]['pmdec_error']*u.mas/u.yr*inflateFactor]
# See if both objects have RV's in DR2:
if catalog == 'gaiaedr3.gaia_source':
key = 'dr2_radial_velocity'
error_key = 'dr2_radial_velocity_error'
elif catalog == 'gaiadr2.gaia_source':
key = 'radial_velocity'
error_key = 'radial_velocity_error'
if type(k[0][key]) == np.float64 and type(j[0][key]) == np.float64 or type(k[0][key]) == np.float32 and type(j[0][key]) == np.float32:
rv = True
self.rv1 = [j[0][key]*u.km/u.s,j[0][error_key]*u.km/u.s]
self.rv2 = [k[0][key]*u.km/u.s,k[0][error_key]*u.km/u.s]
rv1 = MonteCarloIt(self.rv1)
rv2 = MonteCarloIt(self.rv2)
self.rv = [ -np.mean(rv2-rv1) , np.std(rv2-rv1) ] # km/s
# negative to relfect change in coordinate system from RV measurements to lofti
# pos RV = towards observer in this coord system
else:
self.rv = [0,0]
# weighted mean of parallax values:
plx = np.average([self.plx1[0].value,self.plx2[0].value], weights = [self.plx1[1].value,self.plx2[1].value])
plxerr = np.max([self.plx1[1].value,self.plx2[1].value])
self.plx = [plx,plxerr] # mas
self.distance = distance(*self.plx) # pc
# Compute separations of component 2 relative to 1:
r1 = MonteCarloIt(self.RA1)
r2 = MonteCarloIt(self.RA2)
d1 = MonteCarloIt(self.Dec1)
d2 = MonteCarloIt(self.Dec2)
ra = (r2*deg_to_mas - r1*deg_to_mas) * np.cos(np.radians(np.mean([self.Dec1[0].value,self.Dec2[0].value])))
dec = ((d2 - d1)*u.deg).to(u.mas).value
self.deltaRA = [np.mean(ra),np.std(ra)] # mas
self.deltaDec = [np.mean(dec),np.std(dec)] # mas
# compute relative proper motion:
pr1 = MonteCarloIt(self.pmRA1)
pr2 = MonteCarloIt(self.pmRA2)
pd1 = MonteCarloIt(self.pmDec1)
pd2 = MonteCarloIt(self.pmDec2)
pmRA = [np.mean(pr2 - pr1), np.std(pr2-pr1)] # mas/yr
pmDec = [np.mean(pd2 - pd1), np.std(pd2 - pd1)] # mas/yr
self.pmRA = masyr_to_kms(pmRA,self.plx) # km/s
self.pmDec = masyr_to_kms(pmDec,self.plx) # km/s
# Compute separation/position angle:
r, p = to_polar(r1,r2,d1,d2)
self.sep = tuple([np.mean(r).value, np.std(r).value]) # mas
self.pa = tuple([np.mean(p).value, np.std(p).value]) # deg
self.sep_au = tuple([((self.sep[0]/1000)*self.distance[0]), ((self.sep[1]/1000)*self.distance[0])])
self.sep_km = tuple([ self.sep_au[0]*u.au.to(u.km) , self.sep_au[1]*u.au.to(u.km)])
# compute total velocities:
if rv:
self.total_vel = [ add_in_quad([self.pmRA[0],self.pmDec[0],self.rv[0]]) ,
add_in_quad([self.pmRA[1],self.pmDec[1],self.rv[1]]) ] # km/s
self.total_planeofsky_vel = [ add_in_quad([self.pmRA[0],self.pmDec[0]]) ,
add_in_quad([self.pmRA[1],self.pmDec[1]]) ] # km/s
else:
self.total_vel = [ add_in_quad([self.pmRA[0],self.pmDec[0]]) ,
add_in_quad([self.pmRA[1],self.pmDec[1]]) ] # km/s
self.total_planeofsky_vel = self.total_vel.copy() # km/s
# compute deltamag:
self.deltaGmag = j[0]['phot_g_mean_mag'] - k[0]['phot_g_mean_mag']
class FitOrbit(object):
''' Object for performing an orbit fit. Takes attributes from Fitter class.
ex: orbits = FitOrbit(fitterobject)
Args:
fitterobject (Fitter object): Fitter object initialized from the Fitter class
write_stats (bool): If True, write out summary statistics of orbit sample at \
conclusion of fit. Default = True.
write_results (bool): If True, write out the fit results to a pickle file \
in addition to the text file created during the fit. Default = True.
deltaRA, deltaDec (flt): relative separation in RA and Dec directions, in mas
pmRA, pmDec (flt): relative proper motion in RA/Dec directions in km s^-1
rv (flt, optional): relative RV of 2 relative to 1, if both are present in Gaia EDR3
mtot_init (flt): initial total system mass in Msun from user input
distance (flt): distance of system in pc, computed from Gaia parallax using method of Bailer-Jones et. al 2018.
sep (flt): separation vector in mas
pa (flt): postion angle of separation vector in degrees from North
ref_epoch (flt): epoch of the measurement, 2016.0 for Gaia EDR3 and 2015.5 for Gaia DR2.
Norbits (int): number of desired orbit samples
write_stats (bool): if True, write summary of sample statistics to human-readable file at end of run. Default = True
write_results (bool): if True, write out current state of sample orbits in pickle file in periodic intervals during \
run, and again at the end of the run. RECOMMENDED. Default = True
results_filename (str): name of file for saving pickled results to disk. If not supplied, \
defaul name is FitResults.y.mo.d.h.m.s.pkl, saved in same directory as fit was run.
stats_filename (str): name of file for saving human-readable file of stats of sample results. If not supplied, \
defaul name is FitResults.Stats.y.mo.d.h.m.s.pkl, saved in same directory as fit was run.
run_time (flt): run time for the last fit. astropy units object
Written by <NAME>, 2020
'''
def __init__(self, fitterobject, write_stats = True, write_results = True, python_version=False, \
use_pm_cross_term = False, corr_coeff = None):
# establish fit parameters:
self.deltaRA = fitterobject.deltaRA
self.deltaDec = fitterobject.deltaDec
self.pmRA = fitterobject.pmRA
self.pmDec = fitterobject.pmDec
self.rv = fitterobject.rv
self.mtot_init = fitterobject.mtot
self.distance = fitterobject.distance
self.sep = fitterobject.sep
self.pa = fitterobject.pa
self.ref_epoch = fitterobject.ref_epoch
self.Norbits = fitterobject.Norbits
self.write_results = write_results
self.write_stats = write_stats
self.results_filename = fitterobject.results_filename
self.stats_filename = fitterobject.stats_filename
self.astrometry = fitterobject.astrometry
if self.astrometry:
self.astrometric_ra = fitterobject.astrometric_ra
self.astrometric_dec = fitterobject.astrometric_dec
self.astrometric_dates = fitterobject.astrometric_dates
self.use_user_rv = fitterobject.use_user_rv
if self.use_user_rv:
self.user_rv = fitterobject.user_rv
self.user_rv_dates = fitterobject.user_rv_dates
# run orbit fitter:
self.fitorbit(python_fitOFTI=python_version, use_pm_cross_term = use_pm_cross_term, corr_coeff = corr_coeff)
def fitorbit(self, save_results_every_X_loops = 100, python_fitOFTI=False, use_pm_cross_term = False, corr_coeff = None):
'''Run the OFTI fitting run on the Fitter object. Called when FitOrbit object
is created.
Args:
save_results_every_X_loops (int): on every Xth loop, save status of the \
orbit sample arrays to a pickle file, if write_results = True (Default)
python_fitOFTI (bool): If True, fit using python only without using C Kepler's equation solver. Default = False
use_pm_cross_term (bool): If True, include the proper motion correlation cross term in the Chi^2 computation \
Default = False
Written by <NAME>, 2020
'''
# write header:
print('Saving orbits in',self.results_filename)
k = open(self.results_filename, 'w')
output_file_header = '# sma [arcsec] period [yrs] orbit phase t_0 [yr] ecc incl [deg]\
argp [deg] lan [deg] m_tot [Msun] dist [pc] chi^2 ln(prob) ln(randn)'
k.write(output_file_header + "\n")
k.close()
import time as tm
########### Perform initial run to get initial chi-squared: #############
# Draw random orbits:
#parameters = a,T,const,to,e,i,w,O,m1,dist
numSamples = 10000
parameters_init = draw_samples(numSamples, self.mtot_init, self.distance, self.ref_epoch)
# Compute positions and velocities:
if(python_fitOFTI):
X,Y,Z,Xdot,Ydot,Zdot,Xddot,Yddot,Zddot,parameters=calc_OFTI(parameters_init,self.ref_epoch,self.sep,self.pa)
else:
returnArray = np.zeros((19,numSamples))
returnArray = calcOFTI_C(parameters_init,self.ref_epoch,self.sep,self.pa,returnArray.copy())
X,Y,Z,Xdot,Ydot,Zdot,Xddot,Yddot,Zddot = returnArray[0:9]
parameters = returnArray[9:]
# Compute chi squared:
if self.rv[0] != 0:
model = np.array([Y,X,Ydot,Xdot,Zdot])
data = np.array([self.deltaRA, self.deltaDec, self.pmRA, self.pmDec, self.rv])
else:
model = np.array([Y,X,Ydot,Xdot])
data = np.array([self.deltaRA, self.deltaDec, self.pmRA, self.pmDec])
chi2 = ComputeChi2(data,model)
if use_pm_cross_term:
chi2 -= ( 2 * corr_coeff * (data[2][0] - model[2]) * (data[3][0] - model[3]) ) / (data[2][1] * data[3][1])
if self.astrometry:
p = parameters.copy()
a,T,const,to,e,i,w,O,m1,dist = p[0],p[1],p[2],p[3],p[4],p[5],p[6],p[7],p[8],p[9]
chi2_astr = np.zeros(10000)
# Calculate predicted positions at astr observation dates for each orbit:
for j in range(self.astrometric_ra.shape[1]):
# for each date, compute XYZ for each 10000 trial orbit. We can
# skip scale and rotate because that was accomplished in the calc_OFTI call above.
X1,Y1,Z1,E1 = calc_XYZ(a,T,to,e,i,w,O,self.astrometric_dates[j])
# Place astrometry into data array where: data[0][0]=ra obs, data[0][1]=ra err, etc:
data = np.array([self.astrometric_ra[:,j], self.astrometric_dec[:,j]])
# place corresponding predicited positions at that date for each trial orbit in arcsec:
model = np.array([Y1*1000,X1*1000])
# compute chi2 for trial orbits at that date and add to the total chi2 sum:
chi2_astr += ComputeChi2(data,model)
chi2 = chi2 + chi2_astr
if self.use_user_rv:
p = parameters.copy()
a,T,const,to,e,i,w,O,m1,dist = p[0],p[1],p[2],p[3],p[4],p[5],p[6],p[7],p[8],p[9]
chi2_rv = np.zeros(10000)
for j in range(self.user_rv.shape[1]):
# compute ecc anomaly at that date:
X1,Y1,Z1,E1 = calc_XYZ(a,T,to,e,i,w,O,self.user_rv_dates[j])
# compute velocities at that ecc anom:
Xdot,Ydot,Zdot = calc_velocities(a,T,to,e,i,w,O,dist,E1)
# compute chi2:
chi2_rv += ComputeChi2(np.array([self.user_rv[:,j]]),np.array([Zdot]))
chi2 = chi2 + chi2_rv
print('inital chi min',np.nanmin(chi2))
self.chi_min = np.nanmin(chi2)
# Accept/reject:
accepted, lnprob, lnrand = AcceptOrReject(chi2,self.chi_min)
# count number accepted:
number_orbits_accepted = np.size(accepted)
# tack on chi2, log probability, log random unif number to parameters array:
parameters = np.concatenate((parameters,chi2[None,:],lnprob[None,:],lnrand[None,:]), axis = 0)
# transpose:
parameters=np.transpose(parameters)
# write results to file:
k = open(self.results_filename, 'a')
for params in parameters[accepted]:
string = ' '.join([str(p) for p in params])
k.write(string + "\n")
k.close()
###### start loop ########
# initialize:
loop_count = 0
start=tm.time()
while number_orbits_accepted < self.Norbits:
# Draw random orbits:
numSamples = 10000
parameters_init = draw_samples(numSamples, self.mtot_init, self.distance, self.ref_epoch)
# Compute positions and velocities and new parameters array with scaled and rotated values:
if(python_fitOFTI):
X,Y,Z,Xdot,Ydot,Zdot,Xddot,Yddot,Zddot,parameters=calc_OFTI(parameters_init,self.ref_epoch,self.sep,self.pa)
else:
returnArray = np.zeros((19,numSamples))
returnArray = calcOFTI_C(parameters_init,self.ref_epoch,self.sep,self.pa,returnArray.copy())
X,Y,Z,Xdot,Ydot,Zdot,Xddot,Yddot,Zddot = returnArray[0:9]
parameters = returnArray[9:]
returnArray = None
# compute chi2 for orbits using Gaia observations:
if self.rv[0] != 0:
model = np.array([Y,X,Ydot,Xdot,Zdot])
data = np.array([self.deltaRA, self.deltaDec, self.pmRA, self.pmDec, self.rv])
else:
model = np.array([Y,X,Ydot,Xdot])
data = np.array([self.deltaRA, self.deltaDec, self.pmRA, self.pmDec])
chi2 = ComputeChi2(data,model)
if use_pm_cross_term:
chi2 -= ( 2 * (data[2][0] - model[2]) * (data[3][0] - model[3]) ) / (data[2][1] * data[3][1])
# add user astrometry if given:
if self.astrometry:
p = parameters.copy()
a,T,const,to,e,i,w,O,m1,dist = p[0],p[1],p[2],p[3],p[4],p[5],p[6],p[7],p[8],p[9]
chi2_astr = np.zeros(10000)
# Calculate predicted positions at astr observation dates for each orbit:
for j in range(self.astrometric_ra.shape[1]):
# for each date, compute XYZ for each 10000 trial orbit. We can
# skip scale and rotate because that was accomplished in the calc_OFTI call above.
X1,Y1,Z1,E1 = calc_XYZ(a,T,to,e,i,w,O,self.astrometric_dates[j])
# Place astrometry into data array where: data[0][0]=ra obs, data[0][1]=ra err, etc:
data = np.array([self.astrometric_ra[:,j], self.astrometric_dec[:,j]])
# place corresponding predicited positions at that date for each trial orbit:
model = np.array([Y1*1000,X1*1000])
# compute chi2 for trial orbits at that date and add to the total chi2 sum:
chi2_astr += ComputeChi2(data,model)
chi2 = chi2 + chi2_astr
# add user rv if given:
if self.use_user_rv:
p = parameters.copy()
a,T,const,to,e,i,w,O,m1,dist = p[0],p[1],p[2],p[3],p[4],p[5],p[6],p[7],p[8],p[9]
chi2_rv = np.zeros(10000)
for j in range(self.user_rv.shape[1]):
# compute ecc anomaly at that date:
X1,Y1,Z1,E1 = calc_XYZ(a,T,to,e,i,w,O,self.user_rv_dates[j])
# compute velocities at that ecc anom:
Xdot,Ydot,Zdot = calc_velocities(a,T,to,e,i,w,O,dist,E1)
# compute chi2:
chi2_rv += ComputeChi2(np.array([self.user_rv[:,j]]),np.array([Zdot]))
chi2 = chi2 + chi2_rv
# Accept/reject:
accepted, lnprob, lnrand = AcceptOrReject(chi2,self.chi_min)
if np.size(accepted) == 0:
pass
else:
# count num accepted
p = parameters.copy()
a,T,const,to,e,i,w,O,m1,dist = p[0],p[1],p[2],p[3],p[4],p[5],p[6],p[7],p[8],p[9]
sampleResults = calc_XYZ(a,T,to,e,i/180*np.pi,w/180*np.pi,O/180*np.pi,2016.0)
number_orbits_accepted += np.size(accepted)
parameters = np.concatenate((parameters,chi2[None,:],lnprob[None,:],lnrand[None,:]), axis = 0)
parameters=np.transpose(parameters)
k = open(self.results_filename, 'a')
for params in parameters[accepted]:
string = ' '.join([str(p) for p in params])
k.write(string + "\n")
k.close()
if np.nanmin(chi2) < self.chi_min:
# If there is a new min chi2:
self.chi_min = np.nanmin(chi2)
#print('found new chi min:',self.chi_min)
# re-evaluate to accept/reject with new chi_min:
if number_orbits_accepted != 0:
dat = np.loadtxt(open(self.results_filename,"r"),delimiter=' ',ndmin=2)
lnprob = -(dat[:,10]-self.chi_min)/2.0
dat[:,11] = lnprob
accepted_retest = np.where(lnprob > dat[:,12])
q = open(self.results_filename, 'w')
q.write(output_file_header + "\n")
for data in dat[accepted_retest]:
string = ' '.join([str(d) for d in data])
q.write(string + "\n")
q.close()
dat2 = np.loadtxt(open(self.results_filename,"r"),delimiter=' ',ndmin=2)
number_orbits_accepted=dat2.shape[0]
loop_count += 1
#print('loop count',loop_count)
update_progress(number_orbits_accepted,self.Norbits)
# one last accept/reject with final chi_min value:
dat = np.loadtxt(open(self.results_filename,"r"),delimiter=' ',ndmin=2)
lnprob = -(dat[:,10]-self.chi_min)/2.0
dat[:,11] = lnprob
accepted_retest = np.where(lnprob > dat[:,12])
q = open(self.results_filename, 'w')
q.write(output_file_header + "\n")
for data in dat[accepted_retest]:
string = ' '.join([str(d) for d in data])
q.write(string + "\n")
q.close()
# when finished, upload results and store in object:
dat = np.loadtxt(open(self.results_filename,"r"),delimiter=' ',ndmin=2)
number_orbits_accepted=dat.shape[0]
print('Final Norbits:', number_orbits_accepted)
# intialise results object and store accepted orbits:
if self.rv[0] != 0:
self.results = Results(orbits = dat, limit_lan = False, limit_aop = False)
else:
self.results = Results(orbits = dat, limit_lan = True, limit_aop = False)
self.results.Update(self.results.orbits)
# pickle dump the results attribute:
if self.write_results:
self.results.SaveResults(self.results_filename.replace(".txt", ".pkl"), write_text_file = False)
stop = tm.time()
self.results.run_time = (stop - start)*u.s
# compute stats and write to file:
self.results.stats = Stats(orbits = self.results.orbits, write_to_file = self.write_stats, filename = self.stats_filename)
class Results(object):
'''A class for storing and manipulating the results of the orbit fit.
Args:
orbits (Norbits x 13 array): array of accepted orbits from \
OFTI fit in the same order as the following attributes
sma (1 x Norbits array): semi-major axis in arcsec
period (1 x Norbits array): period in years
orbit_fraction (1 x Norbits array): fraction of orbit past periastron \
passage the observation (2016) occured on. Values: [0,1)
t0 (1 x Norbits array): date of periastron passage in decimal years
ecc (1 x Norbits array): eccentricity
inc (1 x Norbits array): inclination relative to plane of the sky in deg
aop (1 x Norbits array): arguement of periastron in deg
lan (1 x Norbits array): longitude of ascending node in deg
mtot (1 x Norbits array): total system mass in Msun
distance (1 x Norbits array): distance to system in parsecs
chi2 (1 x Norbits array): chi^2 value for the orbit
lnprob (1 x Norbits array): log probability of orbit
lnrand (1 x Norbits array): log of random "dice roll" for \
orbit acceptance
limit_aop, limit_lan (bool): In the absence of radial velocity info, \
there is a degeneracy between arg of periastron and long of ascending \
node. Common practice is to limit one to the interval [0,180] deg. \
By default, lofti limits lan to this interval if rv = False. The user can \
choose to limit aop instead by setting limit_aop = True, limit_lan = False. \
The orbits[:,6] (aop) and orbits[:,7] (lan) arrays preserve the original values. \
Written by <NAME>, 2020
'''
def __init__(self, orbits = [], limit_aop = False, limit_lan = True):
self.orbits = orbits
self.limit_lan = limit_lan
self.limit_aop = limit_aop
def Update(self, orbits):
'''Take elements of the "orbits" attribute and populate
the orbital element attributes
Args:
orbits (arr): orbits array from Results class
Written by <NAME>, 2020
'''
self.sma = orbits[:,0]
self.period = orbits[:,1]
self.orbit_fraction = orbits[:,2]
self.t0 = orbits[:,3]
self.ecc = orbits[:,4]
self.inc = orbits[:,5]
self.aop = orbits[:,6]
if self.limit_aop:
self.aop = limit_to_180deg(self.aop)
self.lan = orbits[:,7] % 360
if self.limit_lan:
self.lan = limit_to_180deg(self.lan)
self.mtot = orbits[:,8]
self.distance = orbits[:,9]
self.chi2 = orbits[:,10]
self.lnprob = orbits[:,11]
self.lnrand = orbits[:,12]
def SaveResults(self, filename, write_text_file = False, text_filename = None):
'''Save the orbits and orbital parameters attributes in a pickle file
Args:
filename (str): filename for pickle file
write_text_file (bool): if True, also write out the accepted orbits to a \
human readable text file
text_filename (bool): if write_to_text = True, specifify filename for text file
Written by <NAME>, 2020
'''
pickle.dump(self, open( filename, "wb" ) )
# write results to file:
if write_text_file:
k = open(text_filename, 'a')
for params in self.orbits:
string = ' '.join([str(p) for p in params])
k.write(string + "\n")
k.close()
def LoadResults(self, filename, append = False):
'''Read in the orbits and orbital parameters attributes from a pickle file
Args:
filename (str): filename of pickle file to load
append (bool): if True, append read in orbit samples to another Results \
object. Default = False.
Written by <NAME>, 2020
'''
results_in = pickle.load( open( filename, "rb" ) )
if append == False:
self.orbits = results_in.orbits
self.Update(self.orbits)
else:
self.orbits = np.vstack((self.orbits,results_in.orbits))
self.Update(self.orbits)
# plotting results:
def PlotHists(self):
'''Plot 1-d histograms of orbital elements 'sma','ecc','inc','aop','lan','t0' from fit results.
Written by <NAME>, 2020
'''
if len(self.sma < 50):
bins = 50
else:
bins = 'fd'
fig = plt.figure(figsize=(30, 5.5))
params = np.array([self.sma,self.ecc,self.inc,self.aop,self.lan,self.t0])
names = np.array(['sma','ecc','inc','aop','lan','t0'])
for i in range(len(params)):
ax = plt.subplot2grid((1,len(params)), (0,i))
plt.hist(params[i],bins=bins,edgecolor='none',alpha=0.8)
plt.tick_params(axis='both', left=False, top=False, right=False, bottom=True, \
labelleft=False, labeltop=False, labelright=False, labelbottom=True)
plt.xticks(rotation=45, fontsize = 20)
plt.xlabel(names[i], fontsize = 25)
plt.tight_layout()
return fig
def PlotOrbits(self, color = True, colorbar = True, ref_epoch = 2016.0, size = 100, plot3d = False, cmap = 'viridis',xlim=False,ylim=False):
'''Plot a random selection of orbits from the sample in the plane of the sky.
Args:
color (bool): if True, plot orbit tracks using a colormap scale to orbit fraction (phase) \
past observation date (2015.5). If False, orbit tracks will be black. Default = True
colorbar (bool): if True and color = True, plot colorbar for orbit phase
ref_epoch (flt): reference epoch for drawing orbits. Default = 2015.5
size (int): Number of orbits to plot. Default = True
plot3d (bool): If True, return a plot of orbits in 3D space. Default = False
cmap (str): colormap for orbit phase plot
Written by <NAME>, 2020
'''
# Random selection of orbits to plot:
if len(self.sma) > size:
# if there are more orbits than desired size, randomly select orbits from
# the posterior sample:
ind = np.random.choice(range(0,len(self.sma)),replace=False,size=size)
else:
# if there are fewer orbits than desired size, take all of them:
ind = np.random.choice(range(0,len(self.sma)),replace=False,size=len(self.sma))
from numpy import tan, arctan, sqrt, cos, sin, arccos
# label for colormap axis:
colorlabel = 'Phase'
# create figure:
fig = plt.figure(figsize = (7.5, 6.))
plt.grid(ls=':')
# invert X axis for RA:
plt.gca().invert_xaxis()
if plot3d:
# Make 3d axis object:
ax = fig.add_subplot(111, projection='3d')
# plot central star:
ax.scatter(0,0,0,color='orange',marker='*',s=300,zorder=10)
ax.set_zlabel('Z (")',fontsize=20)
else:
# plot central star:
plt.scatter(0,0,color='orange',marker='*',s=300,zorder=10)
# For each orbit in the random selection from the posterior samples:
for a,T,to,e,i,w,O in zip(self.sma[ind],self.period[ind],self.t0[ind],self.ecc[ind],np.radians(self.inc[ind]),\
np.radians(self.aop[ind]),np.radians(self.lan[ind])):
# define an array of times along orbit:
times = np.linspace(ref_epoch,ref_epoch+T,5000)
X,Y,Z = np.array([]),np.array([]),np.array([])
E = np.array([])
# Compute X,Y,Z positions for each time:
for t in times:
n = (2*np.pi)/T
M = n*(t-to)
nextE = [danby_solve(eccentricity_anomaly, varM,vare, 0.001) for varM,vare in zip([M],[e])]
E = np.append(E,nextE)
r1 = a*(1.-e*cos(E))
f1 = sqrt(1.+e)*sin(E/2.)
f2 = sqrt(1.-e)*cos(E/2.)
f = 2.*np.arctan2(f1,f2)
r = (a*(1.-e**2))/(1.+(e*cos(f)))
X1 = r * ( cos(O)*cos(w+f) - sin(O)*sin(w+f)*cos(i) )
Y1 = r * ( sin(O)*cos(w+f) + cos(O)*sin(w+f)*cos(i) )
Z1 = r * sin(w+f) * sin(i)
X,Y,Z = np.append(X,X1),np.append(Y,Y1),np.append(Z,Z1)
# Plot the X,Y(Z) positions:
if not plot3d:
if color:
plt.scatter(Y,X,c=((times-ref_epoch)/T),cmap=cmap,s=3,lw=0)
plt.gca().set_aspect('equal', adjustable='datalim')
else:
plt.plot(Y,X, color='black',alpha=0.3)
plt.gca().set_aspect('equal', adjustable='datalim')
if plot3d:
from mpl_toolkits.mplot3d import Axes3D
if color:
ax.scatter(Y,X,Z,c=((times-ref_epoch)/T),cmap=cmap,s=3,lw=0)
else:
ax.plot(Y,X,Z, color='black',alpha=0.3)
# plot colorbar:
if not plot3d:
if color:
if colorbar == True:
cb = plt.colorbar().set_label(colorlabel, fontsize=20)
plt.gca().tick_params(labelsize=14)
plt.ylabel('Dec (")',fontsize=20)
plt.xlabel('RA (")',fontsize=20)
plt.gca().tick_params(labelsize=14)
if(xlim):
plt.xlim(xlim)
if(ylim):
plt.ylim(ylim)
return fig
def PlotSepPA(self, ref_epoch = 2016.0, size = 100, timespan = [20,20], orbitcolor = 'skyblue'):
'''Plot a random selection of orbits from the sample in separation and position angle as
a function of time.
Args:
ref_epoch (flt): reference epoch for drawing orbits. Default = 2015.5
size (int): Number of orbits to plot. Default = True
timespan (tuple, int): number of years before [0] and after [1] the ref epoch to \
plot sep and pa
orbitcolor (str): color to use to plot the orbits
Written by <NAME>, 2020
'''
# Random selection of orbits to plot:
if len(self.sma) > size:
# if there are more orbits than desired size, randomly select orbits from
# the posterior sample:
ind = np.random.choice(range(0,len(self.sma)),replace=False,size=size)
else:
# if there are fewer orbits than desired size, take all of them:
ind = np.random.choice(range(0,len(self.sma)),replace=False,size=len(self.sma))
from numpy import tan, arctan, sqrt, cos, sin, arccos
# make figure
fig = plt.figure(figsize = (8, 10))
# define subplots:
plt.subplot(2,1,1)
plt.gca().tick_params(labelsize=14)
plt.grid(ls=':')
# define times to compute sep/pa:
tmin,tmax = ref_epoch - timespan[0],ref_epoch + timespan[1]
t = np.linspace(tmin,tmax,2000)
date_ticks = np.arange(tmin,tmax,10)
# for each selected orbit from the sample:
for a,T,to,e,i,w,O in zip(self.sma[ind],self.period[ind],self.t0[ind],self.ecc[ind],np.radians(self.inc[ind]),\
np.radians(self.aop[ind]),np.radians(self.lan[ind])):
X = np.array([])
Y = np.array([])
# compute X,Y at each time point:
X1,Y1 = orbits_for_plotting(a,T,to,e,i,w,O,t)
X = np.append(X, X1)
Y = np.append(Y,Y1)
# compute sep:
r=np.sqrt((X**2)+(Y**2))
# plot sep in mas:
plt.plot(t,r*1000,color=orbitcolor,alpha=0.5)
plt.ylabel(r'$\rho$ (mas)',fontsize=20)
# next suplot:
plt.subplot(2,1,2)
plt.grid(ls=':')
# for each selected orbit from the sample:
for a,T,to,e,i,w,O in zip(self.sma[ind],self.period[ind],self.t0[ind],self.ecc[ind],np.radians(self.inc[ind]),\
np.radians(self.aop[ind]),np.radians(self.lan[ind])):
X = np.array([])
Y = np.array([])
X1,Y1 = orbits_for_plotting(a,T,to,e,i,w,O,t)
X = np.append(X, X1)
Y = np.append(Y,Y1)
# compute pa:
theta=np.arctan2(X,-Y)
theta=(np.degrees(theta)+270.)%360
# plot it:
plt.plot(t,theta,color=orbitcolor,alpha=0.5)
plt.ylabel(r'P.A. (deg)',fontsize=19)
plt.xlabel('Years',fontsize=19)
plt.gca().tick_params(labelsize=14)
plt.tight_layout()
return fig
class Stats(object):
'''A class for storing and manipulating the statistics of the results of the orbit fit.
For every parameter, there is a series of stats computed and saved as stats.param.stat
Examples:
stats.sma.mean = mean of semimajor axis
stats.ecc.ci68 = 68% confidence interval for eccentricity
stats.aop.std = standard deviation of arg of periastron
Args:
orbits (Norbits x 13 array): array of accepted orbits from \
OFTI fit in the same order as the following attributes
param.mean (flt): mean of parameter computed using np.mean
param.median (flt): np.median of parameter
param.mode (flt): mode of parameter
param.std (flt): standard deviation from np.std
param.ci68 (tuple,flt): 68% minimum credible interval of form (lower bound, upper bound)
param.ci95 (tuple,flt): 95% minimum credible interval
write_to_file (bool): If True, write stats to a human-readbale text file.
filename (str): filename for saving stats file. If not supplied, default \
name is FitResults.Stats.y.mo.d.h.m.s.pkl, saved in same directory as fit was run.
Written by <NAME>, 2020
'''
def __init__(self, orbits = [], write_to_file = False, filename = None):
self.orbits = orbits
# Compute stats on parameter arrays and save as attributes:
self.sma = StatsSubclass(self.orbits[:,0])
self.period = StatsSubclass(self.orbits[:,1])
self.orbit_fraction = StatsSubclass(self.orbits[:,2])
self.t0 = StatsSubclass(self.orbits[:,3])
self.ecc = StatsSubclass(self.orbits[:,4])
self.inc = StatsSubclass(self.orbits[:,5])
self.aop = StatsSubclass(self.orbits[:,6])
self.lan = StatsSubclass(self.orbits[:,7])
self.mtot = StatsSubclass(self.orbits[:,8])
self.distance = StatsSubclass(self.orbits[:,9])
if write_to_file:
params = np.array([self.sma,self.period,self.orbit_fraction,self.t0,self.ecc,self.inc,\
self.aop,self.lan,self.mtot,self.distance])
names = np.array(['sma','period','orbit fraction','t0','ecc','inc','aop','lan','mtot','distance'])
if not filename:
filename = 'FitResults.Stats.'+time.strftime("%Y.%m.%d.%H.%M.%S")+'.txt'
k = open(filename, 'w')
string = 'Parameter Mean Median Mode Std 68% Min Cred Int 95% Min Cred Int'
k.write(string + "\n")
for i in range(len(params)):
string = make_parameter_string(params[i],names[i])
k.write(string + "\n")
k.close()
class StatsSubclass(Stats):
'''Subclass for computing and storing statistics
Args:
array (arr): array for which to compute statistics
'''
def __init__(self, array):
self.mean,self.median,self.mode,self.std,self.ci68,self.ci95 = compute_statistics(array)
|
[
"numpy.radians",
"matplotlib.pyplot.grid",
"matplotlib.pyplot.hist",
"numpy.sqrt",
"matplotlib.pyplot.ylabel",
"numpy.array",
"numpy.arctan2",
"numpy.nanmin",
"numpy.sin",
"numpy.arange",
"numpy.mean",
"numpy.where",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"numpy.max",
"numpy.linspace",
"numpy.vstack",
"numpy.concatenate",
"matplotlib.pyplot.scatter",
"matplotlib.pyplot.ylim",
"numpy.degrees",
"numpy.fromstring",
"matplotlib.pyplot.xticks",
"numpy.average",
"matplotlib.pyplot.gca",
"numpy.size",
"matplotlib.pyplot.tick_params",
"numpy.cos",
"numpy.std",
"matplotlib.pyplot.xlim",
"numpy.transpose",
"time.time",
"warnings.filterwarnings",
"astropy.units.au.to",
"time.strftime",
"matplotlib.pyplot.colorbar",
"numpy.append",
"matplotlib.pyplot.figure",
"numpy.zeros",
"matplotlib.pyplot.tight_layout",
"matplotlib.pyplot.subplot"
] |
[((275, 308), 'warnings.filterwarnings', 'warnings.filterwarnings', (['"""ignore"""'], {}), "('ignore')\n", (298, 308), False, 'import warnings\n'), ((14422, 14529), 'numpy.average', 'np.average', (['[self.plx1[0].value, self.plx2[0].value]'], {'weights': '[self.plx1[1].value, self.plx2[1].value]'}), '([self.plx1[0].value, self.plx2[0].value], weights=[self.plx1[1].\n value, self.plx2[1].value])\n', (14432, 14529), True, 'import numpy as np\n'), ((14542, 14590), 'numpy.max', 'np.max', (['[self.plx1[1].value, self.plx2[1].value]'], {}), '([self.plx1[1].value, self.plx2[1].value])\n', (14548, 14590), True, 'import numpy as np\n'), ((24848, 24863), 'numpy.nanmin', 'np.nanmin', (['chi2'], {}), '(chi2)\n', (24857, 24863), True, 'import numpy as np\n'), ((25025, 25042), 'numpy.size', 'np.size', (['accepted'], {}), '(accepted)\n', (25032, 25042), True, 'import numpy as np\n'), ((25149, 25239), 'numpy.concatenate', 'np.concatenate', (['(parameters, chi2[None, :], lnprob[None, :], lnrand[None, :])'], {'axis': '(0)'}), '((parameters, chi2[None, :], lnprob[None, :], lnrand[None, :]\n ), axis=0)\n', (25163, 25239), True, 'import numpy as np\n'), ((25271, 25295), 'numpy.transpose', 'np.transpose', (['parameters'], {}), '(parameters)\n', (25283, 25295), True, 'import numpy as np\n'), ((25632, 25641), 'time.time', 'tm.time', ([], {}), '()\n', (25639, 25641), True, 'import time as tm\n'), ((31428, 31457), 'numpy.where', 'np.where', (['(lnprob > dat[:, 12])'], {}), '(lnprob > dat[:, 12])\n', (31436, 31457), True, 'import numpy as np\n'), ((32467, 32476), 'time.time', 'tm.time', ([], {}), '()\n', (32474, 32476), True, 'import time as tm\n'), ((37267, 37296), 'matplotlib.pyplot.figure', 'plt.figure', ([], {'figsize': '(30, 5.5)'}), '(figsize=(30, 5.5))\n', (37277, 37296), True, 'import matplotlib.pyplot as plt\n'), ((37314, 37383), 'numpy.array', 'np.array', (['[self.sma, self.ecc, self.inc, self.aop, self.lan, self.t0]'], {}), '([self.sma, self.ecc, self.inc, self.aop, self.lan, self.t0])\n', (37322, 37383), True, 'import numpy as np\n'), ((37395, 37446), 'numpy.array', 'np.array', (["['sma', 'ecc', 'inc', 'aop', 'lan', 't0']"], {}), "(['sma', 'ecc', 'inc', 'aop', 'lan', 't0'])\n", (37403, 37446), True, 'import numpy as np\n'), ((37894, 37912), 'matplotlib.pyplot.tight_layout', 'plt.tight_layout', ([], {}), '()\n', (37910, 37912), True, 'import matplotlib.pyplot as plt\n'), ((39443, 39473), 'matplotlib.pyplot.figure', 'plt.figure', ([], {'figsize': '(7.5, 6.0)'}), '(figsize=(7.5, 6.0))\n', (39453, 39473), True, 'import matplotlib.pyplot as plt\n'), ((39483, 39499), 'matplotlib.pyplot.grid', 'plt.grid', ([], {'ls': '""":"""'}), "(ls=':')\n", (39491, 39499), True, 'import matplotlib.pyplot as plt\n'), ((42049, 42083), 'matplotlib.pyplot.ylabel', 'plt.ylabel', (['"""Dec (")"""'], {'fontsize': '(20)'}), '(\'Dec (")\', fontsize=20)\n', (42059, 42083), True, 'import matplotlib.pyplot as plt\n'), ((42091, 42124), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""RA (")"""'], {'fontsize': '(20)'}), '(\'RA (")\', fontsize=20)\n', (42101, 42124), True, 'import matplotlib.pyplot as plt\n'), ((43471, 43498), 'matplotlib.pyplot.figure', 'plt.figure', ([], {'figsize': '(8, 10)'}), '(figsize=(8, 10))\n', (43481, 43498), True, 'import matplotlib.pyplot as plt\n'), ((43536, 43556), 'matplotlib.pyplot.subplot', 'plt.subplot', (['(2)', '(1)', '(1)'], {}), '(2, 1, 1)\n', (43547, 43556), True, 'import matplotlib.pyplot as plt\n'), ((43607, 43623), 'matplotlib.pyplot.grid', 'plt.grid', ([], {'ls': '""":"""'}), "(ls=':')\n", (43615, 43623), True, 'import matplotlib.pyplot as plt\n'), ((43746, 43775), 'numpy.linspace', 'np.linspace', (['tmin', 'tmax', '(2000)'], {}), '(tmin, tmax, 2000)\n', (43757, 43775), True, 'import numpy as np\n'), ((43795, 43820), 'numpy.arange', 'np.arange', (['tmin', 'tmax', '(10)'], {}), '(tmin, tmax, 10)\n', (43804, 43820), True, 'import numpy as np\n'), ((44452, 44492), 'matplotlib.pyplot.ylabel', 'plt.ylabel', (['"""$\\\\rho$ (mas)"""'], {'fontsize': '(20)'}), "('$\\\\rho$ (mas)', fontsize=20)\n", (44462, 44492), True, 'import matplotlib.pyplot as plt\n'), ((44524, 44544), 'matplotlib.pyplot.subplot', 'plt.subplot', (['(2)', '(1)', '(2)'], {}), '(2, 1, 2)\n', (44535, 44544), True, 'import matplotlib.pyplot as plt\n'), ((44551, 44567), 'matplotlib.pyplot.grid', 'plt.grid', ([], {'ls': '""":"""'}), "(ls=':')\n", (44559, 44567), True, 'import matplotlib.pyplot as plt\n'), ((45190, 45227), 'matplotlib.pyplot.ylabel', 'plt.ylabel', (['"""P.A. (deg)"""'], {'fontsize': '(19)'}), "('P.A. (deg)', fontsize=19)\n", (45200, 45227), True, 'import matplotlib.pyplot as plt\n'), ((45236, 45268), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""Years"""'], {'fontsize': '(19)'}), "('Years', fontsize=19)\n", (45246, 45268), True, 'import matplotlib.pyplot as plt\n'), ((45320, 45338), 'matplotlib.pyplot.tight_layout', 'plt.tight_layout', ([], {}), '()\n', (45336, 45338), True, 'import matplotlib.pyplot as plt\n'), ((15108, 15119), 'numpy.mean', 'np.mean', (['ra'], {}), '(ra)\n', (15115, 15119), True, 'import numpy as np\n'), ((15120, 15130), 'numpy.std', 'np.std', (['ra'], {}), '(ra)\n', (15126, 15130), True, 'import numpy as np\n'), ((15171, 15183), 'numpy.mean', 'np.mean', (['dec'], {}), '(dec)\n', (15178, 15183), True, 'import numpy as np\n'), ((15184, 15195), 'numpy.std', 'np.std', (['dec'], {}), '(dec)\n', (15190, 15195), True, 'import numpy as np\n'), ((15425, 15443), 'numpy.mean', 'np.mean', (['(pr2 - pr1)'], {}), '(pr2 - pr1)\n', (15432, 15443), True, 'import numpy as np\n'), ((15445, 15462), 'numpy.std', 'np.std', (['(pr2 - pr1)'], {}), '(pr2 - pr1)\n', (15451, 15462), True, 'import numpy as np\n'), ((15491, 15509), 'numpy.mean', 'np.mean', (['(pd2 - pd1)'], {}), '(pd2 - pd1)\n', (15498, 15509), True, 'import numpy as np\n'), ((15511, 15528), 'numpy.std', 'np.std', (['(pd2 - pd1)'], {}), '(pd2 - pd1)\n', (15517, 15528), True, 'import numpy as np\n'), ((22195, 22221), 'numpy.zeros', 'np.zeros', (['(19, numSamples)'], {}), '((19, numSamples))\n', (22203, 22221), True, 'import numpy as np\n'), ((22529, 22563), 'numpy.array', 'np.array', (['[Y, X, Ydot, Xdot, Zdot]'], {}), '([Y, X, Ydot, Xdot, Zdot])\n', (22537, 22563), True, 'import numpy as np\n'), ((22579, 22650), 'numpy.array', 'np.array', (['[self.deltaRA, self.deltaDec, self.pmRA, self.pmDec, self.rv]'], {}), '([self.deltaRA, self.deltaDec, self.pmRA, self.pmDec, self.rv])\n', (22587, 22650), True, 'import numpy as np\n'), ((22685, 22713), 'numpy.array', 'np.array', (['[Y, X, Ydot, Xdot]'], {}), '([Y, X, Ydot, Xdot])\n', (22693, 22713), True, 'import numpy as np\n'), ((22730, 22792), 'numpy.array', 'np.array', (['[self.deltaRA, self.deltaDec, self.pmRA, self.pmDec]'], {}), '([self.deltaRA, self.deltaDec, self.pmRA, self.pmDec])\n', (22738, 22792), True, 'import numpy as np\n'), ((23175, 23190), 'numpy.zeros', 'np.zeros', (['(10000)'], {}), '(10000)\n', (23183, 23190), True, 'import numpy as np\n'), ((24299, 24314), 'numpy.zeros', 'np.zeros', (['(10000)'], {}), '(10000)\n', (24307, 24314), True, 'import numpy as np\n'), ((24807, 24822), 'numpy.nanmin', 'np.nanmin', (['chi2'], {}), '(chi2)\n', (24816, 24822), True, 'import numpy as np\n'), ((36882, 36925), 'numpy.vstack', 'np.vstack', (['(self.orbits, results_in.orbits)'], {}), '((self.orbits, results_in.orbits))\n', (36891, 36925), True, 'import numpy as np\n'), ((37549, 37608), 'matplotlib.pyplot.hist', 'plt.hist', (['params[i]'], {'bins': 'bins', 'edgecolor': '"""none"""', 'alpha': '(0.8)'}), "(params[i], bins=bins, edgecolor='none', alpha=0.8)\n", (37557, 37608), True, 'import matplotlib.pyplot as plt\n'), ((37618, 37769), 'matplotlib.pyplot.tick_params', 'plt.tick_params', ([], {'axis': '"""both"""', 'left': '(False)', 'top': '(False)', 'right': '(False)', 'bottom': '(True)', 'labelleft': '(False)', 'labeltop': '(False)', 'labelright': '(False)', 'labelbottom': '(True)'}), "(axis='both', left=False, top=False, right=False, bottom=\n True, labelleft=False, labeltop=False, labelright=False, labelbottom=True)\n", (37633, 37769), True, 'import matplotlib.pyplot as plt\n'), ((37799, 37835), 'matplotlib.pyplot.xticks', 'plt.xticks', ([], {'rotation': '(45)', 'fontsize': '(20)'}), '(rotation=45, fontsize=20)\n', (37809, 37835), True, 'import matplotlib.pyplot as plt\n'), ((37850, 37883), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['names[i]'], {'fontsize': '(25)'}), '(names[i], fontsize=25)\n', (37860, 37883), True, 'import matplotlib.pyplot as plt\n'), ((39885, 39948), 'matplotlib.pyplot.scatter', 'plt.scatter', (['(0)', '(0)'], {'color': '"""orange"""', 'marker': '"""*"""', 's': '(300)', 'zorder': '(10)'}), "(0, 0, color='orange', marker='*', s=300, zorder=10)\n", (39896, 39948), True, 'import matplotlib.pyplot as plt\n'), ((40113, 40138), 'numpy.radians', 'np.radians', (['self.inc[ind]'], {}), '(self.inc[ind])\n', (40123, 40138), True, 'import numpy as np\n'), ((40161, 40186), 'numpy.radians', 'np.radians', (['self.aop[ind]'], {}), '(self.aop[ind])\n', (40171, 40186), True, 'import numpy as np\n'), ((40187, 40212), 'numpy.radians', 'np.radians', (['self.lan[ind]'], {}), '(self.lan[ind])\n', (40197, 40212), True, 'import numpy as np\n'), ((40287, 40330), 'numpy.linspace', 'np.linspace', (['ref_epoch', '(ref_epoch + T)', '(5000)'], {}), '(ref_epoch, ref_epoch + T, 5000)\n', (40298, 40330), True, 'import numpy as np\n'), ((40402, 40414), 'numpy.array', 'np.array', (['[]'], {}), '([])\n', (40410, 40414), True, 'import numpy as np\n'), ((42198, 42212), 'matplotlib.pyplot.xlim', 'plt.xlim', (['xlim'], {}), '(xlim)\n', (42206, 42212), True, 'import matplotlib.pyplot as plt\n'), ((42243, 42257), 'matplotlib.pyplot.ylim', 'plt.ylim', (['ylim'], {}), '(ylim)\n', (42251, 42257), True, 'import matplotlib.pyplot as plt\n'), ((43962, 43987), 'numpy.radians', 'np.radians', (['self.inc[ind]'], {}), '(self.inc[ind])\n', (43972, 43987), True, 'import numpy as np\n'), ((44010, 44035), 'numpy.radians', 'np.radians', (['self.aop[ind]'], {}), '(self.aop[ind])\n', (44020, 44035), True, 'import numpy as np\n'), ((44036, 44061), 'numpy.radians', 'np.radians', (['self.lan[ind]'], {}), '(self.lan[ind])\n', (44046, 44061), True, 'import numpy as np\n'), ((44080, 44092), 'numpy.array', 'np.array', (['[]'], {}), '([])\n', (44088, 44092), True, 'import numpy as np\n'), ((44109, 44121), 'numpy.array', 'np.array', (['[]'], {}), '([])\n', (44117, 44121), True, 'import numpy as np\n'), ((44242, 44258), 'numpy.append', 'np.append', (['X', 'X1'], {}), '(X, X1)\n', (44251, 44258), True, 'import numpy as np\n'), ((44275, 44291), 'numpy.append', 'np.append', (['Y', 'Y1'], {}), '(Y, Y1)\n', (44284, 44291), True, 'import numpy as np\n'), ((44332, 44356), 'numpy.sqrt', 'np.sqrt', (['(X ** 2 + Y ** 2)'], {}), '(X ** 2 + Y ** 2)\n', (44339, 44356), True, 'import numpy as np\n'), ((44398, 44448), 'matplotlib.pyplot.plot', 'plt.plot', (['t', '(r * 1000)'], {'color': 'orbitcolor', 'alpha': '(0.5)'}), '(t, r * 1000, color=orbitcolor, alpha=0.5)\n', (44406, 44448), True, 'import matplotlib.pyplot as plt\n'), ((44711, 44736), 'numpy.radians', 'np.radians', (['self.inc[ind]'], {}), '(self.inc[ind])\n', (44721, 44736), True, 'import numpy as np\n'), ((44759, 44784), 'numpy.radians', 'np.radians', (['self.aop[ind]'], {}), '(self.aop[ind])\n', (44769, 44784), True, 'import numpy as np\n'), ((44785, 44810), 'numpy.radians', 'np.radians', (['self.lan[ind]'], {}), '(self.lan[ind])\n', (44795, 44810), True, 'import numpy as np\n'), ((44829, 44841), 'numpy.array', 'np.array', (['[]'], {}), '([])\n', (44837, 44841), True, 'import numpy as np\n'), ((44858, 44870), 'numpy.array', 'np.array', (['[]'], {}), '([])\n', (44866, 44870), True, 'import numpy as np\n'), ((44945, 44961), 'numpy.append', 'np.append', (['X', 'X1'], {}), '(X, X1)\n', (44954, 44961), True, 'import numpy as np\n'), ((44978, 44994), 'numpy.append', 'np.append', (['Y', 'Y1'], {}), '(Y, Y1)\n', (44987, 44994), True, 'import numpy as np\n'), ((45038, 45055), 'numpy.arctan2', 'np.arctan2', (['X', '(-Y)'], {}), '(X, -Y)\n', (45048, 45055), True, 'import numpy as np\n'), ((45137, 45184), 'matplotlib.pyplot.plot', 'plt.plot', (['t', 'theta'], {'color': 'orbitcolor', 'alpha': '(0.5)'}), '(t, theta, color=orbitcolor, alpha=0.5)\n', (45145, 45184), True, 'import matplotlib.pyplot as plt\n'), ((47352, 47485), 'numpy.array', 'np.array', (['[self.sma, self.period, self.orbit_fraction, self.t0, self.ecc, self.inc,\n self.aop, self.lan, self.mtot, self.distance]'], {}), '([self.sma, self.period, self.orbit_fraction, self.t0, self.ecc,\n self.inc, self.aop, self.lan, self.mtot, self.distance])\n', (47360, 47485), True, 'import numpy as np\n'), ((47511, 47614), 'numpy.array', 'np.array', (["['sma', 'period', 'orbit fraction', 't0', 'ecc', 'inc', 'aop', 'lan',\n 'mtot', 'distance']"], {}), "(['sma', 'period', 'orbit fraction', 't0', 'ecc', 'inc', 'aop',\n 'lan', 'mtot', 'distance'])\n", (47519, 47614), True, 'import numpy as np\n'), ((4688, 4736), 'numpy.sqrt', 'np.sqrt', (['(self.mass1err ** 2 + self.mass2err ** 2)'], {}), '(self.mass1err ** 2 + self.mass2err ** 2)\n', (4695, 4736), True, 'import numpy as np\n'), ((8026, 8074), 'numpy.array', 'np.array', (["[user_rv['rv'] * -1, user_rv['rverr']]"], {}), "([user_rv['rv'] * -1, user_rv['rverr']])\n", (8034, 8074), True, 'import numpy as np\n'), ((8109, 8138), 'numpy.array', 'np.array', (["user_rv['rv_dates']"], {}), "(user_rv['rv_dates'])\n", (8117, 8138), True, 'import numpy as np\n'), ((8954, 8967), 'numpy.radians', 'np.radians', (['x'], {}), '(x)\n', (8964, 8967), True, 'import numpy as np\n'), ((9016, 9029), 'numpy.radians', 'np.radians', (['x'], {}), '(x)\n', (9026, 9029), True, 'import numpy as np\n'), ((14141, 14158), 'numpy.std', 'np.std', (['(rv2 - rv1)'], {}), '(rv2 - rv1)\n', (14147, 14158), True, 'import numpy as np\n'), ((23720, 23785), 'numpy.array', 'np.array', (['[self.astrometric_ra[:, j], self.astrometric_dec[:, j]]'], {}), '([self.astrometric_ra[:, j], self.astrometric_dec[:, j]])\n', (23728, 23785), True, 'import numpy as np\n'), ((23912, 23944), 'numpy.array', 'np.array', (['[Y1 * 1000, X1 * 1000]'], {}), '([Y1 * 1000, X1 * 1000])\n', (23920, 23944), True, 'import numpy as np\n'), ((26180, 26206), 'numpy.zeros', 'np.zeros', (['(19, numSamples)'], {}), '((19, numSamples))\n', (26188, 26206), True, 'import numpy as np\n'), ((26588, 26622), 'numpy.array', 'np.array', (['[Y, X, Ydot, Xdot, Zdot]'], {}), '([Y, X, Ydot, Xdot, Zdot])\n', (26596, 26622), True, 'import numpy as np\n'), ((26642, 26713), 'numpy.array', 'np.array', (['[self.deltaRA, self.deltaDec, self.pmRA, self.pmDec, self.rv]'], {}), '([self.deltaRA, self.deltaDec, self.pmRA, self.pmDec, self.rv])\n', (26650, 26713), True, 'import numpy as np\n'), ((26756, 26784), 'numpy.array', 'np.array', (['[Y, X, Ydot, Xdot]'], {}), '([Y, X, Ydot, Xdot])\n', (26764, 26784), True, 'import numpy as np\n'), ((26805, 26867), 'numpy.array', 'np.array', (['[self.deltaRA, self.deltaDec, self.pmRA, self.pmDec]'], {}), '([self.deltaRA, self.deltaDec, self.pmRA, self.pmDec])\n', (26813, 26867), True, 'import numpy as np\n'), ((27296, 27311), 'numpy.zeros', 'np.zeros', (['(10000)'], {}), '(10000)\n', (27304, 27311), True, 'import numpy as np\n'), ((28523, 28538), 'numpy.zeros', 'np.zeros', (['(10000)'], {}), '(10000)\n', (28531, 28538), True, 'import numpy as np\n'), ((29175, 29192), 'numpy.size', 'np.size', (['accepted'], {}), '(accepted)\n', (29182, 29192), True, 'import numpy as np\n'), ((29546, 29563), 'numpy.size', 'np.size', (['accepted'], {}), '(accepted)\n', (29553, 29563), True, 'import numpy as np\n'), ((29593, 29683), 'numpy.concatenate', 'np.concatenate', (['(parameters, chi2[None, :], lnprob[None, :], lnrand[None, :])'], {'axis': '(0)'}), '((parameters, chi2[None, :], lnprob[None, :], lnrand[None, :]\n ), axis=0)\n', (29607, 29683), True, 'import numpy as np\n'), ((29702, 29726), 'numpy.transpose', 'np.transpose', (['parameters'], {}), '(parameters)\n', (29714, 29726), True, 'import numpy as np\n'), ((30001, 30016), 'numpy.nanmin', 'np.nanmin', (['chi2'], {}), '(chi2)\n', (30010, 30016), True, 'import numpy as np\n'), ((30110, 30125), 'numpy.nanmin', 'np.nanmin', (['chi2'], {}), '(chi2)\n', (30119, 30125), True, 'import numpy as np\n'), ((39540, 39549), 'matplotlib.pyplot.gca', 'plt.gca', ([], {}), '()\n', (39547, 39549), True, 'import matplotlib.pyplot as plt\n'), ((40347, 40359), 'numpy.array', 'np.array', (['[]'], {}), '([])\n', (40355, 40359), True, 'import numpy as np\n'), ((40360, 40372), 'numpy.array', 'np.array', (['[]'], {}), '([])\n', (40368, 40372), True, 'import numpy as np\n'), ((40373, 40385), 'numpy.array', 'np.array', (['[]'], {}), '([])\n', (40381, 40385), True, 'import numpy as np\n'), ((40685, 40704), 'numpy.append', 'np.append', (['E', 'nextE'], {}), '(E, nextE)\n', (40694, 40704), True, 'import numpy as np\n'), ((40754, 40767), 'numpy.sqrt', 'sqrt', (['(1.0 + e)'], {}), '(1.0 + e)\n', (40758, 40767), False, 'from numpy import tan, arctan, sqrt, cos, sin, arccos\n'), ((40765, 40777), 'numpy.sin', 'sin', (['(E / 2.0)'], {}), '(E / 2.0)\n', (40768, 40777), False, 'from numpy import tan, arctan, sqrt, cos, sin, arccos\n'), ((40792, 40805), 'numpy.sqrt', 'sqrt', (['(1.0 - e)'], {}), '(1.0 - e)\n', (40796, 40805), False, 'from numpy import tan, arctan, sqrt, cos, sin, arccos\n'), ((40803, 40815), 'numpy.cos', 'cos', (['(E / 2.0)'], {}), '(E / 2.0)\n', (40806, 40815), False, 'from numpy import tan, arctan, sqrt, cos, sin, arccos\n'), ((40832, 40850), 'numpy.arctan2', 'np.arctan2', (['f1', 'f2'], {}), '(f1, f2)\n', (40842, 40850), True, 'import numpy as np\n'), ((41060, 41066), 'numpy.sin', 'sin', (['i'], {}), '(i)\n', (41063, 41066), False, 'from numpy import tan, arctan, sqrt, cos, sin, arccos\n'), ((41087, 41103), 'numpy.append', 'np.append', (['X', 'X1'], {}), '(X, X1)\n', (41096, 41103), True, 'import numpy as np\n'), ((41103, 41119), 'numpy.append', 'np.append', (['Y', 'Y1'], {}), '(Y, Y1)\n', (41112, 41119), True, 'import numpy as np\n'), ((41119, 41135), 'numpy.append', 'np.append', (['Z', 'Z1'], {}), '(Z, Z1)\n', (41128, 41135), True, 'import numpy as np\n'), ((42132, 42141), 'matplotlib.pyplot.gca', 'plt.gca', ([], {}), '()\n', (42139, 42141), True, 'import matplotlib.pyplot as plt\n'), ((43563, 43572), 'matplotlib.pyplot.gca', 'plt.gca', ([], {}), '()\n', (43570, 43572), True, 'import matplotlib.pyplot as plt\n'), ((45276, 45285), 'matplotlib.pyplot.gca', 'plt.gca', ([], {}), '()\n', (45283, 45285), True, 'import matplotlib.pyplot as plt\n'), ((4963, 4997), 'time.strftime', 'time.strftime', (['"""%Y.%m.%d.%H.%M.%S"""'], {}), "('%Y.%m.%d.%H.%M.%S')\n", (4976, 4997), False, 'import time\n'), ((5059, 5093), 'time.strftime', 'time.strftime', (['"""%Y.%m.%d.%H.%M.%S"""'], {}), "('%Y.%m.%d.%H.%M.%S')\n", (5072, 5093), False, 'import time\n'), ((9394, 9424), 'numpy.fromstring', 'np.fromstring', (['table1'], {'sep': '""" """'}), "(table1, sep=' ')\n", (9407, 9424), True, 'import numpy as np\n'), ((14122, 14140), 'numpy.mean', 'np.mean', (['(rv2 - rv1)'], {}), '(rv2 - rv1)\n', (14129, 14140), True, 'import numpy as np\n'), ((14985, 15034), 'numpy.mean', 'np.mean', (['[self.Dec1[0].value, self.Dec2[0].value]'], {}), '([self.Dec1[0].value, self.Dec2[0].value])\n', (14992, 15034), True, 'import numpy as np\n'), ((15774, 15784), 'numpy.mean', 'np.mean', (['r'], {}), '(r)\n', (15781, 15784), True, 'import numpy as np\n'), ((15792, 15801), 'numpy.std', 'np.std', (['r'], {}), '(r)\n', (15798, 15801), True, 'import numpy as np\n'), ((15853, 15863), 'numpy.mean', 'np.mean', (['p'], {}), '(p)\n', (15860, 15863), True, 'import numpy as np\n'), ((15871, 15880), 'numpy.std', 'np.std', (['p'], {}), '(p)\n', (15877, 15880), True, 'import numpy as np\n'), ((16063, 16076), 'astropy.units.au.to', 'u.au.to', (['u.km'], {}), '(u.km)\n', (16070, 16076), True, 'import astropy.units as u\n'), ((16094, 16107), 'astropy.units.au.to', 'u.au.to', (['u.km'], {}), '(u.km)\n', (16101, 16107), True, 'import astropy.units as u\n'), ((24694, 24724), 'numpy.array', 'np.array', (['[self.user_rv[:, j]]'], {}), '([self.user_rv[:, j]])\n', (24702, 24724), True, 'import numpy as np\n'), ((24724, 24740), 'numpy.array', 'np.array', (['[Zdot]'], {}), '([Zdot])\n', (24732, 24740), True, 'import numpy as np\n'), ((27869, 27934), 'numpy.array', 'np.array', (['[self.astrometric_ra[:, j], self.astrometric_dec[:, j]]'], {}), '([self.astrometric_ra[:, j], self.astrometric_dec[:, j]])\n', (27877, 27934), True, 'import numpy as np\n'), ((28059, 28091), 'numpy.array', 'np.array', (['[Y1 * 1000, X1 * 1000]'], {}), '([Y1 * 1000, X1 * 1000])\n', (28067, 28091), True, 'import numpy as np\n'), ((30544, 30573), 'numpy.where', 'np.where', (['(lnprob > dat[:, 12])'], {}), '(lnprob > dat[:, 12])\n', (30552, 30573), True, 'import numpy as np\n'), ((41049, 41059), 'numpy.sin', 'sin', (['(w + f)'], {}), '(w + f)\n', (41052, 41059), False, 'from numpy import tan, arctan, sqrt, cos, sin, arccos\n'), ((41249, 41315), 'matplotlib.pyplot.scatter', 'plt.scatter', (['Y', 'X'], {'c': '((times - ref_epoch) / T)', 'cmap': 'cmap', 's': '(3)', 'lw': '(0)'}), '(Y, X, c=(times - ref_epoch) / T, cmap=cmap, s=3, lw=0)\n', (41260, 41315), True, 'import matplotlib.pyplot as plt\n'), ((41423, 41463), 'matplotlib.pyplot.plot', 'plt.plot', (['Y', 'X'], {'color': '"""black"""', 'alpha': '(0.3)'}), "(Y, X, color='black', alpha=0.3)\n", (41431, 41463), True, 'import matplotlib.pyplot as plt\n'), ((45074, 45091), 'numpy.degrees', 'np.degrees', (['theta'], {}), '(theta)\n', (45084, 45091), True, 'import numpy as np\n'), ((7071, 7120), 'numpy.array', 'np.array', (["[astrometry['ra'], astrometry['raerr']]"], {}), "([astrometry['ra'], astrometry['raerr']])\n", (7079, 7120), True, 'import numpy as np\n'), ((7164, 7215), 'numpy.array', 'np.array', (["[astrometry['dec'], astrometry['decerr']]"], {}), "([astrometry['dec'], astrometry['decerr']])\n", (7172, 7215), True, 'import numpy as np\n'), ((28946, 28976), 'numpy.array', 'np.array', (['[self.user_rv[:, j]]'], {}), '([self.user_rv[:, j]])\n', (28954, 28976), True, 'import numpy as np\n'), ((28976, 28992), 'numpy.array', 'np.array', (['[Zdot]'], {}), '([Zdot])\n', (28984, 28992), True, 'import numpy as np\n'), ((40729, 40735), 'numpy.cos', 'cos', (['E'], {}), '(E)\n', (40732, 40735), False, 'from numpy import tan, arctan, sqrt, cos, sin, arccos\n'), ((40887, 40893), 'numpy.cos', 'cos', (['f'], {}), '(f)\n', (40890, 40893), False, 'from numpy import tan, arctan, sqrt, cos, sin, arccos\n'), ((40919, 40925), 'numpy.cos', 'cos', (['O'], {}), '(O)\n', (40922, 40925), False, 'from numpy import tan, arctan, sqrt, cos, sin, arccos\n'), ((40926, 40936), 'numpy.cos', 'cos', (['(w + f)'], {}), '(w + f)\n', (40929, 40936), False, 'from numpy import tan, arctan, sqrt, cos, sin, arccos\n'), ((40953, 40959), 'numpy.cos', 'cos', (['i'], {}), '(i)\n', (40956, 40959), False, 'from numpy import tan, arctan, sqrt, cos, sin, arccos\n'), ((40985, 40991), 'numpy.sin', 'sin', (['O'], {}), '(O)\n', (40988, 40991), False, 'from numpy import tan, arctan, sqrt, cos, sin, arccos\n'), ((40992, 41002), 'numpy.cos', 'cos', (['(w + f)'], {}), '(w + f)\n', (40995, 41002), False, 'from numpy import tan, arctan, sqrt, cos, sin, arccos\n'), ((41019, 41025), 'numpy.cos', 'cos', (['i'], {}), '(i)\n', (41022, 41025), False, 'from numpy import tan, arctan, sqrt, cos, sin, arccos\n'), ((47678, 47712), 'time.strftime', 'time.strftime', (['"""%Y.%m.%d.%H.%M.%S"""'], {}), "('%Y.%m.%d.%H.%M.%S')\n", (47691, 47712), False, 'import time\n'), ((40937, 40943), 'numpy.sin', 'sin', (['O'], {}), '(O)\n', (40940, 40943), False, 'from numpy import tan, arctan, sqrt, cos, sin, arccos\n'), ((40944, 40954), 'numpy.sin', 'sin', (['(w + f)'], {}), '(w + f)\n', (40947, 40954), False, 'from numpy import tan, arctan, sqrt, cos, sin, arccos\n'), ((41003, 41009), 'numpy.cos', 'cos', (['O'], {}), '(O)\n', (41006, 41009), False, 'from numpy import tan, arctan, sqrt, cos, sin, arccos\n'), ((41010, 41020), 'numpy.sin', 'sin', (['(w + f)'], {}), '(w + f)\n', (41013, 41020), False, 'from numpy import tan, arctan, sqrt, cos, sin, arccos\n'), ((41329, 41338), 'matplotlib.pyplot.gca', 'plt.gca', ([], {}), '()\n', (41336, 41338), True, 'import matplotlib.pyplot as plt\n'), ((41482, 41491), 'matplotlib.pyplot.gca', 'plt.gca', ([], {}), '()\n', (41489, 41491), True, 'import matplotlib.pyplot as plt\n'), ((41934, 41948), 'matplotlib.pyplot.colorbar', 'plt.colorbar', ([], {}), '()\n', (41946, 41948), True, 'import matplotlib.pyplot as plt\n'), ((42004, 42013), 'matplotlib.pyplot.gca', 'plt.gca', ([], {}), '()\n', (42011, 42013), True, 'import matplotlib.pyplot as plt\n'), ((6241, 6260), 'numpy.mean', 'np.mean', (['astr_ra[i]'], {}), '(astr_ra[i])\n', (6248, 6260), True, 'import numpy as np\n'), ((6327, 6345), 'numpy.std', 'np.std', (['astr_ra[i]'], {}), '(astr_ra[i])\n', (6333, 6345), True, 'import numpy as np\n'), ((6492, 6512), 'numpy.mean', 'np.mean', (['astr_dec[i]'], {}), '(astr_dec[i])\n', (6499, 6512), True, 'import numpy as np\n'), ((6579, 6598), 'numpy.std', 'np.std', (['astr_dec[i]'], {}), '(astr_dec[i])\n', (6585, 6598), True, 'import numpy as np\n')]
|
"""
script to run mc sims on the three associations techniques when the tracks origin are equal. Used to calculate the
total number of correctly associating tracks and total # falsly not associating tracks from the same target.
"""
import numpy as np
from stonesoup.types.state import GaussianState
from data_association.CountingAssociator import CountingAssociator
from data_association.bar_shalom_hypothesis_associators import HypothesisTestDependenceAssociator, \
HypothesisTestIndependenceAssociator
from trackers.kf_dependent_fusion_async_sensors import KalmanFilterDependentFusionAsyncSensors
from utils import open_object
from utils.scenario_generator import generate_scenario_3
start_seed = 0
end_seed = 5 # normally 500
num_mc_iterations = end_seed - start_seed
# params
save_fig = False
# scenario parameters
sigma_process_list = [0.3] # [0.05, 0.05, 0.05, 0.5, 0.5, 0.5, 3, 3, 3]
sigma_meas_radar_list = [50] # [5, 30, 200, 5, 30, 200, 5, 30, 200]
sigma_meas_ais_list = [10] # [10] * 9
radar_meas_rate = 1 # relevant radar meas rates: 1
ais_meas_rate_list = [6] # relevant AIS meas rates: 2 - 12
timesteps = 200
# associator params
association_distance_threshold = 10
consecutive_hits_confirm_association = 3
consecutive_misses_end_association = 2
# dicts to store final results for printing in a latex friendly way
Pc_overall = {} # Pc is the percentage of correctly associating tracks that originate from the same target
something_else_overall = {}
stats = []
for sigma_process, sigma_meas_radar, sigma_meas_ais, ais_meas_rate in zip(sigma_process_list, sigma_meas_radar_list,
sigma_meas_ais_list, ais_meas_rate_list):
for seed in range(start_seed, end_seed):
# generate scenario
generate_scenario_3(seed=seed, permanent_save=False, radar_meas_rate=radar_meas_rate,
ais_meas_rate=ais_meas_rate, sigma_process=sigma_process,
sigma_meas_radar=sigma_meas_radar, sigma_meas_ais=sigma_meas_ais,
timesteps=timesteps)
folder = "temp" # temp instead of seed, as it is not a permanent save
# load ground truth and the measurements
data_folder = "../scenarios/scenario3/" + folder + "/"
ground_truth = open_object.open_object(data_folder + "ground_truth.pk1")
measurements_radar = open_object.open_object(data_folder + "measurements_radar.pk1")
measurements_ais = open_object.open_object(data_folder + "measurements_ais.pk1")
# load start_time
start_time = open_object.open_object(data_folder + "start_time.pk1")
# prior
initial_covar = np.diag([sigma_meas_radar * sigma_meas_ais, sigma_meas_radar * sigma_process,
sigma_meas_radar * sigma_meas_ais, sigma_meas_radar * sigma_process]) ** 2
prior = GaussianState([1, 1.1, -1, 0.9], initial_covar, timestamp=start_time)
kf_dependent_fusion = KalmanFilterDependentFusionAsyncSensors(start_time, prior,
sigma_process_radar=sigma_process,
sigma_process_ais=sigma_process,
sigma_meas_radar=sigma_meas_radar,
sigma_meas_ais=sigma_meas_ais)
tracks_fused_dependent, tracks_radar, tracks_ais = kf_dependent_fusion.track_async(
start_time, measurements_radar, measurements_ais, fusion_rate=1)
# use the CountingAssociator to evaluate whether the tracks are associated
associator = CountingAssociator(association_distance_threshold, consecutive_hits_confirm_association,
consecutive_misses_end_association)
num_correct_associations = 0
num_false_mis_associations = 0
for i in range(1, len(tracks_radar)):
# use the associator to check the association
associated = associator.associate_tracks(tracks_radar[:i], tracks_ais[:i])
if associated:
num_correct_associations += 1
else:
num_false_mis_associations += 1
# save the number of correct associations and false mis associations in a dict
stats_individual = {'seed': seed, 'num_correct_associations': num_correct_associations,
'num_false_mis_associations': num_false_mis_associations}
stats.append(stats_individual)
# todo count the number of associations that turn out to be correct
# calc the #correct_associations and #false_mis_associations
tot_num_correct_associations = sum([stat['num_correct_associations'] for stat in stats])
tot_num_false_mis_associations = sum([stat['num_false_mis_associations'] for stat in stats])
print("")
|
[
"utils.open_object.open_object",
"stonesoup.types.state.GaussianState",
"numpy.diag",
"data_association.CountingAssociator.CountingAssociator",
"trackers.kf_dependent_fusion_async_sensors.KalmanFilterDependentFusionAsyncSensors",
"utils.scenario_generator.generate_scenario_3"
] |
[((1806, 2051), 'utils.scenario_generator.generate_scenario_3', 'generate_scenario_3', ([], {'seed': 'seed', 'permanent_save': '(False)', 'radar_meas_rate': 'radar_meas_rate', 'ais_meas_rate': 'ais_meas_rate', 'sigma_process': 'sigma_process', 'sigma_meas_radar': 'sigma_meas_radar', 'sigma_meas_ais': 'sigma_meas_ais', 'timesteps': 'timesteps'}), '(seed=seed, permanent_save=False, radar_meas_rate=\n radar_meas_rate, ais_meas_rate=ais_meas_rate, sigma_process=\n sigma_process, sigma_meas_radar=sigma_meas_radar, sigma_meas_ais=\n sigma_meas_ais, timesteps=timesteps)\n', (1825, 2051), False, 'from utils.scenario_generator import generate_scenario_3\n'), ((2337, 2394), 'utils.open_object.open_object', 'open_object.open_object', (["(data_folder + 'ground_truth.pk1')"], {}), "(data_folder + 'ground_truth.pk1')\n", (2360, 2394), False, 'from utils import open_object\n'), ((2424, 2487), 'utils.open_object.open_object', 'open_object.open_object', (["(data_folder + 'measurements_radar.pk1')"], {}), "(data_folder + 'measurements_radar.pk1')\n", (2447, 2487), False, 'from utils import open_object\n'), ((2515, 2576), 'utils.open_object.open_object', 'open_object.open_object', (["(data_folder + 'measurements_ais.pk1')"], {}), "(data_folder + 'measurements_ais.pk1')\n", (2538, 2576), False, 'from utils import open_object\n'), ((2625, 2680), 'utils.open_object.open_object', 'open_object.open_object', (["(data_folder + 'start_time.pk1')"], {}), "(data_folder + 'start_time.pk1')\n", (2648, 2680), False, 'from utils import open_object\n'), ((2924, 2993), 'stonesoup.types.state.GaussianState', 'GaussianState', (['[1, 1.1, -1, 0.9]', 'initial_covar'], {'timestamp': 'start_time'}), '([1, 1.1, -1, 0.9], initial_covar, timestamp=start_time)\n', (2937, 2993), False, 'from stonesoup.types.state import GaussianState\n'), ((3025, 3225), 'trackers.kf_dependent_fusion_async_sensors.KalmanFilterDependentFusionAsyncSensors', 'KalmanFilterDependentFusionAsyncSensors', (['start_time', 'prior'], {'sigma_process_radar': 'sigma_process', 'sigma_process_ais': 'sigma_process', 'sigma_meas_radar': 'sigma_meas_radar', 'sigma_meas_ais': 'sigma_meas_ais'}), '(start_time, prior,\n sigma_process_radar=sigma_process, sigma_process_ais=sigma_process,\n sigma_meas_radar=sigma_meas_radar, sigma_meas_ais=sigma_meas_ais)\n', (3064, 3225), False, 'from trackers.kf_dependent_fusion_async_sensors import KalmanFilterDependentFusionAsyncSensors\n'), ((3773, 3901), 'data_association.CountingAssociator.CountingAssociator', 'CountingAssociator', (['association_distance_threshold', 'consecutive_hits_confirm_association', 'consecutive_misses_end_association'], {}), '(association_distance_threshold,\n consecutive_hits_confirm_association, consecutive_misses_end_association)\n', (3791, 3901), False, 'from data_association.CountingAssociator import CountingAssociator\n'), ((2722, 2877), 'numpy.diag', 'np.diag', (['[sigma_meas_radar * sigma_meas_ais, sigma_meas_radar * sigma_process, \n sigma_meas_radar * sigma_meas_ais, sigma_meas_radar * sigma_process]'], {}), '([sigma_meas_radar * sigma_meas_ais, sigma_meas_radar *\n sigma_process, sigma_meas_radar * sigma_meas_ais, sigma_meas_radar *\n sigma_process])\n', (2729, 2877), True, 'import numpy as np\n')]
|
from numpy import exp, pi, cos, sin, tan
from ....Functions.Geometry.inter_line_circle import inter_line_circle
def _comp_point_coordinate(self):
"""Compute the point coordinates needed to plot the Slot.
Parameters
----------
self : HoleM51
A HoleM51 object
Returns
-------
point_dict: dict
A dict of the slot coordinates
"""
Rext = self.get_Rext()
# comp point coordinate (in complex)
alpha = self.comp_alpha()
Wslot = 2 * sin(self.W1 / 2) * (Rext - self.H1)
L = 0.5 * (Wslot - self.W0) / cos(alpha) # ||P2,P5||
# Center of the hole
Z0 = Rext - self.H0
Z2 = Z0 + 1j * self.W0 / 2
Z25 = Z0 - 1j * self.W0 / 2
Z15 = Z25 - self.H2
Z1 = Z2 - 1j * self.W2
Z26 = Z1 - 1j * self.W3
Z12 = Z2 - self.H2
Z13 = Z12 - 1j * self.W2
Z14 = Z13 - 1j * self.W3
Z11 = Z12 + 1j * tan(alpha / 2) * self.H2
Z16 = Z15 - 1j * tan(alpha / 2) * self.H2
# Draw the left side with center P2, and X axis =(P2,P5), Y axis=(P2,P10)
Z3 = self.W4 * exp(1j * (pi / 2 - alpha)) + Z2
Z4 = (self.W4 + self.W5) * exp(1j * (pi / 2 - alpha)) + Z2
Z5 = (Rext - self.H1) * exp(1j * self.W1 / 2)
Z10 = (1j * self.H2) * exp(1j * (pi / 2 - alpha)) + Z2
Z9 = (1j * self.H2 + self.W4) * exp(1j * (pi / 2 - alpha)) + Z2
Z8 = (1j * self.H2 + self.W4 + self.W5) * exp(1j * (pi / 2 - alpha)) + Z2
Z7 = (1j * self.H2 + L) * exp(1j * (pi / 2 - alpha)) + Z2
# Draw the right side with center P25, X axis (P25,P23), Y axis(P25,P17)
Z24 = self.W6 * exp(-1j * (pi / 2 - alpha)) + Z25
Z23 = (self.W6 + self.W7) * exp(-1j * (pi / 2 - alpha)) + Z25
Z22 = (Rext - self.H1) * exp(-1j * self.W1 / 2)
Z17 = (-1j * self.H2) * exp(-1j * (pi / 2 - alpha)) + Z25
Z18 = (-1j * self.H2 + self.W6) * exp(-1j * (pi / 2 - alpha)) + Z25
Z19 = (-1j * self.H2 + self.W6 + self.W7) * exp(-1j * (pi / 2 - alpha)) + Z25
Z20 = (-1j * self.H2 + L) * exp(-1j * (pi / 2 - alpha)) + Z25
# Z6 is the intersection of the line [Z7,Z10] and Circle centre
# (0,0) radius Rext - H1
Zint = inter_line_circle(Z7, Z10, Rext - self.H1)
# Select the point with Re(Z) > 0
if Zint[0].real > 0:
Z6 = Zint[0]
else:
Z6 = Zint[1]
Z21 = Z6.conjugate()
point_dict = dict()
point_dict["Z1"] = Z1
point_dict["Z2"] = Z2
point_dict["Z3"] = Z3
point_dict["Z4"] = Z4
point_dict["Z5"] = Z5
point_dict["Z6"] = Z6
point_dict["Z7"] = Z7
point_dict["Z8"] = Z8
point_dict["Z9"] = Z9
point_dict["Z10"] = Z10
point_dict["Z11"] = Z11
point_dict["Z12"] = Z12
point_dict["Z13"] = Z13
point_dict["Z14"] = Z14
point_dict["Z15"] = Z15
point_dict["Z16"] = Z16
point_dict["Z17"] = Z17
point_dict["Z18"] = Z18
point_dict["Z19"] = Z19
point_dict["Z20"] = Z20
point_dict["Z21"] = Z21
point_dict["Z22"] = Z22
point_dict["Z23"] = Z23
point_dict["Z24"] = Z24
point_dict["Z25"] = Z25
point_dict["Z26"] = Z26
return point_dict
|
[
"numpy.exp",
"numpy.sin",
"numpy.cos",
"numpy.tan"
] |
[((565, 575), 'numpy.cos', 'cos', (['alpha'], {}), '(alpha)\n', (568, 575), False, 'from numpy import exp, pi, cos, sin, tan\n'), ((1175, 1198), 'numpy.exp', 'exp', (['(1.0j * self.W1 / 2)'], {}), '(1.0j * self.W1 / 2)\n', (1178, 1198), False, 'from numpy import exp, pi, cos, sin, tan\n'), ((1691, 1715), 'numpy.exp', 'exp', (['(-1.0j * self.W1 / 2)'], {}), '(-1.0j * self.W1 / 2)\n', (1694, 1715), False, 'from numpy import exp, pi, cos, sin, tan\n'), ((495, 511), 'numpy.sin', 'sin', (['(self.W1 / 2)'], {}), '(self.W1 / 2)\n', (498, 511), False, 'from numpy import exp, pi, cos, sin, tan\n'), ((1052, 1080), 'numpy.exp', 'exp', (['(1.0j * (pi / 2 - alpha))'], {}), '(1.0j * (pi / 2 - alpha))\n', (1055, 1080), False, 'from numpy import exp, pi, cos, sin, tan\n'), ((1115, 1143), 'numpy.exp', 'exp', (['(1.0j * (pi / 2 - alpha))'], {}), '(1.0j * (pi / 2 - alpha))\n', (1118, 1143), False, 'from numpy import exp, pi, cos, sin, tan\n'), ((1224, 1252), 'numpy.exp', 'exp', (['(1.0j * (pi / 2 - alpha))'], {}), '(1.0j * (pi / 2 - alpha))\n', (1227, 1252), False, 'from numpy import exp, pi, cos, sin, tan\n'), ((1292, 1320), 'numpy.exp', 'exp', (['(1.0j * (pi / 2 - alpha))'], {}), '(1.0j * (pi / 2 - alpha))\n', (1295, 1320), False, 'from numpy import exp, pi, cos, sin, tan\n'), ((1370, 1398), 'numpy.exp', 'exp', (['(1.0j * (pi / 2 - alpha))'], {}), '(1.0j * (pi / 2 - alpha))\n', (1373, 1398), False, 'from numpy import exp, pi, cos, sin, tan\n'), ((1432, 1460), 'numpy.exp', 'exp', (['(1.0j * (pi / 2 - alpha))'], {}), '(1.0j * (pi / 2 - alpha))\n', (1435, 1460), False, 'from numpy import exp, pi, cos, sin, tan\n'), ((1562, 1591), 'numpy.exp', 'exp', (['(-1.0j * (pi / 2 - alpha))'], {}), '(-1.0j * (pi / 2 - alpha))\n', (1565, 1591), False, 'from numpy import exp, pi, cos, sin, tan\n'), ((1628, 1657), 'numpy.exp', 'exp', (['(-1.0j * (pi / 2 - alpha))'], {}), '(-1.0j * (pi / 2 - alpha))\n', (1631, 1657), False, 'from numpy import exp, pi, cos, sin, tan\n'), ((1742, 1771), 'numpy.exp', 'exp', (['(-1.0j * (pi / 2 - alpha))'], {}), '(-1.0j * (pi / 2 - alpha))\n', (1745, 1771), False, 'from numpy import exp, pi, cos, sin, tan\n'), ((1814, 1843), 'numpy.exp', 'exp', (['(-1.0j * (pi / 2 - alpha))'], {}), '(-1.0j * (pi / 2 - alpha))\n', (1817, 1843), False, 'from numpy import exp, pi, cos, sin, tan\n'), ((1896, 1925), 'numpy.exp', 'exp', (['(-1.0j * (pi / 2 - alpha))'], {}), '(-1.0j * (pi / 2 - alpha))\n', (1899, 1925), False, 'from numpy import exp, pi, cos, sin, tan\n'), ((1962, 1991), 'numpy.exp', 'exp', (['(-1.0j * (pi / 2 - alpha))'], {}), '(-1.0j * (pi / 2 - alpha))\n', (1965, 1991), False, 'from numpy import exp, pi, cos, sin, tan\n'), ((883, 897), 'numpy.tan', 'tan', (['(alpha / 2)'], {}), '(alpha / 2)\n', (886, 897), False, 'from numpy import exp, pi, cos, sin, tan\n'), ((929, 943), 'numpy.tan', 'tan', (['(alpha / 2)'], {}), '(alpha / 2)\n', (932, 943), False, 'from numpy import exp, pi, cos, sin, tan\n')]
|
print("\n")
print("PythonExercises-v2 by <NAME>")
print("\n")
print("=== EXERCISE 1 ===")
print("\n")
print("(a) 5 / 3 = " + str(5 / 3))
print("=> with python3 you can receive a float even if you divide two \
integers")
print("\n")
print("(b) 5 % 3 = " + str(5 % 3))
print("=> % is the modulus which divides left hand operand by right hand \
operand and returns remainder")
print("\n")
print("(c) 5.0 / 3 = " + str(5.0 / 3))
print("=> outputs a float number.. there is no difference if a plain 5 or 5.0 \
is used")
print("\n")
print("(d) 5 / 3.0 = " + str(5 / 3.0))
print("=> outputs a float number.. there is no difference if a plain 3 or 3.0 \
is used")
print("\n")
print("(e) 5.2 % 3 = " + str(5.2 % 3))
print("=> % is the modulus which divides left hand operand by right hand \
operand and returns remainder")
print("\n")
print("=== EXERCISE 2 ===")
print("\n")
print("(a) 2000.3 ** 200 = ...")
try:
print(str(2000.3 ** 200))
except OverflowError as e:
print("=> The python3 interpreter throws a OverflowError " + str(e))
print("\n")
print("(b) 1.0 + 1.0 - 1.0 = " + str(1.0 + 1.0 - 1.0))
print("=> Addition and substraction of float values which results in another \
float value")
print("\n")
print("(c) 1.0 + 1.0e20 - 1.0e20 = " + str(1.0 + 1.0e20 - 1.0e20))
print("=> 1.0 + 1.0e20 is rounded as close as possible, which is 1.0e20 and \
after substraction of it again it results in 0.0")
print("\n")
print("=== EXERCISE 3 ===")
print("\n")
print("(a) float(123) = " + str(float(123)))
print("=> Takes the integer value 123 as input and casts it to the float \
value 123.0")
print("\n")
print("(b) float('123') = " + str(float('123')))
print("=> Takes the string '123' as input and casts it to the float value \
123.0")
print("\n")
print("(c) float('123.23') = " + str(float('123.23')))
print("=> Takes the string '123.23' as input and casts it to the float value \
123.23")
print("\n")
print("(d) int(123.23) = " + str(int(123.23)))
print("=> Takes the float 123.23 as input and casts it to the integer value \
123")
print("\n")
print("(e) int('123.23') = ...")
try:
int('123.23')
except ValueError as e:
print("=> The int() function can't cast a string to float to int and thus \
throws a ValueError (" + str(e) + ")")
print("\n")
print("(f) int(float('123.23')) = " + str(int(float(123.23))))
print("=> As we cast the string to float first, we can use it as a input to \
the int() function and receive a integer")
print("\n")
print("(g) str(12) = " + str(12))
print("=> Takes the integer 12 as input and casts it to the string '12'")
print("\n")
print("(h) str(12.2) = " + str(12.2))
print("=> Takes the float 12.2 as input and casts it to the string '12.2'")
print("\n")
print("(i) bool('a') = " + str(bool('a')))
print("=> Because an actual value (the character 'a') is passed to the bool() \
function, True is returned")
print("\n")
print("(j) bool(0) = " + str(bool(0)))
print("=> The boolean value False equals 0 in python, thus False is returned")
print("\n")
print("(k) bool(0.1) = " + str(bool(0.1)))
print("=> Because a value != 0 is provided in the bool() function, \
it returns True")
print("\n")
print("=== EXERCISE 4 ===")
print("\n")
print("range(5) = {}".format(range(5)))
print("=> range(5) returns a sequence of integers from 0 to 4. for i in \
range(5) is consequently iterating over the sequence of integers")
print("\n")
print("type(range(5)) = {}".format(type(range(5))))
print("=> The type function returns an object's class. For range(5) the class \
range is returned")
print("\n")
print("=== EXERCISE 5 ===")
print("\n")
def div_by_number(numbers_list, max_found):
number_found = 0
x = 1
while number_found < max_found:
for number in numbers_list:
if x % number == 0:
print(x)
number_found = number_found + 1
x = x + 1
numbers_list = [5, 7, 11]
print("div_by_number({}, 20)\n".format(numbers_list))
div_by_number(numbers_list, 20)
print("\n")
print("=== EXERCISE 6 ===")
print("\n")
print("(a) & (b)\n")
def is_prime(n):
if n <= 3:
return n > 1
elif n % 2 == 0 or n % 3 == 0:
return False
i = 5
while i * i <= n:
if n % i == 0 or n % (i + 2) == 0:
return False
i = i + 6
return True
print("is_prime(0) = {}\n".format(is_prime(0)))
print("is_prime(1) = {}\n".format(is_prime(1)))
print("is_prime(3) = {}\n".format(is_prime(3)))
print("is_prime(7) = {}\n".format(is_prime(7)))
print("is_prime(8) = {}\n".format(is_prime(8)))
print("is_prime(112331) = {}".format(is_prime(112331)))
def primes_up_to(n):
primes = []
for i in range(0, n):
if is_prime(i):
primes.append(i)
return primes
print("\n(c) primes_up_to(100) = {}".format(primes_up_to(100)))
def first_primes(n):
primes = []
i = 0
while len(primes) < n:
if is_prime(i):
primes.append(i)
i = i + 1
return primes
print("\n(d) first_primes(12) = {}".format(first_primes(12)))
print("\n")
print("=== EXERCISE 7 ===")
print("\n")
print("(a) print_elements(elements_list)\n")
def print_elements(elements):
for element in elements:
print(element)
elements_list = [12, "abc", 92.2, "hello"]
print_elements(elements_list)
print("\n(b) print_elements_reverse(elements_list)\n")
def print_elements_reverse(elements):
for element in elements[::-1]:
print(element)
print_elements_reverse(elements_list)
print("\n(c) len_elements(elements_list)\n")
def len_elements(elements):
count = 0
for _ in elements:
count = count + 1
return count
print("len_elements(elements_list) = {}".format(len_elements(elements_list)))
print("\n")
print("=== EXERCISE 8 ===")
a = [12, "abc", 92.2, "hello"]
print("\n")
print("(a) a = {}".format(a))
print("\n(b) b = a")
b = a
print("\n(c) b[1] = 'changed'")
b[1] = "changed"
print("\n(d) a = {}".format(a))
print("=> b is binding to the same object as a, so when b[1] was changed \
a[1] also shows the change")
print("\n(e) c = a[:]")
c = a[:]
print("\n(f) c[2] = 'also changed'")
c[2] = "also changed"
print("\n(g) a = {}".format(a))
print("=> A copy of the list a was created with a[:] and assigned to c, thus \
a[2] did not change when c[2] changed")
def set_first_elem_to_zero(l):
if len(l) > 0:
l[0] = 0
return l
numbers = [12, 21, 214, 3]
print("\n...")
print("\nnumbers = {}".format(numbers))
print("set_first_elem_to_zero(numbers) = \
{}".format(set_first_elem_to_zero(numbers)))
print("numbers = {}".format(numbers))
print("=> The original list also changed, even though we did not assign \
the returned list to it (same binding)")
print("\n")
print("=== EXERCISE 9 ===")
elements = [[1,3], [3,6]]
print("\n")
print("elements = {}".format(elements))
flat_list = lambda l: [element for sublist in l for element in sublist]
print("flat_list(elements) = {}".format(flat_list(elements)))
print("\n")
print("=== EXERCISE 10 ===")
import matplotlib.pyplot as plt
import numpy as np
t = np.arange(0.0, 2.0, 0.01)
s = np.sin(t - 2) ** 2 * np.e ** (-t ** 2)
fig, ax = plt.subplots()
ax.plot(t, s)
ax.set(xlabel='x', ylabel='y',
title='Exercise 10')
plt.show()
print("\n")
print("See Figure_1.png")
print("\n")
print("=== EXERCISE 11 ===")
def product_iteration(numbers):
product = 0
if len(numbers) > 0:
product = numbers.pop()
for number in numbers:
product = product * number
return product
from functools import reduce
def product_recursive(numbers):
if len(numbers) > 0:
return reduce((lambda x, y: x * y), numbers)
else:
return 0
numbers = [21, 12, 10, 128, 2]
empty_list = []
print("\n")
print("product_iteration(numbers) = {}".format(product_iteration(numbers)))
print("product_iteration(empty_list) = \
{}".format(product_iteration(empty_list)))
numbers = [21, 12, 10, 128, 2]
print("\n")
print("product_recursive(numbers) = {}".format(product_recursive(numbers)))
print("product_recursive(empty_list) = \
{}".format(product_recursive(empty_list)))
print("\n")
print("=== EXERCISE 12 ===")
print("\n\nGood to know!")
print("\n")
print("=== EXERCISE 13 ===")
def read_file(filename):
with open(filename, 'r') as myfile:
data=myfile.read().replace('\n', '')
return data
file_content = read_file("emails.txt")
print("\n\nread_file('emails.txt')\n\n{}".format(file_content))
import re
def extract_email(string):
match = re.findall(r'[\w\.-]+@[\w\.-]+\.\w+', string)
return match
print("\nextract_email(file_content)\
\n\n{}".format(extract_email(file_content)))
|
[
"functools.reduce",
"numpy.sin",
"re.findall",
"matplotlib.pyplot.subplots",
"numpy.arange",
"matplotlib.pyplot.show"
] |
[((7097, 7122), 'numpy.arange', 'np.arange', (['(0.0)', '(2.0)', '(0.01)'], {}), '(0.0, 2.0, 0.01)\n', (7106, 7122), True, 'import numpy as np\n'), ((7177, 7191), 'matplotlib.pyplot.subplots', 'plt.subplots', ([], {}), '()\n', (7189, 7191), True, 'import matplotlib.pyplot as plt\n'), ((7266, 7276), 'matplotlib.pyplot.show', 'plt.show', ([], {}), '()\n', (7274, 7276), True, 'import matplotlib.pyplot as plt\n'), ((8547, 8597), 're.findall', 're.findall', (['"""[\\\\w\\\\.-]+@[\\\\w\\\\.-]+\\\\.\\\\w+"""', 'string'], {}), "('[\\\\w\\\\.-]+@[\\\\w\\\\.-]+\\\\.\\\\w+', string)\n", (8557, 8597), False, 'import re\n'), ((7127, 7140), 'numpy.sin', 'np.sin', (['(t - 2)'], {}), '(t - 2)\n', (7133, 7140), True, 'import numpy as np\n'), ((7660, 7695), 'functools.reduce', 'reduce', (['(lambda x, y: x * y)', 'numbers'], {}), '(lambda x, y: x * y, numbers)\n', (7666, 7695), False, 'from functools import reduce\n')]
|
#-------------------------------------------------------------------------------
# This function defines the sea level change timeseries for marine ice sheet problem.
# *Default = sinusoidal tidal cycle if 'tides' with 1m amplitude if 'tides' turned 'on', OR...
# = zero if 'tides' turned 'off'
#-------------------------------------------------------------------------------
import numpy as np
from params import t_final,nt_per_year,tides
def sl_change(t):
if tides == 'on':
SLC = np.sin(4*np.pi*t/(3.154e7/12.0/30.0)) # tidal frequency of 2 per day
else:
SLC = 0.0 # no sea level change for
# long-time marine problem
return SLC
|
[
"numpy.sin"
] |
[((505, 555), 'numpy.sin', 'np.sin', (['(4 * np.pi * t / (31540000.0 / 12.0 / 30.0))'], {}), '(4 * np.pi * t / (31540000.0 / 12.0 / 30.0))\n', (511, 555), True, 'import numpy as np\n')]
|
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits import mplot3d
# from scipy.stats import entropy
import sys
sys.path.append('../')
import cloudtropy
# data
gen_dim = 2
gen_N = 300
lims = (-2,6)
scale = 0.2
X = np.random.uniform(low=lims[0],high=lims[1],size=(10000,2)) # background
X = np.concatenate([X,scale*np.random.randn(gen_N,gen_dim)+np.array([0,0])] )
X = np.concatenate([X,scale*np.random.randn(gen_N,gen_dim)+np.array([4,0])] )
X = np.concatenate([X,scale*np.random.randn(gen_N,gen_dim)+np.array([0,4])] )
X = np.concatenate([X,scale*np.random.randn(gen_N,gen_dim)+np.array([4,4])] )
# input parameters
N_grid = 80
delta_c = 0.35
# grid,pmf = cloudtropy.pmf(X,N=N_grid,delta_c=delta_c,lims=[(-2,6),(-2,6)])
grid,pmf = cloudtropy.pmf(X,d=0.1,delta_c=delta_c,lims=[(-2,6),(-2,6)])
entropy = cloudtropy.entropy(X,base=2,N=N_grid,delta_c=delta_c,lims=[(-3,7),(-3,7)])
print(cloudtropy.entropy(X,base=2,d=0.1,delta_c=delta_c,lims=[(-3,7),(-3,7)]))
############## All in one
fig = plt.figure(figsize=(14,3))
#
ax1 = fig.add_subplot(1,4,1)
# levels = np.linspace(0,flat_pmf.max(),40)
ax1.scatter(X[:,0], X[:,1],s=1,alpha=0.1,color='k')
ax1.set_xlabel('x'),ax1.set_ylabel('y')
ax1.set_xlim(lims),ax1.set_xlim(lims)
ax1.axis('equal')
#
ax2 = fig.add_subplot(1,3,2,projection='3d')
ax2.plot_surface(grid[0], grid[1], pmf,cmap='coolwarm', edgecolor='none',shade='interp')
ax2.set_xlabel('x'),ax2.set_ylabel('y')#,ax.set_zlabel('PMF',rotation=90)
ax2.view_init(elev=60, azim=-45)
#
ax3 = fig.add_subplot(1,3,3)
cs = ax3.contourf(grid[0], grid[1], pmf, levels=np.linspace(0,pmf.max(),40), cmap='Purples_r')
ax3.set_xlabel('x'),ax3.set_ylabel('y')
ax3.set_title('Entropy = %.3f'%entropy)
ax3.set_xlim(lims),ax3.set_xlim(lims),
ax3.axis('equal')
cbar = fig.colorbar(cs)
#
plt.tight_layout()
# plt.savefig('all.pdf')
plt.savefig('all.png',dpi=400)
############## Separate
fig = plt.figure(figsize=(4,3))
#
ax1 = fig.add_subplot(1,1,1)
# levels = np.linspace(0,flat_pmf.max(),40)
ax1.scatter(X[:,0], X[:,1],s=1,alpha=0.1,color='k')
ax1.set_xlabel('x'),ax1.set_ylabel('y')
ax1.set_xlim(lims),ax1.set_xlim(lims)
ax1.axis('equal')
plt.savefig('scatter.png',dpi=400)
#
fig = plt.figure(figsize=(4,3))
#
ax2 = fig.add_subplot(1,1,1,projection='3d')
ax2.plot_surface(grid[0], grid[1], pmf,cmap='coolwarm', edgecolor='none',shade='interp')
ax2.set_xlabel('x'),ax2.set_ylabel('y')#,ax.set_zlabel('PMF',rotation=90)
ax2.view_init(elev=60, azim=-45)
plt.savefig('surf.png',dpi=400)
#
fig = plt.figure(figsize=(4,3))
#
ax3 = fig.add_subplot(1,1,1)
cs = ax3.contourf(grid[0], grid[1], pmf, levels=np.linspace(0,pmf.max(),40), cmap='Purples_r')
# ax3.set_xlabel('x'),ax3.set_ylabel('y')
# ax3.set_title('Entropy = %.3f'%entropy)
ax3.set_xlim(lims),ax3.set_xlim(lims),
ax3.axis('equal')
cbar = fig.colorbar(cs)
#
plt.tight_layout()
# plt.savefig('all.pdf')
plt.savefig('contour_simple.png',dpi=400)
|
[
"matplotlib.pyplot.savefig",
"cloudtropy.entropy",
"cloudtropy.pmf",
"numpy.array",
"matplotlib.pyplot.figure",
"numpy.random.randn",
"matplotlib.pyplot.tight_layout",
"numpy.random.uniform",
"sys.path.append"
] |
[((133, 155), 'sys.path.append', 'sys.path.append', (['"""../"""'], {}), "('../')\n", (148, 155), False, 'import sys\n'), ((239, 300), 'numpy.random.uniform', 'np.random.uniform', ([], {'low': 'lims[0]', 'high': 'lims[1]', 'size': '(10000, 2)'}), '(low=lims[0], high=lims[1], size=(10000, 2))\n', (256, 300), True, 'import numpy as np\n'), ((761, 827), 'cloudtropy.pmf', 'cloudtropy.pmf', (['X'], {'d': '(0.1)', 'delta_c': 'delta_c', 'lims': '[(-2, 6), (-2, 6)]'}), '(X, d=0.1, delta_c=delta_c, lims=[(-2, 6), (-2, 6)])\n', (775, 827), False, 'import cloudtropy\n'), ((832, 917), 'cloudtropy.entropy', 'cloudtropy.entropy', (['X'], {'base': '(2)', 'N': 'N_grid', 'delta_c': 'delta_c', 'lims': '[(-3, 7), (-3, 7)]'}), '(X, base=2, N=N_grid, delta_c=delta_c, lims=[(-3, 7), (-3,\n 7)])\n', (850, 917), False, 'import cloudtropy\n'), ((1023, 1050), 'matplotlib.pyplot.figure', 'plt.figure', ([], {'figsize': '(14, 3)'}), '(figsize=(14, 3))\n', (1033, 1050), True, 'import matplotlib.pyplot as plt\n'), ((1805, 1823), 'matplotlib.pyplot.tight_layout', 'plt.tight_layout', ([], {}), '()\n', (1821, 1823), True, 'import matplotlib.pyplot as plt\n'), ((1849, 1880), 'matplotlib.pyplot.savefig', 'plt.savefig', (['"""all.png"""'], {'dpi': '(400)'}), "('all.png', dpi=400)\n", (1860, 1880), True, 'import matplotlib.pyplot as plt\n'), ((1912, 1938), 'matplotlib.pyplot.figure', 'plt.figure', ([], {'figsize': '(4, 3)'}), '(figsize=(4, 3))\n', (1922, 1938), True, 'import matplotlib.pyplot as plt\n'), ((2161, 2196), 'matplotlib.pyplot.savefig', 'plt.savefig', (['"""scatter.png"""'], {'dpi': '(400)'}), "('scatter.png', dpi=400)\n", (2172, 2196), True, 'import matplotlib.pyplot as plt\n'), ((2204, 2230), 'matplotlib.pyplot.figure', 'plt.figure', ([], {'figsize': '(4, 3)'}), '(figsize=(4, 3))\n', (2214, 2230), True, 'import matplotlib.pyplot as plt\n'), ((2473, 2505), 'matplotlib.pyplot.savefig', 'plt.savefig', (['"""surf.png"""'], {'dpi': '(400)'}), "('surf.png', dpi=400)\n", (2484, 2505), True, 'import matplotlib.pyplot as plt\n'), ((2513, 2539), 'matplotlib.pyplot.figure', 'plt.figure', ([], {'figsize': '(4, 3)'}), '(figsize=(4, 3))\n', (2523, 2539), True, 'import matplotlib.pyplot as plt\n'), ((2832, 2850), 'matplotlib.pyplot.tight_layout', 'plt.tight_layout', ([], {}), '()\n', (2848, 2850), True, 'import matplotlib.pyplot as plt\n'), ((2876, 2918), 'matplotlib.pyplot.savefig', 'plt.savefig', (['"""contour_simple.png"""'], {'dpi': '(400)'}), "('contour_simple.png', dpi=400)\n", (2887, 2918), True, 'import matplotlib.pyplot as plt\n'), ((915, 993), 'cloudtropy.entropy', 'cloudtropy.entropy', (['X'], {'base': '(2)', 'd': '(0.1)', 'delta_c': 'delta_c', 'lims': '[(-3, 7), (-3, 7)]'}), '(X, base=2, d=0.1, delta_c=delta_c, lims=[(-3, 7), (-3, 7)])\n', (933, 993), False, 'import cloudtropy\n'), ((370, 386), 'numpy.array', 'np.array', (['[0, 0]'], {}), '([0, 0])\n', (378, 386), True, 'import numpy as np\n'), ((448, 464), 'numpy.array', 'np.array', (['[4, 0]'], {}), '([4, 0])\n', (456, 464), True, 'import numpy as np\n'), ((526, 542), 'numpy.array', 'np.array', (['[0, 4]'], {}), '([0, 4])\n', (534, 542), True, 'import numpy as np\n'), ((604, 620), 'numpy.array', 'np.array', (['[4, 4]'], {}), '([4, 4])\n', (612, 620), True, 'import numpy as np\n'), ((339, 370), 'numpy.random.randn', 'np.random.randn', (['gen_N', 'gen_dim'], {}), '(gen_N, gen_dim)\n', (354, 370), True, 'import numpy as np\n'), ((417, 448), 'numpy.random.randn', 'np.random.randn', (['gen_N', 'gen_dim'], {}), '(gen_N, gen_dim)\n', (432, 448), True, 'import numpy as np\n'), ((495, 526), 'numpy.random.randn', 'np.random.randn', (['gen_N', 'gen_dim'], {}), '(gen_N, gen_dim)\n', (510, 526), True, 'import numpy as np\n'), ((573, 604), 'numpy.random.randn', 'np.random.randn', (['gen_N', 'gen_dim'], {}), '(gen_N, gen_dim)\n', (588, 604), True, 'import numpy as np\n')]
|
#!/usr/bin/env python
# _*_ encoding: utf-8 _*_
"""simplex.py: Simplex algorithm with rational coefficients"""
import numpy as np
import fractions as frac
__author__ = "<NAME>"
__email__ = "<EMAIL>"
class RestrictedSimplex(object):
def __init__(self, leaving_index=None, entering_index=None):
if not leaving_index:
def func(l):
m = 0
while not l[m] and m < len(l):
m += 1
if m == len(l):
return 0
for i in range(len(l)):
if l[i] and l[m] > l[i]:
m = i
return m
leaving_index = func
if not entering_index:
def func(l):
return l.index(min(l))
entering_index = func
self.leaving_index = leaving_index
self.entering_index = entering_index
def __call__(self, lin_p, recursion_limit=100):
""" Runs a restricted version of the simplex algorithm
Runs simplex algorithm on linear programs having feasible basic
solution. It takes in an integer to limit the number of recursions.
:return: a linear program whose basic solution has maximal objective
value.
"""
a = lin_p.table
if not lin_p.has_feasible_basic:
raise TypeError("Linear program doesn't have feasible base solution")
n = 0
while any(a[0, :-1] < 0) and n < recursion_limit:
entering_choices = [i for i in map(lambda x: 0 if x > 0 else x,
a[0, :-1])]
e = self.entering_index(entering_choices)
leaving_choices = [None]*lin_p.shape[0]
for i in range(lin_p.shape[0]):
if a[i+1, e] > 0:
leaving_choices[i] = (a[i+1, -1]/a[i+1, e])
if not [i for i in leaving_choices if i]:
raise OverflowError("Linear program unbounded | check model and state.")
else:
l = 1 + self.leaving_index(leaving_choices)
lin_p.pivot(e, l)
n += 1
form = "Basic solution = " + \
"(" + "{}, " * (lin_p.shape[1] - 1) + "{})" + \
" with objective value = {}."
print(form.format(*lin_p.basic_solution(), lin_p.table[0, -1]), end="\n\n")
return lin_p.basic_solution(), lin_p.table[0, -1]
class Simplex(RestrictedSimplex):
def is_feasible(self, lin_p):
""" Checks if linear program is feasible..
Has side effect: transforms linear program if not basic feasible
into an equivalent linear program having basic feasible solution.
:return: boolean.
"""
print(" ### Checking feasibility of linear program", lin_p, sep="\n\n")
if lin_p.has_feasible_basic():
print(" ### Input linear program has feasible basic solution", end="\n\n")
return True
print(" ### Basic solution is not feasible: using auxiliary linear program in next step", end="\n\n")
gain_fun = np.copy(lin_p.table[0])
lin_p.shape = (lin_p.shape[0], lin_p.shape[1] + 1)
lin_p.table = np.insert(lin_p.table, 0, frac.Fraction(-1, 1), axis=1)
lin_p.table[0] = np.hstack((np.ones(1, dtype=frac.Fraction),
np.zeros(lin_p.shape[1], dtype=frac.Fraction)))
lin_p.basic = [i+1 for i in lin_p.basic]
l = 1 + np.argmin(lin_p.table[1:, -1])
lin_p.pivot(0, l) # Now program has feasible basic solution
if RestrictedSimplex.__call__(self, lin_p)[1] == 0:
print(" ### Input linear program is thus feasible", end="\n\n")
if 0 in lin_p.basic:
l = lin_p.basic.index(0)
e = 0
while e < lin_p.shape and lin_p.table[l, e] == 0:
# There is a at least an e with this property
# Unbounded otherwise
e += 1
lin_p.pivot(e, l) # 0 not basic anymore
lin_p.basic = [i-1 for i in lin_p.basic]
lin_p.table = lin_p.table[:, 1:]
lin_p.shape = (lin_p.shape[0], lin_p.shape[1] - 1)
lin_p.table[0] = gain_fun
for i in lin_p.basic:
lin_p.table[0, :] = lin_p.table[0, :] - \
lin_p.table[0, i] * \
lin_p.table[1 + lin_p.basic.index(i), :]
lin_p.table[0, -1] = -lin_p.table[0, -1]
return True
else:
return False
def __call__(self, lin_p, recursion_limit=100):
""" Simplex algorithm.
:return: a linear program whose basic solution has maximal objective
value.
"""
if self.is_feasible(lin_p):
simplex = RestrictedSimplex(self.leaving_index,
self.entering_index)
print(" ### Getting back to linear program equivalent to input with feasible basic solution", end="\n\n")
return simplex(lin_p, recursion_limit=recursion_limit)
else:
raise Exception("Linear program is not feasible.")
|
[
"numpy.copy",
"numpy.ones",
"fractions.Fraction",
"numpy.zeros",
"numpy.argmin"
] |
[((3105, 3128), 'numpy.copy', 'np.copy', (['lin_p.table[0]'], {}), '(lin_p.table[0])\n', (3112, 3128), True, 'import numpy as np\n'), ((3237, 3257), 'fractions.Fraction', 'frac.Fraction', (['(-1)', '(1)'], {}), '(-1, 1)\n', (3250, 3257), True, 'import fractions as frac\n'), ((3486, 3516), 'numpy.argmin', 'np.argmin', (['lin_p.table[1:, -1]'], {}), '(lin_p.table[1:, -1])\n', (3495, 3516), True, 'import numpy as np\n'), ((3303, 3334), 'numpy.ones', 'np.ones', (['(1)'], {'dtype': 'frac.Fraction'}), '(1, dtype=frac.Fraction)\n', (3310, 3334), True, 'import numpy as np\n'), ((3372, 3417), 'numpy.zeros', 'np.zeros', (['lin_p.shape[1]'], {'dtype': 'frac.Fraction'}), '(lin_p.shape[1], dtype=frac.Fraction)\n', (3380, 3417), True, 'import numpy as np\n')]
|
# STL imports
import random
import logging
import string
import time
import datetime
import random
import struct
import sys
from functools import wraps
# Third party imports
import numpy as np
import faker
from faker.providers import BaseProvider
logging.getLogger('faker').setLevel(logging.ERROR)
sys.path.append('.')
def gen_vectors(num, dim):
return [[random.random() for _ in range(dim)] for _ in range(num)]
def gen_single_vector(dim):
return [[random.random() for _ in range(dim)]]
def gen_vector(nb, d, seed=np.random.RandomState(1234)):
xb = seed.rand(nb, d).astype("float32")
return xb.tolist()
def gen_unique_str(str=None):
prefix = "".join(random.choice(string.ascii_letters + string.digits) for _ in range(8))
return prefix if str is None else str + "_" + prefix
def get_current_day():
return time.strftime('%Y-%m-%d', time.localtime())
def get_last_day(day):
tmp = datetime.datetime.now() - datetime.timedelta(days=day)
return tmp.strftime('%Y-%m-%d')
def get_next_day(day):
tmp = datetime.datetime.now() + datetime.timedelta(days=day)
return tmp.strftime('%Y-%m-%d')
def gen_long_str(num):
string = ''
for _ in range(num):
char = random.choice('tomorrow')
string += char
class FakerProvider(BaseProvider):
def collection_name(self):
return 'collection_names' + str(random.randint(1000, 9999))
def name(self):
return 'name' + str(random.randint(1000, 9999))
def dim(self):
return random.randint(0, 999)
fake = faker.Faker()
fake.add_provider(FakerProvider)
def collection_name_factory():
return fake.collection_name()
def records_factory(dimension, nq):
return [[random.random() for _ in range(dimension)] for _ in range(nq)]
def binary_records_factory(dim, nq):
# uint8 values range is [0, 256), so we specify the high range is 256.
xnb = np.random.randint(256, size=[nq, (dim // 8)], dtype="uint8")
xb = [bytes(b) for b in xnb]
return xb
def integer_factory(nq):
return [random.randint(0, 128) for _ in range(nq)]
def time_it(func):
@wraps(func)
def inner(*args, **kwrgs):
pref = time.perf_counter()
result = func(*args, **kwrgs)
delt = time.perf_counter() - pref
print(f"[{func.__name__}][{delt:.4}s]")
return result
return inner
|
[
"logging.getLogger",
"random.choice",
"time.perf_counter",
"functools.wraps",
"datetime.timedelta",
"faker.Faker",
"datetime.datetime.now",
"numpy.random.randint",
"random.random",
"time.localtime",
"sys.path.append",
"random.randint",
"numpy.random.RandomState"
] |
[((301, 321), 'sys.path.append', 'sys.path.append', (['"""."""'], {}), "('.')\n", (316, 321), False, 'import sys\n'), ((1553, 1566), 'faker.Faker', 'faker.Faker', ([], {}), '()\n', (1564, 1566), False, 'import faker\n'), ((532, 559), 'numpy.random.RandomState', 'np.random.RandomState', (['(1234)'], {}), '(1234)\n', (553, 559), True, 'import numpy as np\n'), ((1905, 1963), 'numpy.random.randint', 'np.random.randint', (['(256)'], {'size': '[nq, dim // 8]', 'dtype': '"""uint8"""'}), "(256, size=[nq, dim // 8], dtype='uint8')\n", (1922, 1963), True, 'import numpy as np\n'), ((2121, 2132), 'functools.wraps', 'wraps', (['func'], {}), '(func)\n', (2126, 2132), False, 'from functools import wraps\n'), ((249, 275), 'logging.getLogger', 'logging.getLogger', (['"""faker"""'], {}), "('faker')\n", (266, 275), False, 'import logging\n'), ((872, 888), 'time.localtime', 'time.localtime', ([], {}), '()\n', (886, 888), False, 'import time\n'), ((925, 948), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (946, 948), False, 'import datetime\n'), ((951, 979), 'datetime.timedelta', 'datetime.timedelta', ([], {'days': 'day'}), '(days=day)\n', (969, 979), False, 'import datetime\n'), ((1051, 1074), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (1072, 1074), False, 'import datetime\n'), ((1077, 1105), 'datetime.timedelta', 'datetime.timedelta', ([], {'days': 'day'}), '(days=day)\n', (1095, 1105), False, 'import datetime\n'), ((1223, 1248), 'random.choice', 'random.choice', (['"""tomorrow"""'], {}), "('tomorrow')\n", (1236, 1248), False, 'import random\n'), ((1521, 1543), 'random.randint', 'random.randint', (['(0)', '(999)'], {}), '(0, 999)\n', (1535, 1543), False, 'import random\n'), ((2052, 2074), 'random.randint', 'random.randint', (['(0)', '(128)'], {}), '(0, 128)\n', (2066, 2074), False, 'import random\n'), ((2179, 2198), 'time.perf_counter', 'time.perf_counter', ([], {}), '()\n', (2196, 2198), False, 'import time\n'), ((364, 379), 'random.random', 'random.random', ([], {}), '()\n', (377, 379), False, 'import random\n'), ((465, 480), 'random.random', 'random.random', ([], {}), '()\n', (478, 480), False, 'import random\n'), ((682, 733), 'random.choice', 'random.choice', (['(string.ascii_letters + string.digits)'], {}), '(string.ascii_letters + string.digits)\n', (695, 733), False, 'import random\n'), ((1718, 1733), 'random.random', 'random.random', ([], {}), '()\n', (1731, 1733), False, 'import random\n'), ((2252, 2271), 'time.perf_counter', 'time.perf_counter', ([], {}), '()\n', (2269, 2271), False, 'import time\n'), ((1381, 1407), 'random.randint', 'random.randint', (['(1000)', '(9999)'], {}), '(1000, 9999)\n', (1395, 1407), False, 'import random\n'), ((1458, 1484), 'random.randint', 'random.randint', (['(1000)', '(9999)'], {}), '(1000, 9999)\n', (1472, 1484), False, 'import random\n')]
|
import numba
import numpy as np
from scipy.sparse import csr_matrix
from .base import BasePointer, GraphBlasContainer
from .context import handle_panic, return_error
from .exceptions import GrB_Info
class MatrixPtr(BasePointer):
def set_matrix(self, matrix):
self.instance = matrix
class Matrix(GraphBlasContainer):
def __init__(self, matrix):
assert isinstance(matrix, csr_matrix)
self.matrix = matrix
@classmethod
def new_from_dtype(cls, dtype, nrows, ncols):
matrix = csr_matrix((nrows, ncols), dtype=dtype)
return cls(matrix)
@classmethod
def new_from_existing(cls, other):
matrix = csr_matrix(other)
return cls(matrix)
@classmethod
def get_pointer(cls):
return MatrixPtr()
@handle_panic
def Matrix_new(A: MatrixPtr, dtype: type, nrows: int, ncols: int):
if nrows <= 0:
return_error(GrB_Info.GrB_INVALID_VALUE, "nrows must be > 0")
if ncols <= 0:
return_error(GrB_Info.GrB_INVALID_VALUE, "ncols must be > 0")
matrix = Matrix.new_from_dtype(dtype, nrows, ncols)
A.set_matrix(matrix)
return GrB_Info.GrB_SUCCESS
@handle_panic
def Matrix_dup(C: MatrixPtr, A: Matrix):
matrix = Matrix.new_from_existing(A)
C.set_matrix(matrix)
return GrB_Info.GrB_SUCCESS
@handle_panic
def Matrix_resize(C: Matrix, nrows: int, ncols: int):
if nrows <= 0:
return_error(GrB_Info.GrB_INVALID_VALUE, "nrows must be > 0")
if ncols <= 0:
return_error(GrB_Info.GrB_INVALID_VALUE, "ncols must be > 0")
C.matrix.resize((nrows, ncols))
return GrB_Info.GrB_SUCCESS
# TODO: this is just the essential code; it needs to handle descriptors, masks, accumulators, etc
@handle_panic
def mxm(C, A, B, semiring):
cr, cc = C.shape
ar, ac = A.shape
br, bc = B.shape
if cr != ar:
return_error(GrB_Info.GrB_DIMENSION_MISMATCH, "C.nrows != A.nrows")
if cc != bc:
return_error(GrB_Info.GrB_DIMENSION_MISMATCH, "C.ncols != B.ncols")
if ac != br:
return_error(GrB_Info.GrB_DIMENSION_MISMATCH, "A.nrows != B.ncols")
b = B.tocsc()
d, i, ip = _sparse_matmul(
A.data,
A.indices,
A.indptr,
b.data,
b.indices,
b.indptr,
semiring.plus.op,
semiring.times,
semiring.plus.identity,
C.dtype,
)
C.data = d
C.indices = i
C.indptr = ip
return GrB_Info.GrB_SUCCESS
@numba.njit
def _sparse_matmul(
a_data,
a_indices,
a_indptr,
b_data,
b_indices,
b_indptr,
plus,
times,
identity,
dtype,
):
# Final array size is unknown, so we give ourselves room and then adjust on the fly
tmp_output_size = a_data.size * 2
data = np.empty((tmp_output_size,), dtype=dtype)
indices = np.empty((tmp_output_size,), dtype=a_indices.dtype)
indptr = np.empty((a_indptr.size,), dtype=a_indptr.dtype)
output_counter = 0
for iptr in range(a_indptr.size - 1):
indptr[iptr] = output_counter
for jptr in range(b_indptr.size - 1):
a_counter = a_indptr[iptr]
a_stop = a_indptr[iptr + 1]
b_counter = b_indptr[jptr]
b_stop = b_indptr[jptr + 1]
val = identity
nonempty = False
while a_counter < a_stop and b_counter < b_stop:
a_k = a_indices[a_counter]
b_k = b_indices[b_counter]
if a_k == b_k:
val = plus(val, times(a_data[a_counter], b_data[b_counter]))
nonempty = True
a_counter += 1
b_counter += 1
elif a_k < b_k:
a_counter += 1
else:
b_counter += 1
if nonempty:
if output_counter >= tmp_output_size:
# We filled up the allocated space; copy existing data to a larger array
tmp_output_size *= 2
new_data = np.empty((tmp_output_size,), dtype=data.dtype)
new_indices = np.empty((tmp_output_size,), dtype=indices.dtype)
new_data[:output_counter] = data[:output_counter]
new_indices[:output_counter] = indices[:output_counter]
data = new_data
indices = new_indices
data[output_counter] = val
indices[output_counter] = jptr
output_counter += 1
# Add final entry to indptr (should indicate nnz in the output)
nnz = output_counter
indptr[iptr + 1] = nnz
# Trim output arrays
data = data[:nnz]
indices = indices[:nnz]
return (data, indices, indptr)
|
[
"scipy.sparse.csr_matrix",
"numpy.empty"
] |
[((2755, 2796), 'numpy.empty', 'np.empty', (['(tmp_output_size,)'], {'dtype': 'dtype'}), '((tmp_output_size,), dtype=dtype)\n', (2763, 2796), True, 'import numpy as np\n'), ((2811, 2862), 'numpy.empty', 'np.empty', (['(tmp_output_size,)'], {'dtype': 'a_indices.dtype'}), '((tmp_output_size,), dtype=a_indices.dtype)\n', (2819, 2862), True, 'import numpy as np\n'), ((2876, 2924), 'numpy.empty', 'np.empty', (['(a_indptr.size,)'], {'dtype': 'a_indptr.dtype'}), '((a_indptr.size,), dtype=a_indptr.dtype)\n', (2884, 2924), True, 'import numpy as np\n'), ((524, 563), 'scipy.sparse.csr_matrix', 'csr_matrix', (['(nrows, ncols)'], {'dtype': 'dtype'}), '((nrows, ncols), dtype=dtype)\n', (534, 563), False, 'from scipy.sparse import csr_matrix\n'), ((665, 682), 'scipy.sparse.csr_matrix', 'csr_matrix', (['other'], {}), '(other)\n', (675, 682), False, 'from scipy.sparse import csr_matrix\n'), ((4021, 4067), 'numpy.empty', 'np.empty', (['(tmp_output_size,)'], {'dtype': 'data.dtype'}), '((tmp_output_size,), dtype=data.dtype)\n', (4029, 4067), True, 'import numpy as np\n'), ((4102, 4151), 'numpy.empty', 'np.empty', (['(tmp_output_size,)'], {'dtype': 'indices.dtype'}), '((tmp_output_size,), dtype=indices.dtype)\n', (4110, 4151), True, 'import numpy as np\n')]
|
import numpy as np
class CellularAutomationModel:
grid_width = 40
grid_height = 40
def __init__(self):
self.grid = self._randomised_grid()
def evolve(self):
"""
Evolve the current grid state using Conway's Game of Life algorithm.
:returns
dict: A dictionary representation of the state of cells in the grid
"""
base_grid = self.grid.copy()
for y in range(self.grid_height):
for x in range(self.grid_width):
cell_state = base_grid[x, y]
n_neighbours = self._calculate_alive_neighbours(x, y, cell_state, grid=base_grid)
self.grid[x, y] = self._next_cell_state(cell_state, n_neighbours)
return self._json_formatted_grid()
def toggle_cell_state(self, x, y):
"""
Reverses the cell state for a particular cell coordinate.
"""
self.grid[x][y] = 0 if self.grid[x][y] == 1 else 1
def reset_grid(self):
"""
Resets the grid array to a random state.
:returns
dict: A dictionary representation of the state of cells in the grid
"""
self.grid = self._randomised_grid()
return self._json_formatted_grid()
def _calculate_alive_neighbours(self, x, y, cell_state, grid):
"""
Returns the number of alive nearest neighbours.
"""
surrounding_arr = self._surrounding_arr(x, y, grid)
n_alive = sum(sum(surrounding_arr))
return n_alive - cell_state
def _json_formatted_grid(self):
"""
Returns a python dictionary which represents the current state of the cells in the grid.
key: An integer that represents a single cell based on the coordinate position.
value: The cell state <0 or 1> to represent whether a cell is dead or alive.
"""
json_grid = {}
for x in range(self.grid_width):
for y in range(self.grid_height):
cell_id = int(x + y*self.grid_width)
json_grid[cell_id] = int(self.grid[x, y])
return json_grid
def _randomised_grid(self):
"""
Returns a 2d array with values of randomly assigned values of 0 or 1.
"""
return np.random.randint(2, size=(self.grid_height, self.grid_width))
@staticmethod
def _surrounding_arr(x, y, grid):
"""
Returns an 2d array containing all the adjacent cells for a particular coordinate (radius = 1 cell).
"""
if x != 0 and y != 0:
return grid[x - 1:x + 2, y - 1:y + 2]
elif x == 0:
return grid[x:x + 2, y - 1:y + 2]
elif y == 0:
return grid[x - 1:x + 2, y:y + 2]
else:
return grid[x:x + 2, y:y + 2]
@staticmethod
def _next_cell_state(cell_state, n_neighbours):
"""
Returns the new cell state 0 (dead) or 1 (alive). New state is determined using the current cell state
and number of alive neighbours based on the rules in Conway's Game of Life.
"""
if (cell_state == 1 and (n_neighbours not in range(2, 4))) or (cell_state == 0 and n_neighbours != 3):
return 0
return 1
|
[
"numpy.random.randint"
] |
[((2271, 2333), 'numpy.random.randint', 'np.random.randint', (['(2)'], {'size': '(self.grid_height, self.grid_width)'}), '(2, size=(self.grid_height, self.grid_width))\n', (2288, 2333), True, 'import numpy as np\n')]
|
# run.py
"""
Script for running a specific pipeline from a given yaml config file
"""
import os
import argparse
import yaml
from importlib import import_module
import numpy as np
import time
import pandas as pd
def import_from_path(path_to_module, obj_name = None):
"""
Import an object from a module based on the filepath of
the module and the string name of the object.
If obj_name is None, return the module instead.
"""
module_name = path_to_module.replace("/",".").strip(".py")
module = import_module(module_name)
if obj_name == None:
return module
obj = getattr(module, obj_name)
return obj
if __name__ == "__main__":
parser = argparse.ArgumentParser(description = __doc__)
parser.add_argument("-c", "--config", help = "File path to the config file")
parser.add_argument("-o", "--output", help = "Path to the output file")
args = parser.parse_args()
with open(args.config) as config_file:
config = yaml.safe_load(config_file)
if args.output != None:
output = True
out_csv = args.output
dfs = []
else:
output = False
# Importing pipeline elements
ds_splitter = import_from_path(config["split"]["filepath"],
config["split"]["class"]) (**config["split"]["parameters"])
preprocess = import_from_path(config["preprocess"]["filepath"])
model_params = config["model"]["parameters"]
if "kernel" in model_params:
kernel_func = import_from_path(model_params["kernel"]["filepath"],
model_params["kernel"]["class"])
kernel_params = model_params["kernel"]["parameters"]
model_params["kernel"] = lambda X, Y: kernel_func(X,Y,**kernel_params)
model = import_from_path(config["model"]["filepath"],
config["model"]["class"])(**config["model"]["parameters"])
evaluation = import_from_path(config["evaluation"]["filepath"])
# Evaluation output directory
out_dir = 'submissions'
if output and not os.path.isdir(out_dir):
os.makedirs(out_dir)
# Lists filling information for the output dataframe
datasets = []
metrics = []
values = []
# Applying pipeline
# Iterate over datasets
for i, dataset in enumerate(config["datasets"]):
time_beg = time.time()
print("Working on dataset ", i)
# Read dataset
X = pd.read_csv(dataset["X"]["filepath"],
**dataset["X"]["parameters"])
## It is currently very important to drop Id before splitting or preprocessing
y = pd.read_csv(dataset["y"]["filepath"],
**dataset["y"]["parameters"]).drop("Id", axis = 1)
if output:
test = pd.read_csv(dataset["test"]["filepath"],
**dataset["test"]["parameters"])
# Split dataset
ds_splitter.generate_idx(y)
X_train, X_test = ds_splitter.split(X)
y_train, y_test = ds_splitter.split(y)
# Preprocess dataset
for transform in config["preprocess"]["X"]:
X_train = getattr(preprocess, transform["transform"])(X_train, **transform["parameters"])
X_test = getattr(preprocess, transform["transform"])(X_test, **transform["parameters"])
for transform in config["preprocess"]["y"]:
y_train = getattr(preprocess, transform["transform"])(y_train, **transform["parameters"])
y_test = getattr(preprocess, transform["transform"])(y_test, **transform["parameters"])
if output:
for transform in config["preprocess"]["X"]:
test = getattr(preprocess, transform["transform"])(test, **transform["parameters"])
# Fit model
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
if output:
y_pred_test = model.predict(test)
y_pred_test = (y_pred_test + 1)/2
id = np.arange(1000*i, 1000*(i + 1))
dic = {'Id': id, 'Bound': y_pred_test}
df = pd.DataFrame(data = dic)
dfs.append(df)
# Evaluate model
for metric in config["evaluation"]["metrics"]:
datasets.append(dataset["name"])
metrics.append(metric)
values.append(getattr(evaluation, metric)(y_pred, y_test))
print("Done ! In {} s".format(time.time() - time_beg))
if output:
df = pd.concat(dfs).astype('int32')
df.to_csv(os.path.join(out_dir, out_csv), index = False)
results = {"datasets": datasets, "metrics": metrics, "values": values}
print(pd.DataFrame.from_dict(results))
|
[
"importlib.import_module",
"os.makedirs",
"argparse.ArgumentParser",
"pandas.read_csv",
"os.path.join",
"pandas.DataFrame.from_dict",
"yaml.safe_load",
"os.path.isdir",
"pandas.concat",
"pandas.DataFrame",
"time.time",
"numpy.arange"
] |
[((525, 551), 'importlib.import_module', 'import_module', (['module_name'], {}), '(module_name)\n', (538, 551), False, 'from importlib import import_module\n'), ((691, 735), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '__doc__'}), '(description=__doc__)\n', (714, 735), False, 'import argparse\n'), ((987, 1014), 'yaml.safe_load', 'yaml.safe_load', (['config_file'], {}), '(config_file)\n', (1001, 1014), False, 'import yaml\n'), ((2127, 2147), 'os.makedirs', 'os.makedirs', (['out_dir'], {}), '(out_dir)\n', (2138, 2147), False, 'import os\n'), ((2382, 2393), 'time.time', 'time.time', ([], {}), '()\n', (2391, 2393), False, 'import time\n'), ((2469, 2536), 'pandas.read_csv', 'pd.read_csv', (["dataset['X']['filepath']"], {}), "(dataset['X']['filepath'], **dataset['X']['parameters'])\n", (2480, 2536), True, 'import pandas as pd\n'), ((4725, 4756), 'pandas.DataFrame.from_dict', 'pd.DataFrame.from_dict', (['results'], {}), '(results)\n', (4747, 4756), True, 'import pandas as pd\n'), ((2095, 2117), 'os.path.isdir', 'os.path.isdir', (['out_dir'], {}), '(out_dir)\n', (2108, 2117), False, 'import os\n'), ((2820, 2893), 'pandas.read_csv', 'pd.read_csv', (["dataset['test']['filepath']"], {}), "(dataset['test']['filepath'], **dataset['test']['parameters'])\n", (2831, 2893), True, 'import pandas as pd\n'), ((4033, 4068), 'numpy.arange', 'np.arange', (['(1000 * i)', '(1000 * (i + 1))'], {}), '(1000 * i, 1000 * (i + 1))\n', (4042, 4068), True, 'import numpy as np\n'), ((4133, 4155), 'pandas.DataFrame', 'pd.DataFrame', ([], {'data': 'dic'}), '(data=dic)\n', (4145, 4155), True, 'import pandas as pd\n'), ((4584, 4614), 'os.path.join', 'os.path.join', (['out_dir', 'out_csv'], {}), '(out_dir, out_csv)\n', (4596, 4614), False, 'import os\n'), ((2660, 2727), 'pandas.read_csv', 'pd.read_csv', (["dataset['y']['filepath']"], {}), "(dataset['y']['filepath'], **dataset['y']['parameters'])\n", (2671, 2727), True, 'import pandas as pd\n'), ((4535, 4549), 'pandas.concat', 'pd.concat', (['dfs'], {}), '(dfs)\n', (4544, 4549), True, 'import pandas as pd\n'), ((4481, 4492), 'time.time', 'time.time', ([], {}), '()\n', (4490, 4492), False, 'import time\n')]
|
import glob
import os
import os.path
import sys
import shutil
import cPickle
from types import StringType, UnicodeType
from distutils.core import setup
from distutils.extension import Extension
from distutils.command.install import install
PY3K = sys.version_info[0] > 2
with open('README.rst') as inp:
long_description = inp.read()
__version__ = ''
inp = open('prody/__init__.py')
for line in inp:
if (line.startswith('__version__')):
exec(line.strip())
break
inp.close()
def isInstalled(module_name):
"""Check if a required package is installed, by trying to import it."""
try:
return __import__(module_name)
except ImportError:
return False
else:
return True
if not isInstalled('numpy'):
print("""NumPy is not installed. This package is required for main ProDy
features and needs to be installed before you can use ProDy.
You can find NumPy at: http://numpy.scipy.org""")
PACKAGES = ['prody', 'prody.atomic', 'prody.dynamics', 'prody.ensemble',
'prody.measure', 'prody.proteins', 'prody.trajectory',
'prody.routines', 'prody.utilities']
PACKAGE_DATA = {}
if sys.version_info[:2] > (2,6):
PACKAGES.extend(['prody.tests', 'prody.tests.test_kdtree',
'prody.tests.test_measure'])
PACKAGE_DATA['prody.tests'] = ['data/pdb*.pdb', 'data/*.dat',
'data/*.coo', 'data/dcd*.dcd']
EXTENSIONS = []
if os.name != 'java' and sys.version_info[0] == 2:
pairwise2 = ['cpairwise2.c', 'pairwise2.py']
if all([os.path.isfile(os.path.join('prody', 'proteins', fn))
for fn in pairwise2]):
EXTENSIONS.append(
Extension('prody.proteins.cpairwise2',
['prody/proteins/cpairwise2.c'],
include_dirs=["prody"]
))
else:
raise Exception('one or more pairwise2 module files are missing')
if isInstalled('numpy'):
import numpy
kdtree_files = ['__init__.py', 'KDTree.c', 'KDTree.h',
'KDTreemodule.c', 'Neighbor.h', 'kdtree.py']
if all([os.path.isfile(os.path.join('prody', 'kdtree', fn))
for fn in kdtree_files]):
EXTENSIONS.append(
Extension('prody.kdtree._CKDTree',
['prody/kdtree/KDTree.c',
'prody/kdtree/KDTreemodule.c'],
include_dirs=[numpy.get_include()],
))
else:
raise Exception('one or more kdtree module files are missing')
PACKAGES.append('prody.kdtree')
elif isInstalled('numpy'):
raise ImportError('numpy is not installed')
SCRIPTS = ['scripts/prody']
setup(
name='ProDy',
version=__version__,
author='<NAME>',
author_email='ahb12 at pitt dot edu',
description='A Python Package for Protein Dynamics Analysis',
long_description=long_description,
url='http://www.csb.pitt.edu/ProDy',
packages=PACKAGES,
package_data=PACKAGE_DATA,
ext_modules=EXTENSIONS,
license='GPLv3',
keywords=('protein, dynamics, elastic network model, '
'Gaussian network model, anisotropic network model, '
'essential dynamics analysis, principal component analysis, '
'Protein Data Bank, PDB, GNM, ANM, PCA'),
classifiers=[
'Development Status :: 4 - Beta',
'Intended Audience :: Science/Research',
'License :: OSI Approved :: GNU General Public License (GPL)',
'Operating System :: MacOS',
'Operating System :: Microsoft :: Windows',
'Operating System :: POSIX',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Topic :: Scientific/Engineering :: Bio-Informatics',
'Topic :: Scientific/Engineering :: Chemistry',
],
scripts=SCRIPTS,
requires=['NumPy', ],
provides=['ProDy({0:s})'.format(__version__)]
)
|
[
"os.path.join",
"distutils.extension.Extension",
"numpy.get_include"
] |
[((1721, 1820), 'distutils.extension.Extension', 'Extension', (['"""prody.proteins.cpairwise2"""', "['prody/proteins/cpairwise2.c']"], {'include_dirs': "['prody']"}), "('prody.proteins.cpairwise2', ['prody/proteins/cpairwise2.c'],\n include_dirs=['prody'])\n", (1730, 1820), False, 'from distutils.extension import Extension\n'), ((1590, 1627), 'os.path.join', 'os.path.join', (['"""prody"""', '"""proteins"""', 'fn'], {}), "('prody', 'proteins', fn)\n", (1602, 1627), False, 'import os\n'), ((2183, 2218), 'os.path.join', 'os.path.join', (['"""prody"""', '"""kdtree"""', 'fn'], {}), "('prody', 'kdtree', fn)\n", (2195, 2218), False, 'import os\n'), ((2496, 2515), 'numpy.get_include', 'numpy.get_include', ([], {}), '()\n', (2513, 2515), False, 'import numpy\n')]
|
import numpy as np
def pline(x1, y1, x2, y2, x, y):
px = x2 - x1
py = y2 - y1
dd = px * px + py * py
u = ((x - x1) * px + (y - y1) * py) / max(1e-9, float(dd))
dx = x1 + u * px - x
dy = y1 + u * py - y
return dx * dx + dy * dy
def psegment(x1, y1, x2, y2, x, y):
px = x2 - x1
py = y2 - y1
dd = px * px + py * py
u = max(min(((x - x1) * px + (y - y1) * py) / float(dd), 1), 0)
dx = x1 + u * px - x
dy = y1 + u * py - y
return dx * dx + dy * dy
def plambda(x1, y1, x2, y2, x, y):
px = x2 - x1
py = y2 - y1
dd = px * px + py * py
return ((x - x1) * px + (y - y1) * py) / max(1e-9, float(dd))
def postprocess(lines, scores, threshold=0.01, tol=1e9, do_clip=False):
nlines, nscores = [], []
for (p, q), score in zip(lines, scores):
start, end = 0, 1
for a, b in nlines: # nlines: Selected lines.
if (
min(
max(pline(*p, *q, *a), pline(*p, *q, *b)),
max(pline(*a, *b, *p), pline(*a, *b, *q)),
)
> threshold ** 2
):
continue
lambda_a = plambda(*p, *q, *a)
lambda_b = plambda(*p, *q, *b)
if lambda_a > lambda_b:
lambda_a, lambda_b = lambda_b, lambda_a
lambda_a -= tol
lambda_b += tol
# case 1: skip (if not do_clip)
if start < lambda_a and lambda_b < end:
continue
# not intersect
if lambda_b < start or lambda_a > end:
continue
# cover
if lambda_a <= start and end <= lambda_b:
start = 10
break
# case 2 & 3:
if lambda_a <= start and start <= lambda_b:
start = lambda_b
if lambda_a <= end and end <= lambda_b:
end = lambda_a
if start >= end:
break
if start >= end:
continue
nlines.append(np.array([p + (q - p) * start, p + (q - p) * end]))
nscores.append(score)
return np.array(nlines), np.array(nscores)
|
[
"numpy.array"
] |
[((2149, 2165), 'numpy.array', 'np.array', (['nlines'], {}), '(nlines)\n', (2157, 2165), True, 'import numpy as np\n'), ((2167, 2184), 'numpy.array', 'np.array', (['nscores'], {}), '(nscores)\n', (2175, 2184), True, 'import numpy as np\n'), ((2056, 2106), 'numpy.array', 'np.array', (['[p + (q - p) * start, p + (q - p) * end]'], {}), '([p + (q - p) * start, p + (q - p) * end])\n', (2064, 2106), True, 'import numpy as np\n')]
|
import os
from typing import List, Optional
import pickle
import numpy as np
from utilities import augment_long_text, tokenize, tokenize_long_text, to_chars, align
from config import Config as cf
PAD = 0 # TODO: choose appropriate index for these special chars
UNK = 1
DEFAULT = {'PAD': PAD, 'UNK': UNK}
DEFAULT_C = {'': PAD, 'UNK': UNK}
def word_lookup(w: str, table: dict, default=None):
"""
Translate a word into a value by looking up from a dict.
First priority is case-sensitive, then the next priority is case-insensitive.
In case the word does not exist in the dict, a KeyError exception is raised or a default value is returned.
Args:
w: word to translate
table: a dict to translate the word by looking up
default: If not None, this is the value to return in case the word does not exist in the table.
Returns:
Translated value for the word by looking up the word into table.
"""
if w in table: # Match word in case-sentitive mode is the first priority
return table[w]
elif w.lower() in table: # Then, case-insensitive
return table[w.lower()]
else:
if default is not None:
return default
else:
raise KeyError('Key `{}` not found'.format(w))
def char_lookup(c: str, table: dict, default=None):
"""
Translate a char into a value by looking up from a dict.
Args:
c: char to translate
table: a dict to translate the char by looking up
default: If not None, this is the value to return in case the char does not exist in the table.
Returns:
Translated value for the char by looking up the char into table.
"""
if c in table: # Match word in case-sentitive mode is the first priority
return table[c]
else:
if default is not None:
return default
else:
raise KeyError('Key `{}` not found'.format(c))
class Vocabulary(object):
def __init__(self, wv: dict, char_vocab: set):
offset = len(DEFAULT)
w2id = {w: idx+offset for idx, w in enumerate(wv.keys())}
w2id.update(DEFAULT)
id2w = {i:w for w, i in w2id.items()}
c2id = {c: idx+offset for idx, c in enumerate(list(char_vocab))}
c2id.update(DEFAULT_C)
id2c = {i:c for c, i in c2id.items()}
self.wv = wv
self.emb_size = len(wv['the']) # most common word that absolutely appears in the dict
self.w2id = w2id # mapping word to index
self.id2w = id2w # mapping index to word
self.c2id = c2id # mapping char to index
self.id2c = id2c # mapping index to char
def vectorize(self, tokens: List[str], length: int):
"""
Convert list of text tokens into list of indices
"""
vect = [word_lookup(t, self.w2id, default=UNK) for t in tokens]
vect = vect[:length]
if len(vect) < length:
vect.extend([PAD]*(length-len(vect)))
return vect
def vectorize_c(self, chars_list: List[List[str]], length: int, w_length: int):
"""
Convert list of list of chars into list of index-based representation
"""
vects = []
PAD_VECT = [PAD]*w_length
for chars in chars_list:
vects.append([char_lookup(c, self.c2id, default=UNK) for c in chars])
vects = vects[:length]
while len(vects) < length:
vects.append(PAD_VECT)
return vects
def get_embed_weights(self):
"""
Build weights for a word embedding layer.
Note that pre-trained word embedding is used, so no need to parameterize embed_size.
Args:
emb_size: Dim of the vectors
Returns:
[N, emb_size] matrix, where N is number of VOCAB + 1 (for pad)
"""
emb_size = len(self.wv[list(self.wv.keys())[0]])
weights = np.zeros((len(self.id2w), emb_size))
for i, tok in self.id2w.items():
if tok in self.wv:
weights[i] = self.wv[tok]
else:
weights[i] = np.random.uniform(0.0, 1.0, [emb_size])
return weights
def get_char_embed_weights(self, emb_size=64):
"""
Initialize weights for char embedding layer.
Args:
emb_size: Dim of the vectors
Returns:
[len(id2c), emb_size] matrix
"""
weights = emb = np.random.uniform(0.0, 1.0, size=(len(self.id2c), emb_size))
return weights
@property
def vocab_size(self):
return len(self.w2id)
def __getitem__(self, idx):
"""
Get vector for a word.
"""
if not isinstance(idx, str):
raise ValueError('Index must be a string')
return word_lookup(idx, self.wv, default=None)
def __contains__(self, idx):
if not isinstance(idx, str):
raise ValueError('Index must be a string')
return idx in self.wv or idx.lower() in self.wv
class Span(object):
def __init__(self, start_idx: int, end_idx: int):
self.start = start_idx # index of the start token in context
self.end = end_idx # index of the end token in context
@classmethod
def allocate(cls, anchors: List[int], start_char: int, end_char: int):
start_idx = 0
while anchors[start_idx] < start_char:
start_idx += 1
if anchors[start_idx] > start_char:
start_idx -= 1
end_idx = start_idx
while end_idx < len(anchors) and anchors[end_idx] <= end_char:
end_idx += 1
end_idx -= 1
return Span(start_idx, end_idx)
def __str__(self):
return "({}, {})".format(self.start, self.end)
class Answer(object):
def __init__(self, answer_text: str, answer_toks: List[str], span: Span, answer_start: int):
self.answer_text = answer_text # original answer text in JSON
self.answer_toks = answer_toks # tokens of the original answer text
self.answer_chars = to_chars(answer_toks, cf.WORD_LEN, cf.PAD_CHAR) # list of chars of the answer text
self.span = span # The span (token-based index) of the answer in context
self.answer_start = answer_start # start character in original answer text
def vectorize(self, vocab: Vocabulary):
self.answer: List[int] = vocab.vectorize(self.answer_toks, cf.ANSWER_LEN)
self.answer_c: List[List[int]] = vocab.vectorize_c(self.answer_chars, cf.ANSWER_LEN, cf.WORD_LEN)
@classmethod
def parse_json(cls, answers_js: List[dict], context: str, context_toks: List[str], anchors: List[int]):
answers = []
for ans in answers_js:
ans_text = ans['text']
ans_start = ans['answer_start']
ans_toks = tokenize(ans_text)
# Identify the span from context, ans_text & start index
span = Span.allocate(anchors, ans_start, ans_start+len(ans_text)-1)
answers.append(Answer(ans_text, ans_toks, span, ans_start))
return answers
class Question(object):
def __init__(self, question_text: str, ques_id: str, question: List[str], answers: List[Answer], plausible_answers: List[Answer]):
self.question_text = question_text # original question text in JSON
self.question_toks = question # tokens of the original question text
self.question_chars = to_chars(question, cf.WORD_LEN, cf.PAD_CHAR) # list of chars of the question text
self.answers = answers # list of Answer object of the question
self.ques_id = ques_id # id of the question in JSON
self.plausible_answers = plausible_answers
self.paragraph = None # handle to the parent paragraph
def set_paragraph(self, paragraph):
self.paragraph = paragraph
def vectorize(self, vocab: Vocabulary):
self.question: List[int] = vocab.vectorize(self.question_toks, cf.QUERY_LEN)
self.question_c: List[List[int]] = vocab.vectorize_c(self.question_chars, cf.QUERY_LEN, cf.WORD_LEN)
for answer in self.answers:
answer.vectorize(vocab)
class Paragraph(object):
def __init__(self, raw_context: str, context_text: str, context_toks: List[str], questions: List[Question], para_idx: int, anchors: List[int]):
self.raw_context = raw_context # original context text in JSON
self.context_text = context_text # augmented from original context text with SPACES to guide the tokenization
self.context_toks = context_toks # tokens of the context text
self.context_chars = to_chars(context_toks, cf.WORD_LEN, cf.PAD_CHAR) # chars of the context
self.questions = questions # list of Question objects
self.local_word_vocab = self._build_local_word_vocab()
self.local_char_vocab = self._build_local_char_vocab()
self.para_idx = para_idx # Just for management & debug. Not used in experiment.
self.anchors = anchors
def _build_local_word_vocab(self):
local_vocab = set()
local_vocab = local_vocab.union(set(self.context_toks))
for question in self.questions:
local_vocab = local_vocab.union(set(question.question_toks))
for answer in question.answers + question.plausible_answers:
local_vocab = local_vocab.union(set(answer.answer_toks))
return local_vocab
def _build_local_char_vocab(self):
def char_set(tokens):
chars = set()
for tok in tokens:
chars = chars.union(set(tok))
return chars
char_vocab = set()
char_vocab = char_vocab.union(char_set(self.context_chars))
for question in self.questions:
char_vocab = char_vocab.union(char_set(question.question_chars))
for answer in question.answers + question.plausible_answers:
char_vocab = char_vocab.union(char_set(answer.answer_chars))
return char_vocab
@classmethod
def parse_json(cls, para_js: dict, para_idx: int):
# Accumulate all answers' tokens first
all_para_answers = []
for q in para_js['qas']:
if 'answers' in q:
all_para_answers.extend([ans for ans in q['answers']])
if 'plausible_answers' in q:
all_para_answers.extend([ans for ans in q['plausible_answers']])
# Improve the context for better tokenization
raw_context = para_js['context']
# context = augment_long_text(para_js['context'], all_para_answers)
context = raw_context
context_toks = tokenize_long_text(context)
context_toks = [t.strip(' ') for t in context_toks]
anchors = align(raw_context, context_toks)
questions = []
for q in para_js['qas']:
question_text = q['question']
q_toks = tokenize(question_text)
ques_id = q['id']
answers = Answer.parse_json(q['answers'], raw_context, context_toks, anchors) if 'answers' in q else []
plausible_answers = Answer.parse_json(q['plausible_answers'], raw_context, context_toks, anchors) if 'plausible_answers' in q else []
questions.append(Question(question_text, ques_id, q_toks, answers, plausible_answers))
para = Paragraph(raw_context, context, context_toks, questions, para_idx, anchors)
for ques in questions:
ques.set_paragraph(para)
return para
def vectorize(self, vocab):
"""
Vectorize pargraph context, question text & answer text based on given vocab.
"""
self.context: List[int] = vocab.vectorize(self.context_toks, cf.CONTEXT_LEN)
self.context_c: List[List[int]] = vocab.vectorize_c(self.context_chars, cf.CONTEXT_LEN, cf.WORD_LEN)
for question in self.questions:
question.vectorize(vocab)
def exact_match(gt_s, gt_e, pr_s, pr_e):
"""
Evaluate exact match of a predicted span over a ground truth span.
Args:
gt_s: index of the ground truth start position
gt_e: index of the ground truth end position
pr_s: index of the predicted start position
pr_e: index of the predicted end position
"""
return gt_s == pr_s and gt_e == pr_e
def f1(gt_s, gt_e, pr_s, pr_e):
"""
Evaluate F1 score of a predicted span over a ground truth span.
Args:
gt_s: index of the ground truth start position
gt_e: index of the ground truth end position
pr_s: index of the predicted start position
pr_e: index of the predicted end position
"""
gt = {idx for idx in range(gt_s, gt_e+1)}
pr = {idx for idx in range(pr_s, pr_e+1)}
intersection = gt.intersection(pr)
prec = 1. * len(intersection) / len(pr)
rec = 1. * len(intersection) / len(gt)
f1_score = (2. * prec * rec) / (prec+rec) if prec+rec != 0. else 0.
return f1_score
def get_score(metric, gt_starts, gt_ends, pred_start, pred_end):
"""
Args:
metric: a metric function to calculate the score (exact_match or f1_score)
gt_starts: (list) an array of start indices of the available answers
gt_ends: (list) an array of end indices of the available answers
pred_start: (int) predicted start index returned by a model
pred_end: (int) predicted end index returned by a model
Returns:
The best score of the metric evaluated on multiple answer spans.
"""
scores = []
for gt_s, gt_e in zip(gt_starts, gt_ends):
scores.append(metric(gt_s, gt_e, pred_start, pred_end))
return 1.0 * np.max(scores)
class SquadData(object):
"""
To save the whole object to pickle file:
```python
data.save('data/squad_processed.pkl')
```
To load the whole object from pickle file, and extract train & validation data
```python
data = SquadData.load('data/squad_processed.pkl')
ques_ids_train, X_train, y_train = data.train_data()
ques_ids_valid, X_valid, y_valid = data.validation_data()
```
To save structured data to binary files for fast loading:
```python
data.save(np_path='data/numpy')
```
To load numpy data from binary files:
```python
word_vectors, char_vectors, ques_ids_train, X_train, y_train, ques_ids_valid, X_valid, y_valid = SquadData.load(np_path='data/numpy')
```
"""
def __init__(self, train_paragraphs: List[Paragraph], dev_paragraphs: List[Paragraph], vocab: Vocabulary, squad_words: set, squad_chars: set):
"""
Initializer.
Args:
train_paragraphs: list of Paragraph objects from train data
dev_paragraphs: list of Paragraph objects from dev data
vocab: Vocabulary object which store vectors of words appearing in Squad data
squad_words: set of all tokens appearing in Squad data (context, question text, answer text).
Note that some tokens may not appear in vocab. They are treated as unknown words.
Note that this is a set of words, so it must not be used to map words to indices. Use Vocabulary.w2id instead.
squad_chars: set of all characters appearing in Squad data (context, question text, answer text).
"""
self.train_paragraphs = train_paragraphs
self.dev_paragraphs = dev_paragraphs
self.vocab = vocab
self.squad_words = squad_words
self.squad_chars = squad_chars
def summary(self):
print('Num of train paragraphs: {}'.format(len(self.train_paragraphs)))
print('Num of dev paragraphs: {}'.format(len(self.dev_paragraphs)))
print('Num words in vocab: {}'.format(self.vocab.vocab_size))
print('Num unique words: {}'.format(len(self.squad_words)))
print('Num unique chars: {}'.format(len(self.squad_chars)))
unknown_words = [w for w in self.squad_words if w not in self.vocab]
print('Num of unknown words: {}'.format(len(unknown_words)))
def _generate_data(self, paragraphs, dataset: str ='train'):
ques_ids = []
contextw_inp, queryw_inp, contextc_inp, queryc_inp = [], [], [], []
p1, p2, start, end = [], [], [], []
long_count = 0
for para in paragraphs:
for ques in para.questions:
if dataset == 'train':
for ans in ques.answers:
if ans.span.start >= cf.CONTEXT_LEN or ans.span.end >= cf.CONTEXT_LEN:
# print('ques.ques_id:', ques.ques_id, ',', 'ans.span.start, end:', ans.span.start, ',', ans.span.end)
long_count += 1
continue
ques_ids.append(ques.ques_id)
contextw_inp.append(para.context)
queryw_inp.append(ques.question)
contextc_inp.append(para.context_c)
queryc_inp.append(ques.question_c)
vect = np.zeros(cf.CONTEXT_LEN, dtype=np.float16)
vect[ans.span.start] = 1.
p1.append(vect)
vect = np.zeros(cf.CONTEXT_LEN, dtype=np.float16)
vect[ans.span.end] = 1.
p2.append(vect)
start.append(ans.span.start)
end.append(ans.span.end)
else: # dev dataset
ques_ids.append(ques.ques_id)
contextw_inp.append(para.context)
queryw_inp.append(ques.question)
contextc_inp.append(para.context_c)
queryc_inp.append(ques.question_c)
start_list = []
end_list = []
for ans in ques.answers:
if ans.span.start >= cf.CONTEXT_LEN or ans.span.end >= cf.CONTEXT_LEN:
long_count += 1
continue
start_list.append(ans.span.start)
end_list.append(ans.span.end)
# p1, p2 are ignored in dev set
start.append(start_list)
end.append(end_list)
print('There are {} long answers'.format(long_count))
ques_ids = np.array(ques_ids)
contextw_inp, queryw_inp, contextc_inp, queryc_inp = np.array(contextw_inp), np.array(queryw_inp), np.array(contextc_inp), np.array(queryc_inp)
p1, p2, start, end = np.array(p1), np.array(p2), np.array(start), np.array(end)
return (ques_ids, [contextw_inp, queryw_inp, contextc_inp, queryc_inp], [p1, p2, start, end])
def train_data(self):
return self._generate_data(self.train_paragraphs)
def validation_data(self):
return self._generate_data(self.dev_paragraphs, dataset='dev')
def search_paragraph(self, para_idx: int, dataset: str ='train'):
"""
Search for paragraph by index. This function is used for debug only.
"""
paragraphs = self.train_paragraphs if dataset == 'train' else self.dev_paragraphs
for para in paragraphs:
if para.para_idx == para_idx:
return para
return None
def search_question(self, ques_id: str, dataset: str ='train'):
"""
Search for question by ques_id. This function is used for debug only.
"""
paragraphs = self.train_paragraphs if dataset == 'train' else self.dev_paragraphs
for para in paragraphs:
for ques in para.questions:
if ques.ques_id == ques_id:
return ques
return None
@classmethod
def evaluate(cls, gt_start_list, gt_end_list, pred_starts, pred_ends):
"""
Evaluate ExactMatch score & F1 score of predictions on a validation set.
Args:
gt_start_list: list of start indices of multiple ground-truth answer spans
gt_start_list: list of end indices of multiple ground-truth answer spans
pred_starts: list of predicted start indices
pred_ends: list of predicted end indices
Returns:
A hash with 2 keys: 'exact_match' & 'f1'
"""
em_score = 0
f1_score = 0
total = 0
for gt_starts, gt_ends, pred_start, pred_end in zip(gt_start_list, gt_end_list, pred_starts, pred_ends):
if len(gt_starts) > 0:
em_score += get_score(exact_match, gt_starts, gt_ends, pred_start, pred_end)
f1_score += get_score(f1, gt_starts, gt_ends, pred_start, pred_end)
# If gt_starts is empty, the ground-truth answer is over the limit length of the input text.
# We give penalty for that case, that means we give 0 to EM & F1 while we increase the total.
total += 1
em_score = 100. * em_score / total
f1_score = 100. * f1_score / total
em_score, f1_score
return {
'exact_match': em_score,
'f1': f1_score
}
def save(self, filepath=None, np_path=None):
def save_data(prefix, ques_ids,
contextw, queryw, contextc, queryc,
p1, p2, start, end):
np.save(np_path + '/%s_ques_ids.npy' % prefix, ques_ids)
np.save(np_path + '/%s_contextw.npy' % prefix, contextw)
np.save(np_path + '/%s_queryw.npy' % prefix, queryw)
np.save(np_path + '/%s_contextc.npy' % prefix, contextc)
np.save(np_path + '/%s_queryc.npy' % prefix, queryc)
np.save(np_path + '/%s_p1.npy' % prefix, p1)
np.save(np_path + '/%s_p2.npy' % prefix, p2)
np.save(np_path + '/%s_start.npy' % prefix, start)
np.save(np_path + '/%s_end.npy' % prefix, end)
if filepath: # Save the SquadData object to pickle file (slow)
print('Saving squad data to {}...'.format(filepath))
with open(filepath, 'wb') as f:
pickle.dump(self, f)
else: # Save the binary data to *.npy files (fast)
print('Accumulating train & validation arrays from the structure...')
t_ques_ids, X_train, y_train = self.train_data()
v_ques_ids, X_valid, y_valid = self.validation_data()
t_contextw, t_queryw, t_contextc, t_queryc = X_train
t_p1, t_p2, t_start, t_end = y_train
v_contextw, v_queryw, v_contextc, v_queryc = X_valid
v_p1, v_p2, v_start, v_end = y_valid
if not os.path.exists(np_path):
os.makedirs(np_path)
print('Saving word vectors into numpy files...')
word_vectors = self.vocab.get_embed_weights()
char_vectors = self.vocab.get_char_embed_weights()
np.save(np_path + '/word_vectors.npy', word_vectors)
np.save(np_path + '/char_vectors.npy', char_vectors)
print('Saving train arrays into numpy files...')
save_data(
'train', t_ques_ids,
t_contextw, t_queryw, t_contextc, t_queryc,
t_p1, t_p2, t_start, t_end)
print('Saving validation arrays into numpy files...')
save_data(
'val', v_ques_ids,
v_contextw, v_queryw, v_contextc, v_queryc,
v_p1, v_p2, v_start, v_end)
@classmethod
def load(cls, filepath=None, np_path=None):
def load_data(prefix):
ques_ids = np.load(np_path + '/%s_ques_ids.npy' % prefix)
contextw = np.load(np_path + '/%s_contextw.npy' % prefix)
queryw = np.load(np_path + '/%s_queryw.npy' % prefix)
contextc = np.load(np_path + '/%s_contextc.npy' % prefix)
queryc = np.load(np_path + '/%s_queryc.npy' % prefix)
p1 = np.load(np_path + '/%s_p1.npy' % prefix)
p2 = np.load(np_path + '/%s_p2.npy' % prefix)
start = np.load(np_path + '/%s_start.npy' % prefix)
end = np.load(np_path + '/%s_end.npy' % prefix)
return ques_ids, contextw, queryw, contextc, queryc, p1, p2, start, end
if filepath: # Load SquadData object from pickle file (slow)
print('Loading squad data from pickle file {}...'.format(filepath))
with open(filepath, 'rb') as f:
return pickle.load(f)
else: # Load binary data from *.npy files (fast)
print('Loading word vectors from numpy files...')
word_vectors = np.load(np_path + '/word_vectors.npy')
char_vectors = np.load(np_path + '/char_vectors.npy')
print('Loading train arrays from numpy files...')
t_ques_ids, t_contextw, t_queryw, t_contextc, t_queryc, t_p1, t_p2, t_start, t_end = load_data('train')
print('Loading validation arrays from numpy files...')
v_ques_ids, v_contextw, v_queryw, v_contextc, v_queryc, v_p1, v_p2, v_start, v_end = load_data('val')
return [
word_vectors,
char_vectors,
t_ques_ids,
[t_contextw, t_queryw, t_contextc, t_queryc],
[t_p1, t_p2, t_start, t_end],
v_ques_ids,
[v_contextw, v_queryw, v_contextc, v_queryc],
[v_p1, v_p2, v_start, v_end]
]
|
[
"os.path.exists",
"pickle.dump",
"os.makedirs",
"pickle.load",
"utilities.align",
"numpy.max",
"numpy.array",
"numpy.zeros",
"numpy.random.uniform",
"utilities.to_chars",
"numpy.save",
"utilities.tokenize",
"utilities.tokenize_long_text",
"numpy.load"
] |
[((6131, 6178), 'utilities.to_chars', 'to_chars', (['answer_toks', 'cf.WORD_LEN', 'cf.PAD_CHAR'], {}), '(answer_toks, cf.WORD_LEN, cf.PAD_CHAR)\n', (6139, 6178), False, 'from utilities import augment_long_text, tokenize, tokenize_long_text, to_chars, align\n'), ((7546, 7590), 'utilities.to_chars', 'to_chars', (['question', 'cf.WORD_LEN', 'cf.PAD_CHAR'], {}), '(question, cf.WORD_LEN, cf.PAD_CHAR)\n', (7554, 7590), False, 'from utilities import augment_long_text, tokenize, tokenize_long_text, to_chars, align\n'), ((8794, 8842), 'utilities.to_chars', 'to_chars', (['context_toks', 'cf.WORD_LEN', 'cf.PAD_CHAR'], {}), '(context_toks, cf.WORD_LEN, cf.PAD_CHAR)\n', (8802, 8842), False, 'from utilities import augment_long_text, tokenize, tokenize_long_text, to_chars, align\n'), ((10832, 10859), 'utilities.tokenize_long_text', 'tokenize_long_text', (['context'], {}), '(context)\n', (10850, 10859), False, 'from utilities import augment_long_text, tokenize, tokenize_long_text, to_chars, align\n'), ((10938, 10970), 'utilities.align', 'align', (['raw_context', 'context_toks'], {}), '(raw_context, context_toks)\n', (10943, 10970), False, 'from utilities import augment_long_text, tokenize, tokenize_long_text, to_chars, align\n'), ((13832, 13846), 'numpy.max', 'np.max', (['scores'], {}), '(scores)\n', (13838, 13846), True, 'import numpy as np\n'), ((18580, 18598), 'numpy.array', 'np.array', (['ques_ids'], {}), '(ques_ids)\n', (18588, 18598), True, 'import numpy as np\n'), ((6915, 6933), 'utilities.tokenize', 'tokenize', (['ans_text'], {}), '(ans_text)\n', (6923, 6933), False, 'from utilities import augment_long_text, tokenize, tokenize_long_text, to_chars, align\n'), ((11090, 11113), 'utilities.tokenize', 'tokenize', (['question_text'], {}), '(question_text)\n', (11098, 11113), False, 'from utilities import augment_long_text, tokenize, tokenize_long_text, to_chars, align\n'), ((18660, 18682), 'numpy.array', 'np.array', (['contextw_inp'], {}), '(contextw_inp)\n', (18668, 18682), True, 'import numpy as np\n'), ((18684, 18704), 'numpy.array', 'np.array', (['queryw_inp'], {}), '(queryw_inp)\n', (18692, 18704), True, 'import numpy as np\n'), ((18706, 18728), 'numpy.array', 'np.array', (['contextc_inp'], {}), '(contextc_inp)\n', (18714, 18728), True, 'import numpy as np\n'), ((18730, 18750), 'numpy.array', 'np.array', (['queryc_inp'], {}), '(queryc_inp)\n', (18738, 18750), True, 'import numpy as np\n'), ((18780, 18792), 'numpy.array', 'np.array', (['p1'], {}), '(p1)\n', (18788, 18792), True, 'import numpy as np\n'), ((18794, 18806), 'numpy.array', 'np.array', (['p2'], {}), '(p2)\n', (18802, 18806), True, 'import numpy as np\n'), ((18808, 18823), 'numpy.array', 'np.array', (['start'], {}), '(start)\n', (18816, 18823), True, 'import numpy as np\n'), ((18825, 18838), 'numpy.array', 'np.array', (['end'], {}), '(end)\n', (18833, 18838), True, 'import numpy as np\n'), ((21543, 21599), 'numpy.save', 'np.save', (["(np_path + '/%s_ques_ids.npy' % prefix)", 'ques_ids'], {}), "(np_path + '/%s_ques_ids.npy' % prefix, ques_ids)\n", (21550, 21599), True, 'import numpy as np\n'), ((21612, 21668), 'numpy.save', 'np.save', (["(np_path + '/%s_contextw.npy' % prefix)", 'contextw'], {}), "(np_path + '/%s_contextw.npy' % prefix, contextw)\n", (21619, 21668), True, 'import numpy as np\n'), ((21681, 21733), 'numpy.save', 'np.save', (["(np_path + '/%s_queryw.npy' % prefix)", 'queryw'], {}), "(np_path + '/%s_queryw.npy' % prefix, queryw)\n", (21688, 21733), True, 'import numpy as np\n'), ((21746, 21802), 'numpy.save', 'np.save', (["(np_path + '/%s_contextc.npy' % prefix)", 'contextc'], {}), "(np_path + '/%s_contextc.npy' % prefix, contextc)\n", (21753, 21802), True, 'import numpy as np\n'), ((21815, 21867), 'numpy.save', 'np.save', (["(np_path + '/%s_queryc.npy' % prefix)", 'queryc'], {}), "(np_path + '/%s_queryc.npy' % prefix, queryc)\n", (21822, 21867), True, 'import numpy as np\n'), ((21880, 21924), 'numpy.save', 'np.save', (["(np_path + '/%s_p1.npy' % prefix)", 'p1'], {}), "(np_path + '/%s_p1.npy' % prefix, p1)\n", (21887, 21924), True, 'import numpy as np\n'), ((21937, 21981), 'numpy.save', 'np.save', (["(np_path + '/%s_p2.npy' % prefix)", 'p2'], {}), "(np_path + '/%s_p2.npy' % prefix, p2)\n", (21944, 21981), True, 'import numpy as np\n'), ((21994, 22044), 'numpy.save', 'np.save', (["(np_path + '/%s_start.npy' % prefix)", 'start'], {}), "(np_path + '/%s_start.npy' % prefix, start)\n", (22001, 22044), True, 'import numpy as np\n'), ((22057, 22103), 'numpy.save', 'np.save', (["(np_path + '/%s_end.npy' % prefix)", 'end'], {}), "(np_path + '/%s_end.npy' % prefix, end)\n", (22064, 22103), True, 'import numpy as np\n'), ((23110, 23162), 'numpy.save', 'np.save', (["(np_path + '/word_vectors.npy')", 'word_vectors'], {}), "(np_path + '/word_vectors.npy', word_vectors)\n", (23117, 23162), True, 'import numpy as np\n'), ((23175, 23227), 'numpy.save', 'np.save', (["(np_path + '/char_vectors.npy')", 'char_vectors'], {}), "(np_path + '/char_vectors.npy', char_vectors)\n", (23182, 23227), True, 'import numpy as np\n'), ((23804, 23850), 'numpy.load', 'np.load', (["(np_path + '/%s_ques_ids.npy' % prefix)"], {}), "(np_path + '/%s_ques_ids.npy' % prefix)\n", (23811, 23850), True, 'import numpy as np\n'), ((23874, 23920), 'numpy.load', 'np.load', (["(np_path + '/%s_contextw.npy' % prefix)"], {}), "(np_path + '/%s_contextw.npy' % prefix)\n", (23881, 23920), True, 'import numpy as np\n'), ((23942, 23986), 'numpy.load', 'np.load', (["(np_path + '/%s_queryw.npy' % prefix)"], {}), "(np_path + '/%s_queryw.npy' % prefix)\n", (23949, 23986), True, 'import numpy as np\n'), ((24010, 24056), 'numpy.load', 'np.load', (["(np_path + '/%s_contextc.npy' % prefix)"], {}), "(np_path + '/%s_contextc.npy' % prefix)\n", (24017, 24056), True, 'import numpy as np\n'), ((24078, 24122), 'numpy.load', 'np.load', (["(np_path + '/%s_queryc.npy' % prefix)"], {}), "(np_path + '/%s_queryc.npy' % prefix)\n", (24085, 24122), True, 'import numpy as np\n'), ((24140, 24180), 'numpy.load', 'np.load', (["(np_path + '/%s_p1.npy' % prefix)"], {}), "(np_path + '/%s_p1.npy' % prefix)\n", (24147, 24180), True, 'import numpy as np\n'), ((24198, 24238), 'numpy.load', 'np.load', (["(np_path + '/%s_p2.npy' % prefix)"], {}), "(np_path + '/%s_p2.npy' % prefix)\n", (24205, 24238), True, 'import numpy as np\n'), ((24259, 24302), 'numpy.load', 'np.load', (["(np_path + '/%s_start.npy' % prefix)"], {}), "(np_path + '/%s_start.npy' % prefix)\n", (24266, 24302), True, 'import numpy as np\n'), ((24321, 24362), 'numpy.load', 'np.load', (["(np_path + '/%s_end.npy' % prefix)"], {}), "(np_path + '/%s_end.npy' % prefix)\n", (24328, 24362), True, 'import numpy as np\n'), ((24838, 24876), 'numpy.load', 'np.load', (["(np_path + '/word_vectors.npy')"], {}), "(np_path + '/word_vectors.npy')\n", (24845, 24876), True, 'import numpy as np\n'), ((24904, 24942), 'numpy.load', 'np.load', (["(np_path + '/char_vectors.npy')"], {}), "(np_path + '/char_vectors.npy')\n", (24911, 24942), True, 'import numpy as np\n'), ((4154, 4193), 'numpy.random.uniform', 'np.random.uniform', (['(0.0)', '(1.0)', '[emb_size]'], {}), '(0.0, 1.0, [emb_size])\n', (4171, 4193), True, 'import numpy as np\n'), ((22305, 22325), 'pickle.dump', 'pickle.dump', (['self', 'f'], {}), '(self, f)\n', (22316, 22325), False, 'import pickle\n'), ((22853, 22876), 'os.path.exists', 'os.path.exists', (['np_path'], {}), '(np_path)\n', (22867, 22876), False, 'import os\n'), ((22894, 22914), 'os.makedirs', 'os.makedirs', (['np_path'], {}), '(np_path)\n', (22905, 22914), False, 'import os\n'), ((24667, 24681), 'pickle.load', 'pickle.load', (['f'], {}), '(f)\n', (24678, 24681), False, 'import pickle\n'), ((17248, 17290), 'numpy.zeros', 'np.zeros', (['cf.CONTEXT_LEN'], {'dtype': 'np.float16'}), '(cf.CONTEXT_LEN, dtype=np.float16)\n', (17256, 17290), True, 'import numpy as np\n'), ((17413, 17455), 'numpy.zeros', 'np.zeros', (['cf.CONTEXT_LEN'], {'dtype': 'np.float16'}), '(cf.CONTEXT_LEN, dtype=np.float16)\n', (17421, 17455), True, 'import numpy as np\n')]
|
import numpy
from kapteyn import maputils
from matplotlib.pyplot import show, figure
import csv # Read some poitions from file in Comma Separated Values format
# Some initializations
blankcol = "#334455" # Represent undefined values by this color
epsilon = 0.0000000001
figsize = (9,7) # Figure size in inches
plotbox = (0.1,0.05,0.8,0.8)
fig = figure(figsize=figsize)
frame = fig.add_axes(plotbox)
Basefits = maputils.FITSimage("allsky_raw.fits") # Here is your downloaded FITS file in rectangular coordinates
Basefits.hdr['CTYPE1'] = 'GLON-CAR' # For transformations we need to give it a projection type
Basefits.hdr['CTYPE2'] = 'GLAT-CAR' # CAR is rectangular
# Use some header values to define reprojection parameters
cdelt1 = Basefits.hdr['CDELT1']
cdelt2 = Basefits.hdr['CDELT2']
naxis1 = Basefits.hdr['NAXIS1']
naxis2 = Basefits.hdr['NAXIS2']
# Header works only with a patched wcslib 4.3
# Note that changing CRVAL1 to 180 degerees, shifts the plot 180 deg.
header = {'NAXIS' : 2, 'NAXIS1': naxis1, 'NAXIS2': naxis2,
'CTYPE1' : 'GLON-AIT',
'CRVAL1' : 0, 'CRPIX1' : naxis1//2, 'CUNIT1' : 'deg', 'CDELT1' : cdelt1,
'CTYPE2' : 'GLAT-AIT',
'CRVAL2' : 30.0, 'CRPIX2' : naxis2//2, 'CUNIT2' : 'deg', 'CDELT2' : cdelt2,
'LONPOLE' :60.0,
'PV1_1' : 0.0, 'PV1_2' : 90.0, # IMPORTANT. This is a setting from Cal.section 7.1, p 1103
}
Reprojfits = Basefits.reproject_to(header)
annim_rep = Reprojfits.Annotatedimage(frame)
annim_rep.set_colormap("heat.lut") # Set color map before creating Image object
annim_rep.set_blankcolor(blankcol) # Background are NaN's (blanks). Set color here
annim_rep.Image(vmin=30000, vmax=150000) # Just a selection of two clip levels
annim_rep.plot()
# Draw the graticule, but do not cover near -90 to prevent ambiguity
X = numpy.arange(0,390.0,15.0);
Y = numpy.arange(-75,90,15.0)
f = maputils.FITSimage(externalheader=header)
annim = f.Annotatedimage(frame)
grat = annim.Graticule(axnum= (1,2), wylim=(-90,90.0), wxlim=(0,360),
startx=X, starty=Y)
grat.setp_lineswcs0(0, color='w', lw=2)
grat.setp_lineswcs1(0, color='w', lw=2)
# Draw border with standard graticule, just to make the borders look smooth
header['CRVAL1'] = 0.0
header['CRVAL2'] = 0.0
del header['PV1_1']
del header['PV1_2']
header['LONPOLE'] = 0.0
header['LATPOLE'] = 0.0
border = annim.Graticule(header, axnum= (1,2), wylim=(-90,90.0), wxlim=(-180,180),
startx=(180-epsilon, -180+epsilon), skipy=True)
border.setp_lineswcs0(color='w', lw=2) # Show borders in arbitrary color (e.g. background color)
border.setp_lineswcs1(color='w', lw=2)
# Plot the 'inside' graticules
lon_constval = 0.0
lat_constval = 0.0
lon_fmt = 'Dms'; lat_fmt = 'Dms' # Only Degrees must be plotted
addangle0 = addangle1=0.0
deltapx0 = deltapx1 = 1.0
labkwargs0 = {'color':'r', 'va':'center', 'ha':'center'}
labkwargs1 = {'color':'r', 'va':'center', 'ha':'center'}
lon_world = list(range(0,360,30))
lat_world = [-60, -30, 30, 60]
ilabs1 = grat.Insidelabels(wcsaxis=0,
world=lon_world, constval=lat_constval,
deltapx=1.0, deltapy=1.0,
addangle=addangle0, fmt=lon_fmt, **labkwargs0)
ilabs2 = grat.Insidelabels(wcsaxis=1,
world=lat_world, constval=lon_constval,
deltapx=1.0, deltapy=1.0,
addangle=addangle1, fmt=lat_fmt, **labkwargs1)
# Read marker positions (in 0h0m0s 0d0m0s format) from file
reader = csv.reader(open("positions.txt"), delimiter=' ', skipinitialspace=True)
for line in reader:
if line:
hms, dms = line
postxt = "{eq fk4-no-e} "+hms+" {} "+dms # Define the sky system of the source
print(postxt)
annim.Marker(pos=postxt, marker='*', color='yellow', ms=20)
# Plot a title
titlepos = 1.02
title = r"""All sky map in Hammer Aitoff projection (AIT) oblique with:
$(\alpha_p,\delta_p) = (0^\circ,30^\circ)$, $\phi_p = 75^\circ$ also:
$(\phi_0,\theta_0) = (0^\circ,90^\circ)$."""
t = frame.set_title(title, color='g', fontsize=13, linespacing=1.5)
t.set_y(titlepos)
annim.plot()
annim.interact_toolbarinfo()
annim_rep.interact_imagecolors()
show()
|
[
"matplotlib.pyplot.figure",
"kapteyn.maputils.FITSimage",
"numpy.arange",
"matplotlib.pyplot.show"
] |
[((387, 410), 'matplotlib.pyplot.figure', 'figure', ([], {'figsize': 'figsize'}), '(figsize=figsize)\n', (393, 410), False, 'from matplotlib.pyplot import show, figure\n'), ((453, 490), 'kapteyn.maputils.FITSimage', 'maputils.FITSimage', (['"""allsky_raw.fits"""'], {}), "('allsky_raw.fits')\n", (471, 490), False, 'from kapteyn import maputils\n'), ((1933, 1961), 'numpy.arange', 'numpy.arange', (['(0)', '(390.0)', '(15.0)'], {}), '(0, 390.0, 15.0)\n', (1945, 1961), False, 'import numpy\n'), ((1966, 1993), 'numpy.arange', 'numpy.arange', (['(-75)', '(90)', '(15.0)'], {}), '(-75, 90, 15.0)\n', (1978, 1993), False, 'import numpy\n'), ((1996, 2037), 'kapteyn.maputils.FITSimage', 'maputils.FITSimage', ([], {'externalheader': 'header'}), '(externalheader=header)\n', (2014, 2037), False, 'from kapteyn import maputils\n'), ((4320, 4326), 'matplotlib.pyplot.show', 'show', ([], {}), '()\n', (4324, 4326), False, 'from matplotlib.pyplot import show, figure\n')]
|
import uuid
import random
import os
import math
import numpy as np
import simpy
import matplotlib.pyplot as plt
from simulation.ghostdag import block
from simulation.ghostdag.dag import select_ghostdag_k, DAG
from simulation.fakes import FakeDAG
from simulation.channel import Hub, Channel, PlanarTopology
from simulation.helpers import print_dag, print_stats, save_to_json
from simulation.miner import Miner
from simulation.attack_miners import AttackMiner
simulation_time = 2 ** 12
with_attack = True
print_progress = True
def make_dag(genesis_hash, k):
return DAG(k=k, interval=(0, 2 ** 64 - 1), genesis_hash=genesis_hash)
def make_honest_miner(miner_channel, genesis_hash, k, _lambda, _alpha, miner_index, num_miners):
if miner_index == 0:
dag = make_dag(genesis_hash, k)
else:
dag = FakeDAG(genesis_hash=genesis_hash)
return Miner(k, _lambda, 1 / num_miners, dag, miner_channel)
def make_attack_miner(miner_channel, genesis_hash, k, _lambda, _alpha, miner_index, num_miners):
if miner_index == 0:
dag = make_dag(genesis_hash, k)
miner = Miner(-1, _lambda, (1 - _alpha) / (num_miners - 1), dag, miner_channel)
# Only miner 1 is the actual attacker
elif miner_index == 1:
dag = make_dag(genesis_hash, k)
miner = AttackMiner(-1, _lambda, _alpha, dag, miner_channel)
else:
dag = FakeDAG(genesis_hash=genesis_hash)
miner = Miner(-1, _lambda, (1 - _alpha) / (num_miners - 1), dag, miner_channel)
return miner
class Simulation:
def __init__(self, _alpha, _delta, _lambda, rows=3, cols=3, D_factor=1.0, k=None):
# Communication constants
self.D_min, self.D_max = 0.1, np.sqrt((rows * D_factor) ** 2 + (cols * D_factor) ** 2) + 0.1
# Mining parameters
self._alpha = _alpha
self._delta = _delta
self._lambda = _lambda
if k is None:
self.k = select_ghostdag_k(2 * self.D_max * _lambda, _delta)
else:
self.k = k
# Simulation environment
self.env = simpy.Environment()
# Grid topology
self.topology = PlanarTopology(D_min=self.D_min, D_max=self.D_max)
self.hub = Hub(self.env, latency_oracle=self.topology.latency)
self.channels = []
for r in range(rows):
for c in range(cols):
channel = Channel(self.hub)
self.topology.channel_map[channel] = (r * D_factor, c * D_factor)
self.channels.append(channel)
def run_simulation(self, seed=22522):
# Setup and start the simulation
if seed is not None:
np.random.seed(seed)
random.seed(seed)
if print_progress:
print('\n=========\n')
print('GHOSTDAG simulation')
print('\n=========\n')
genesis_hash = uuid.uuid1().int
miners = []
block.reindex_size_trace = []
for i, channel in enumerate(self.channels):
s = str(self.topology.channel_map[channel])
if print_progress:
print('Miner %d coordinates: %s' % (i, s))
if with_attack:
miner = make_attack_miner(channel, genesis_hash, self.k, self._lambda, self._alpha, i, len(self.channels))
else:
miner = make_honest_miner(channel, genesis_hash, self.k, self._lambda, self._alpha, i, len(self.channels))
self.env.process(miner.mine(self.env))
self.env.process(miner.receive(self.env))
if i == 0 and print_progress:
self.env.process(miner.report(self.env))
miners.append(miner)
if print_progress:
print('\n=========\n')
self.env.run(until=simulation_time)
if print_progress:
print('\n=========\n')
return miners[0].dag
def main():
_lambda, _delta, _alpha = 1, 0.01, 0.01
simulation = Simulation(_alpha, _delta, _lambda)
dag = simulation.run_simulation()
# print_dag(dag)
print('\n=========\n')
# Print stats
print_stats(simulation.D_max, _delta, _lambda, dag, simulation.k)
print('\n=========\n')
plt.figure()
plt.plot(block.reindex_size_trace, linewidth=0.1)
plt.xlabel('time')
plt.ylabel('reindex size')
plt.show()
if not os.path.isdir('data'):
os.mkdir('data')
save_to_json(dag, file_name=os.path.join('data', 'dag.json'))
if __name__ == '__main__':
main()
# try:
# main()
# except Exception as ex:
# print(type(ex).__name__, ex)
|
[
"numpy.sqrt",
"matplotlib.pyplot.ylabel",
"simulation.ghostdag.dag.DAG",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"simulation.channel.Hub",
"os.path.isdir",
"os.mkdir",
"numpy.random.seed",
"simpy.Environment",
"uuid.uuid1",
"matplotlib.pyplot.show",
"simulation.helpers.print_stats",
"simulation.channel.Channel",
"simulation.miner.Miner",
"simulation.ghostdag.dag.select_ghostdag_k",
"random.seed",
"simulation.channel.PlanarTopology",
"os.path.join",
"matplotlib.pyplot.figure",
"simulation.fakes.FakeDAG",
"simulation.attack_miners.AttackMiner"
] |
[((570, 632), 'simulation.ghostdag.dag.DAG', 'DAG', ([], {'k': 'k', 'interval': '(0, 2 ** 64 - 1)', 'genesis_hash': 'genesis_hash'}), '(k=k, interval=(0, 2 ** 64 - 1), genesis_hash=genesis_hash)\n', (573, 632), False, 'from simulation.ghostdag.dag import select_ghostdag_k, DAG\n'), ((846, 899), 'simulation.miner.Miner', 'Miner', (['k', '_lambda', '(1 / num_miners)', 'dag', 'miner_channel'], {}), '(k, _lambda, 1 / num_miners, dag, miner_channel)\n', (851, 899), False, 'from simulation.miner import Miner\n'), ((3576, 3641), 'simulation.helpers.print_stats', 'print_stats', (['simulation.D_max', '_delta', '_lambda', 'dag', 'simulation.k'], {}), '(simulation.D_max, _delta, _lambda, dag, simulation.k)\n', (3587, 3641), False, 'from simulation.helpers import print_dag, print_stats, save_to_json\n'), ((3669, 3681), 'matplotlib.pyplot.figure', 'plt.figure', ([], {}), '()\n', (3679, 3681), True, 'import matplotlib.pyplot as plt\n'), ((3683, 3732), 'matplotlib.pyplot.plot', 'plt.plot', (['block.reindex_size_trace'], {'linewidth': '(0.1)'}), '(block.reindex_size_trace, linewidth=0.1)\n', (3691, 3732), True, 'import matplotlib.pyplot as plt\n'), ((3734, 3752), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""time"""'], {}), "('time')\n", (3744, 3752), True, 'import matplotlib.pyplot as plt\n'), ((3754, 3780), 'matplotlib.pyplot.ylabel', 'plt.ylabel', (['"""reindex size"""'], {}), "('reindex size')\n", (3764, 3780), True, 'import matplotlib.pyplot as plt\n'), ((3782, 3792), 'matplotlib.pyplot.show', 'plt.show', ([], {}), '()\n', (3790, 3792), True, 'import matplotlib.pyplot as plt\n'), ((803, 837), 'simulation.fakes.FakeDAG', 'FakeDAG', ([], {'genesis_hash': 'genesis_hash'}), '(genesis_hash=genesis_hash)\n', (810, 837), False, 'from simulation.fakes import FakeDAG\n'), ((1065, 1136), 'simulation.miner.Miner', 'Miner', (['(-1)', '_lambda', '((1 - _alpha) / (num_miners - 1))', 'dag', 'miner_channel'], {}), '(-1, _lambda, (1 - _alpha) / (num_miners - 1), dag, miner_channel)\n', (1070, 1136), False, 'from simulation.miner import Miner\n'), ((1908, 1927), 'simpy.Environment', 'simpy.Environment', ([], {}), '()\n', (1925, 1927), False, 'import simpy\n'), ((1965, 2015), 'simulation.channel.PlanarTopology', 'PlanarTopology', ([], {'D_min': 'self.D_min', 'D_max': 'self.D_max'}), '(D_min=self.D_min, D_max=self.D_max)\n', (1979, 2015), False, 'from simulation.channel import Hub, Channel, PlanarTopology\n'), ((2029, 2080), 'simulation.channel.Hub', 'Hub', (['self.env'], {'latency_oracle': 'self.topology.latency'}), '(self.env, latency_oracle=self.topology.latency)\n', (2032, 2080), False, 'from simulation.channel import Hub, Channel, PlanarTopology\n'), ((3802, 3823), 'os.path.isdir', 'os.path.isdir', (['"""data"""'], {}), "('data')\n", (3815, 3823), False, 'import os\n'), ((3827, 3843), 'os.mkdir', 'os.mkdir', (['"""data"""'], {}), "('data')\n", (3835, 3843), False, 'import os\n'), ((1244, 1296), 'simulation.attack_miners.AttackMiner', 'AttackMiner', (['(-1)', '_lambda', '_alpha', 'dag', 'miner_channel'], {}), '(-1, _lambda, _alpha, dag, miner_channel)\n', (1255, 1296), False, 'from simulation.attack_miners import AttackMiner\n'), ((1312, 1346), 'simulation.fakes.FakeDAG', 'FakeDAG', ([], {'genesis_hash': 'genesis_hash'}), '(genesis_hash=genesis_hash)\n', (1319, 1346), False, 'from simulation.fakes import FakeDAG\n'), ((1357, 1428), 'simulation.miner.Miner', 'Miner', (['(-1)', '_lambda', '((1 - _alpha) / (num_miners - 1))', 'dag', 'miner_channel'], {}), '(-1, _lambda, (1 - _alpha) / (num_miners - 1), dag, miner_channel)\n', (1362, 1428), False, 'from simulation.miner import Miner\n'), ((1793, 1844), 'simulation.ghostdag.dag.select_ghostdag_k', 'select_ghostdag_k', (['(2 * self.D_max * _lambda)', '_delta'], {}), '(2 * self.D_max * _lambda, _delta)\n', (1810, 1844), False, 'from simulation.ghostdag.dag import select_ghostdag_k, DAG\n'), ((2388, 2408), 'numpy.random.seed', 'np.random.seed', (['seed'], {}), '(seed)\n', (2402, 2408), True, 'import numpy as np\n'), ((2412, 2429), 'random.seed', 'random.seed', (['seed'], {}), '(seed)\n', (2423, 2429), False, 'import random\n'), ((2552, 2564), 'uuid.uuid1', 'uuid.uuid1', ([], {}), '()\n', (2562, 2564), False, 'import uuid\n'), ((3873, 3905), 'os.path.join', 'os.path.join', (['"""data"""', '"""dag.json"""'], {}), "('data', 'dag.json')\n", (3885, 3905), False, 'import os\n'), ((1608, 1664), 'numpy.sqrt', 'np.sqrt', (['((rows * D_factor) ** 2 + (cols * D_factor) ** 2)'], {}), '((rows * D_factor) ** 2 + (cols * D_factor) ** 2)\n', (1615, 1664), True, 'import numpy as np\n'), ((2165, 2182), 'simulation.channel.Channel', 'Channel', (['self.hub'], {}), '(self.hub)\n', (2172, 2182), False, 'from simulation.channel import Hub, Channel, PlanarTopology\n')]
|
import argparse
import os
import cv2
import numpy as np
def gamma_correction(source_path, destination_path, a, b, version):
# Load image into memory
# Algorithm can work correctly with colored and grayscale images
if version == 'colored':
original_image = cv2.imread(source_path)
elif version == 'grayscale':
original_image = cv2.imread(source_path, cv2.IMREAD_GRAYSCALE)
else:
# Other types are not supported
raise RuntimeError('Wrong type of image')
# Apply formula to rescaled image
processed_image = a * ((original_image / 255) ** b)
# Crop values, that are too high
processed_image[processed_image >= 1] = 1
# Scale image back to [0 - 255]
processed_image = processed_image * 255
# Correctly convert float values to integers
processed_image = np.rint(processed_image)
# Convert to `np.uint8`, so `imwrite` will save image correctly
cv2.imwrite(destination_path, processed_image.astype(np.uint8))
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='Perform gamma correction.')
parser.add_argument('source_path', metavar='source_path', type=str,
help='Path to the original image.')
parser.add_argument('destination_path', metavar='destination_path', type=str,
help='Path to the processed image.')
parser.add_argument('a', metavar='a', type=float,
help='First parameter of gamma correction algorithm.')
parser.add_argument('b', metavar='b', type=float,
help='Second parameter of gamma correction algorithm.')
parser.add_argument('--version', type=str, default='colored',
help='Shows type of image. Variants: colored / grayscale.')
args = parser.parse_args()
if not os.path.exists(args.source_path):
raise FileNotFoundError
gamma_correction(args.source_path, args.destination_path, args.a, args.b, args.version)
|
[
"os.path.exists",
"numpy.rint",
"argparse.ArgumentParser",
"cv2.imread"
] |
[((836, 860), 'numpy.rint', 'np.rint', (['processed_image'], {}), '(processed_image)\n', (843, 860), True, 'import numpy as np\n'), ((1040, 1104), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Perform gamma correction."""'}), "(description='Perform gamma correction.')\n", (1063, 1104), False, 'import argparse\n'), ((279, 302), 'cv2.imread', 'cv2.imread', (['source_path'], {}), '(source_path)\n', (289, 302), False, 'import cv2\n'), ((1841, 1873), 'os.path.exists', 'os.path.exists', (['args.source_path'], {}), '(args.source_path)\n', (1855, 1873), False, 'import os\n'), ((361, 406), 'cv2.imread', 'cv2.imread', (['source_path', 'cv2.IMREAD_GRAYSCALE'], {}), '(source_path, cv2.IMREAD_GRAYSCALE)\n', (371, 406), False, 'import cv2\n')]
|
# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import os
import time
import paddle
import paddle.fluid as fluid
import numpy as np
import paddle.distributed.fleet as fleet
class Trainer(object):
def __init__(self):
"""
"""
self.place = None
class CPUTrainer(Trainer):
def __init__(self):
super(CPUTrainer, self).__init__()
self.place = fluid.CPUPlace()
self.exe = fluid.Executor(self.place)
def fit(self, model, dataloader, epoch, start_step=10):
fleet.init_worker()
self.exe.run(fluid.default_startup_program())
for epoch_id in range(epoch):
total_time = 0
step = 0
for data in dataloader():
if step > start_step:
start_time = time.time()
loss = self.exe.run(fluid.default_main_program(),
feed=data,
fetch_list=[model.loss.name])
if step > start_step:
end_time = time.time()
total_time += (end_time - start_time)
print(
"worker_index: %d, step%d, train_loss: %f, total time cost = %f, step per second: %f, speed: %f"
% (fleet.worker_index(), step, loss[0], total_time,
(step - start_step) / total_time,
1 / (end_time - start_time)))
step += 1
fleet.stop_worker()
class MultiGPUTrainer(Trainer):
def __init__(self):
super(MultiGPUTrainer, self).__init__()
self.place = fluid.CUDAPlace(
int(os.environ.get('FLAGS_selected_gpus', 0)))
self.exe = fluid.Executor(self.place)
self.exe.run(fluid.default_startup_program())
def fit(self, model, dataloader, epoch, use_dali=False, start_step=10):
for epoch_id in range(epoch):
total_time = 0
step = 0
for data in dataloader:
if step > start_step:
start_time = time.time()
loss = self.exe.run(fluid.default_main_program(),
feed=data,
fetch_list=[model.loss.name],
use_program_cache=True)
if step > start_step:
end_time = time.time()
total_time += (end_time - start_time)
print(
"epoch id: %d, step%d, train_loss: %f, total time cost = %f, step per second: %f, speed: %f"
% (epoch_id, step, loss[0], total_time,
(step - start_step) / total_time,
1 / (end_time - start_time)))
step += 1
if use_dali:
dataloader.reset()
def val(self,
model,
dataloader,
target_list,
current_epoch=-1,
use_dali=False):
self.test_program = model.main_prog.clone(for_test=True)
fetch_target = []
results = {}
for item in target_list:
if item in model.target.keys():
fetch_target.append(model.target[item].name)
results[item] = []
else:
raise Exception("ERROR: Current model only support target: {}".
format(model.target.keys()))
for data in dataloader:
result = self.exe.run(self.test_program,
feed=data,
fetch_list=fetch_target,
use_program_cache=True)
for item in target_list:
results[item].append(np.mean(result[target_list.index(item)]))
log_info = ""
for item in target_list:
log_info += ", {} = {}".format(item, np.mean(results[item]))
if current_epoch > 0:
print("Test Epoch {}{}".format(current_epoch, log_info))
else:
print("Test Result {}".format(log_info))
if use_dali:
dataloader.reset()
def quick_benchmark(self,
model,
dataloader,
start_step=20,
end_step=200):
step = 0
total_time = 0
total_step = 0
counting_time = False
for data in dataloader:
if step > start_step and step <= end_step:
start_time = time.time()
loss = self.exe.run(fluid.default_main_program(),
feed=data,
fetch_list=[],
use_program_cache=True)
if step > start_step and step <= end_step:
end_time = time.time()
total_time += (end_time - start_time)
if step > end_step:
break
step += 1
mean_qps = (end_step - start_step) / total_time
return mean_qps
def benchmark(self,
model,
dataloader,
epoch,
use_dali=False,
start_step=20):
for epoch_id in range(epoch):
total_time = 0
step = 0
for data in dataloader:
if step > start_step and step <= start_step + 100:
start_time = time.time()
loss = self.exe.run(fluid.default_main_program(),
feed=data,
fetch_list=[model.loss.name],
use_program_cache=True)
if step > start_step and step <= start_step + 100:
end_time = time.time()
total_time += (end_time - start_time)
step += 1
average_speed = 100 / total_time
if use_dali:
dataloader.reset()
return average_speed
def benchmark_val(self, model, dataloader, target_list, use_dali=False):
self.test_program = model.main_prog.clone(for_test=True)
fetch_target = []
results = {}
for item in target_list:
if item in model.target.keys():
fetch_target.append(model.target[item].name)
results[item] = []
else:
raise Exception("ERROR: Current model only support target: {}".
format(model.target.keys()))
for data in dataloader:
result = self.exe.run(self.test_program,
feed=data,
fetch_list=fetch_target,
use_program_cache=True)
for item in target_list:
results[item].append(np.mean(result[target_list.index(item)]))
if use_dali:
dataloader.reset()
return results
|
[
"numpy.mean",
"paddle.distributed.fleet.worker_index",
"paddle.fluid.default_startup_program",
"paddle.fluid.CPUPlace",
"os.environ.get",
"paddle.fluid.default_main_program",
"paddle.fluid.Executor",
"paddle.distributed.fleet.stop_worker",
"paddle.distributed.fleet.init_worker",
"time.time"
] |
[((960, 976), 'paddle.fluid.CPUPlace', 'fluid.CPUPlace', ([], {}), '()\n', (974, 976), True, 'import paddle.fluid as fluid\n'), ((996, 1022), 'paddle.fluid.Executor', 'fluid.Executor', (['self.place'], {}), '(self.place)\n', (1010, 1022), True, 'import paddle.fluid as fluid\n'), ((1092, 1111), 'paddle.distributed.fleet.init_worker', 'fleet.init_worker', ([], {}), '()\n', (1109, 1111), True, 'import paddle.distributed.fleet as fleet\n'), ((2069, 2088), 'paddle.distributed.fleet.stop_worker', 'fleet.stop_worker', ([], {}), '()\n', (2086, 2088), True, 'import paddle.distributed.fleet as fleet\n'), ((2311, 2337), 'paddle.fluid.Executor', 'fluid.Executor', (['self.place'], {}), '(self.place)\n', (2325, 2337), True, 'import paddle.fluid as fluid\n'), ((1133, 1164), 'paddle.fluid.default_startup_program', 'fluid.default_startup_program', ([], {}), '()\n', (1162, 1164), True, 'import paddle.fluid as fluid\n'), ((2359, 2390), 'paddle.fluid.default_startup_program', 'fluid.default_startup_program', ([], {}), '()\n', (2388, 2390), True, 'import paddle.fluid as fluid\n'), ((2249, 2289), 'os.environ.get', 'os.environ.get', (['"""FLAGS_selected_gpus"""', '(0)'], {}), "('FLAGS_selected_gpus', 0)\n", (2263, 2289), False, 'import os\n'), ((4524, 4546), 'numpy.mean', 'np.mean', (['results[item]'], {}), '(results[item])\n', (4531, 4546), True, 'import numpy as np\n'), ((5151, 5162), 'time.time', 'time.time', ([], {}), '()\n', (5160, 5162), False, 'import time\n'), ((5195, 5223), 'paddle.fluid.default_main_program', 'fluid.default_main_program', ([], {}), '()\n', (5221, 5223), True, 'import paddle.fluid as fluid\n'), ((5453, 5464), 'time.time', 'time.time', ([], {}), '()\n', (5462, 5464), False, 'import time\n'), ((1362, 1373), 'time.time', 'time.time', ([], {}), '()\n', (1371, 1373), False, 'import time\n'), ((1410, 1438), 'paddle.fluid.default_main_program', 'fluid.default_main_program', ([], {}), '()\n', (1436, 1438), True, 'import paddle.fluid as fluid\n'), ((1622, 1633), 'time.time', 'time.time', ([], {}), '()\n', (1631, 1633), False, 'import time\n'), ((2663, 2674), 'time.time', 'time.time', ([], {}), '()\n', (2672, 2674), False, 'import time\n'), ((2711, 2739), 'paddle.fluid.default_main_program', 'fluid.default_main_program', ([], {}), '()\n', (2737, 2739), True, 'import paddle.fluid as fluid\n'), ((2983, 2994), 'time.time', 'time.time', ([], {}), '()\n', (2992, 2994), False, 'import time\n'), ((6073, 6084), 'time.time', 'time.time', ([], {}), '()\n', (6082, 6084), False, 'import time\n'), ((6121, 6149), 'paddle.fluid.default_main_program', 'fluid.default_main_program', ([], {}), '()\n', (6147, 6149), True, 'import paddle.fluid as fluid\n'), ((6422, 6433), 'time.time', 'time.time', ([], {}), '()\n', (6431, 6433), False, 'import time\n'), ((1867, 1887), 'paddle.distributed.fleet.worker_index', 'fleet.worker_index', ([], {}), '()\n', (1885, 1887), True, 'import paddle.distributed.fleet as fleet\n')]
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2020, 2021.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""Converter to convert a problem with inequality constraints to unconstrained with penalty terms."""
import logging
from typing import Optional, Union, Tuple, List, Dict
import numpy as np
from .quadratic_program_converter import QuadraticProgramConverter
from ..exceptions import QiskitOptimizationError
from ..problems.constraint import Constraint, ConstraintSense
from ..problems.quadratic_objective import QuadraticObjective
from ..problems.quadratic_program import QuadraticProgram
from ..problems.variable import Variable
logger = logging.getLogger(__name__)
class LinearInequalityToPenalty(QuadraticProgramConverter):
r"""Convert linear inequality constraints to penalty terms of the objective function.
There are some linear constraints which do not require slack variables to
construct penalty terms [1]. This class supports the following inequality constraints.
.. math::
\begin{array}{}
\text { Inequality constraint } & & \text { Penalty term } \\
x \leq y & \rightarrow & P(x-x y) \\
x \geq y & \rightarrow & P(y-x y) \\
\sum_{i=1}^n x_i \leq 1, n \geq 2 & \rightarrow & P \sum_{i, j : i < j} x_i x_j\\
\sum_{i=1}^n x_i \geq n-1, n \geq 2 & \rightarrow & P \sum_{i, j : i < j} (1 - x_i) (1 - x_j)
\end{array}
Note that x, y, z and :math:`x_i` are binary variables, and P is a penalty factor,
where the value of P is automatically determined or supplied by users.
If constraints match with any of the patterns, they are converted into penalty terms and added
to the objective function. Otherwise, constraints are kept as is.
References:
[1]: <NAME>, et al. (2019),
A Tutorial on Formulating and Using QUBO Models,
`arXiv:1811.11538 <https://arxiv.org/abs/1811.11538>`_.
"""
def __init__(self, penalty: Optional[float] = None) -> None:
"""
Args:
penalty: Penalty factor to scale equality constraints that are added to objective.
If None is passed, a penalty factor will be automatically calculated on
every conversion.
"""
self._src_num_vars: Optional[int] = None
self._dst: Optional[QuadraticProgram] = None
self._penalty: Optional[float] = penalty
self._should_define_penalty: bool = penalty is None
def convert(self, problem: QuadraticProgram) -> QuadraticProgram:
r"""Convert inequality constraints into penalty terms of the objective function.
This methods converts the following patterns where x, y, and :math:`x_i` are binary variables
and P is a penalty factor.
.. math::
\begin{array}{}
\text { Inequality constraint } & & \text { Penalty term } \\
x \leq y & \rightarrow & P(x-x y) \\
x \geq y & \rightarrow & P(y-x y) \\
\sum_{i=1}^n x_i \leq 1, n \geq 2 & \rightarrow & P \sum_{i, j : i < j} x_i x_j\\
\sum_{i=1}^n x_i \geq n-1, n \geq 2 & \rightarrow & P \sum_{i, j : i < j} (1 - x_i) (1 - x_j)
\end{array}
Args:
problem: The problem to be solved.
Returns:
The converted problem
Raises:
QiskitOptimizationError: If an unsupported-type variable exists.
"""
# create empty QuadraticProgram model
self._src_num_vars = problem.get_num_vars()
self._dst = QuadraticProgram(name=problem.name)
# If no penalty was given, set the penalty coefficient by _auto_define_penalty()
if self._should_define_penalty:
penalty = self._auto_define_penalty(problem)
else:
penalty = self._penalty
# Set variables
for x in problem.variables:
if x.vartype == Variable.Type.CONTINUOUS:
self._dst.continuous_var(x.lowerbound, x.upperbound, x.name)
elif x.vartype == Variable.Type.BINARY:
self._dst.binary_var(x.name)
elif x.vartype == Variable.Type.INTEGER:
self._dst.integer_var(x.lowerbound, x.upperbound, x.name)
else:
raise QiskitOptimizationError(f"Unsupported vartype: {x.vartype}")
# get original objective terms
offset = problem.objective.constant
linear = problem.objective.linear.to_dict()
quadratic = problem.objective.quadratic.to_dict()
sense = problem.objective.sense.value
# convert linear constraints into penalty terms
for constraint in problem.linear_constraints:
# special constraint check function here
if not self._is_matched_constraint(problem, constraint):
self._dst.linear_constraint(
constraint.linear.coefficients,
constraint.sense,
constraint.rhs,
constraint.name,
)
continue
conv_offset, conv_linear, conv_quadratic, varmap = self._conversion_table(constraint)
# constant part
offset += sense * penalty * conv_offset
# linear parts of penalty
for j, j_2 in varmap.items():
# if j already exists in the linear terms dic, add a penalty term
# into existing value else create new key and value in the linear_term dict
if conv_linear[j] != 0:
linear[j_2] = linear.get(j_2, 0.0) + sense * penalty * conv_linear[j]
# quadratic parts of penalty
for j, j_2 in varmap.items():
for k in range(j, len(varmap)):
# if j and k already exist in the quadratic terms dict,
# add a penalty term into existing value
# else create new key and value in the quadratic term dict
if conv_quadratic[j][k] != 0:
tup = (j_2, varmap[k])
quadratic[tup] = (
quadratic.get(tup, 0.0) + sense * penalty * conv_quadratic[j][k]
)
# Copy quadratic_constraints
for quadratic_constraint in problem.quadratic_constraints:
self._dst.quadratic_constraint(
quadratic_constraint.linear.coefficients,
quadratic_constraint.quadratic.coefficients,
quadratic_constraint.sense,
quadratic_constraint.rhs,
quadratic_constraint.name,
)
if problem.objective.sense == QuadraticObjective.Sense.MINIMIZE:
self._dst.minimize(offset, linear, quadratic)
else:
self._dst.maximize(offset, linear, quadratic)
# Update the penalty to the one just used
self._penalty = penalty
return self._dst
@staticmethod
def _conversion_table(
constraint,
) -> Tuple[int, np.ndarray, np.ndarray, Dict[int, int]]:
"""Construct conversion matrix for special constraint.
Returns:
Return conversion table which is used to construct
penalty term in main function.
Raises:
QiskitOptimizationError: if the constraint is invalid.
"""
vars_dict = constraint.linear.to_dict()
coeffs = list(vars_dict.values())
varmap = dict(enumerate(vars_dict.keys()))
rhs = constraint.rhs
sense = constraint.sense
num_vars = len(vars_dict)
# initialize return values, these are used for converted offset, linear
# and quadratic terms
offset = 0
linear = np.zeros(num_vars, dtype=int)
quadratic = np.zeros((num_vars, num_vars), dtype=int)
# rhs = num_vars - 1 correspond to multiple variable with >= n - 1 case.
if sense == ConstraintSense.GE and rhs == num_vars - 1:
# x_1 + ... + x_n >= n - 1
# The number of offset is combination ( nC2 )
offset = num_vars * (num_vars - 1) // 2
linear = np.full(num_vars, 1 - num_vars, dtype=int)
quadratic = np.triu(np.ones((num_vars, num_vars), dtype=int), k=1)
elif sense == ConstraintSense.LE and rhs == 1:
# x_1 + ... + x_n <= 1
quadratic = np.triu(np.ones((num_vars, num_vars), dtype=int), k=1)
elif rhs == 0:
if num_vars != 2:
raise QiskitOptimizationError(
f"Internal error: invalid number of variables {num_vars} {constraint.name}"
)
quadratic = np.array([[0, -1], [0, 0]])
if sense == ConstraintSense.GE:
# x >= y case
if coeffs[0] < 0.0:
linear[0] = 1
else:
linear[1] = 1
elif sense == ConstraintSense.LE:
# x <= y case
if coeffs[0] > 0.0:
linear[0] = 1
else:
linear[1] = 1
else:
raise QiskitOptimizationError(f"Internal error: invalid constraint {constraint.name}")
return offset, linear, quadratic, varmap
@staticmethod
def _is_matched_constraint(problem, constraint) -> bool:
"""Determine if constraint is special or not.
Returns:
True: when constraint is special
False: when constraint is not special
"""
params = constraint.linear.to_dict()
num_vars = len(params)
rhs = constraint.rhs
sense = constraint.sense
coeff_array = np.array(list(params.values()))
# Binary parameter?
if any(problem.variables[i].vartype != Variable.Type.BINARY for i in params.keys()):
return False
if num_vars == 2 and rhs == 0:
if sense in (Constraint.Sense.LE, Constraint.Sense.GE):
# x-y<=0
# x-y>=0
return coeff_array.min() == -1.0 and coeff_array.max() == 1.0
elif num_vars >= 2:
if sense == Constraint.Sense.LE and rhs == 1:
if all(i == 1 for i in params.values()):
# x1+x2+...<=1
return True
elif sense == Constraint.Sense.GE and rhs == num_vars - 1:
if all(i == 1 for i in params.values()):
# x1+x2+...>=n-1
return True
return False
@staticmethod
def _auto_define_penalty(problem) -> float:
"""Automatically define the penalty coefficient.
Returns:
Return the minimum valid penalty factor calculated
from the upper bound and the lower bound of the objective function.
If a constraint has a float coefficient,
return the default value for the penalty factor.
"""
default_penalty = 1e5
# Check coefficients of constraints.
# If a constraint has a float coefficient, return the default value for the penalty factor.
terms = []
for constraint in problem.linear_constraints:
terms.append(constraint.rhs)
terms.extend(constraint.linear.to_array().tolist())
if any(isinstance(term, float) and not term.is_integer() for term in terms):
logger.warning(
"Warning: Using %f for the penalty coefficient because "
"a float coefficient exists in constraints. \n"
"The value could be too small. "
"If so, set the penalty coefficient manually.",
default_penalty,
)
return default_penalty
lin_b = problem.objective.linear.bounds
quad_b = problem.objective.quadratic.bounds
return 1.0 + (lin_b.upperbound - lin_b.lowerbound) + (quad_b.upperbound - quad_b.lowerbound)
def interpret(self, x: Union[np.ndarray, List[float]]) -> np.ndarray:
"""Convert the result of the converted problem back to that of the original problem
Args:
x: The result of the converted problem or the given result in case of FAILURE.
Returns:
The result of the original problem.
Raises:
QiskitOptimizationError: if the number of variables in the result differs from
that of the original problem.
"""
if len(x) != self._src_num_vars:
raise QiskitOptimizationError(
f"The number of variables in the passed result ({len(x)}) differs from "
f"that of the original problem ({self._src_num_vars})."
)
return np.asarray(x)
@property
def penalty(self) -> Optional[float]:
"""Returns the penalty factor used in conversion.
Returns:
The penalty factor used in conversion.
"""
return self._penalty
@penalty.setter
def penalty(self, penalty: Optional[float]) -> None:
"""Set a new penalty factor.
Args:
penalty: The new penalty factor.
If None is passed, a penalty factor will be automatically calculated
on every conversion.
"""
self._penalty = penalty
self._should_define_penalty = penalty is None
|
[
"logging.getLogger",
"numpy.ones",
"numpy.asarray",
"numpy.array",
"numpy.zeros",
"numpy.full"
] |
[((1026, 1053), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1043, 1053), False, 'import logging\n'), ((8151, 8180), 'numpy.zeros', 'np.zeros', (['num_vars'], {'dtype': 'int'}), '(num_vars, dtype=int)\n', (8159, 8180), True, 'import numpy as np\n'), ((8201, 8242), 'numpy.zeros', 'np.zeros', (['(num_vars, num_vars)'], {'dtype': 'int'}), '((num_vars, num_vars), dtype=int)\n', (8209, 8242), True, 'import numpy as np\n'), ((13159, 13172), 'numpy.asarray', 'np.asarray', (['x'], {}), '(x)\n', (13169, 13172), True, 'import numpy as np\n'), ((8559, 8601), 'numpy.full', 'np.full', (['num_vars', '(1 - num_vars)'], {'dtype': 'int'}), '(num_vars, 1 - num_vars, dtype=int)\n', (8566, 8601), True, 'import numpy as np\n'), ((8634, 8674), 'numpy.ones', 'np.ones', (['(num_vars, num_vars)'], {'dtype': 'int'}), '((num_vars, num_vars), dtype=int)\n', (8641, 8674), True, 'import numpy as np\n'), ((8803, 8843), 'numpy.ones', 'np.ones', (['(num_vars, num_vars)'], {'dtype': 'int'}), '((num_vars, num_vars), dtype=int)\n', (8810, 8843), True, 'import numpy as np\n'), ((9088, 9115), 'numpy.array', 'np.array', (['[[0, -1], [0, 0]]'], {}), '([[0, -1], [0, 0]])\n', (9096, 9115), True, 'import numpy as np\n')]
|
""" Decision Trees - Supervised learning: 1-Classification*, 2-Regression.
D.T.s are a non-parametric supervised learning method used for classification and regression. The goal is to create a
model that predicts the value of a target variable by learning simple decision rules inferred from the data features.
Some advantages of decision trees are:
1- Simple to understand and to interpret. Trees can be visualised.
2- Requires little data preparation. Other techniques often require data normalisation, dummy variables need to be
created and blank values to be removed. Note however that this module does not support missing values.
3- The cost of using the tree (i.e., predicting data) is logarithmic in the number of data points used to train the tree.
4- Able to handle both numerical and categorical data. Other techniques are usually specialised in analysing datasets
that have only one type of variable. See algorithms for more information.
5- Able to handle multi-output problems.
6- Uses a white box model. If a given situation is observable in a model, the explanation for the condition is easily
explained by boolean logic. By contrast, in a black box model (e.g., in an artificial neural network), results may be
more difficult to interpret.
7- Possible to validate a model using statistical tests. That makes it possible to account for the reliability
of the model.
8- Performs well even if its assumptions are somewhat violated by the true model from which the data were generated.
The disadvantages of decision trees include:
1- Decision-tree learners can create over-complex trees that do not generalise the data well.This is called overfitting.
Mechanisms such as pruning (not currently supported), setting the minimum number of samples required at a leaf node or
setting the maximum depth of the tree are necessary to avoid this problem.
2- Decision trees can be unstable because small variations in the data might result in a completely different tree
being generated. This problem is mitigated by using decision trees within an ensemble.
3- The problem of learning an optimal decision tree is known to be NP-complete under several aspects of optimality and
even for simple concepts. Consequently, practical decision-tree learning algorithms are based on heuristic algorithms
such as the greedy algorithm where locally optimal decisions are made at each node. Such algorithms cannot guarantee to
return the globally optimal decision tree. This can be mitigated by training multiple trees in an ensemble learner,
where the features and samples are randomly sampled with replacement.
4- There are concepts that are hard to learn because decision trees do not express them easily, such as XOR, parity or
multiplexer problems.
5- Decision tree learners create biased trees if some classes dominate. It is therefore recommended to balance the
dataset prior to fitting with the decision tree.
ID3 (Iterative Dichotomiser 3) was developed in 1986 by <NAME>. The algorithm creates a multiway tree, finding
for each node (i.e. in a greedy manner) the categorical feature that will yield the largest information gain for
categorical targets. Trees are grown to their maximum size and then a pruning step is usually applied to improve the
ability of the tree to generalise to unseen data.
C4.5 is the successor to ID3 and removed the restriction that features must be categorical by dynamically defining a
discrete attribute (based on numerical variables) that partitions the continuous attribute value into a discrete set
of intervals. C4.5 converts the trained trees (i.e. the output of the ID3 algorithm) into sets of if-then rules.
These accuracy of each rule is then evaluated to determine the order in which they should be applied.
Pruning is done by removing a rule's precondition if the accuracy of the rule improves without it.
"""
import numpy as np
from sklearn.externals import joblib
from sklearn import datasets, metrics, tree
from sklearn.cross_validation import train_test_split
cancer = datasets.load_breast_cancer()
data = cancer.data
labels = cancer.target
data = np.asarray(data, dtype='float32')
labels = np.asarray(labels, dtype='int32')
trainData, testData, trainLabels, testLabels = train_test_split(data, labels, train_size=0.8, test_size=0.2)
print('Tree Learning... Fitting... ')
tree_clf = tree.DecisionTreeClassifier(criterion='entropy', splitter='best', max_depth=None, min_samples_split=2,
min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_features=None,
random_state=None, max_leaf_nodes=None, class_weight=None, presort=False)
tree_clf.fit(X=trainData, y=trainLabels)
print('Tree Predicting... ')
predicted = tree_clf.predict(X=testData)
print("Results: \n %s" % metrics.classification_report(testLabels, predicted))
matrix = metrics.confusion_matrix(testLabels, predicted)
print("Confusion Matrix: \n %s" % matrix)
print("\nMean Accuracy: %.4f " % tree_clf.score(X=testData, y=testLabels))
print("Tree Saving in ... /Output/Tree_model.pkl")
joblib.dump(tree_clf, '/home/rainer85ah/PycharmProjects/DiagnosticCancerSolution/Output/Tree_model.pkl')
|
[
"sklearn.metrics.classification_report",
"sklearn.tree.DecisionTreeClassifier",
"numpy.asarray",
"sklearn.datasets.load_breast_cancer",
"sklearn.cross_validation.train_test_split",
"sklearn.externals.joblib.dump",
"sklearn.metrics.confusion_matrix"
] |
[((4019, 4048), 'sklearn.datasets.load_breast_cancer', 'datasets.load_breast_cancer', ([], {}), '()\n', (4046, 4048), False, 'from sklearn import datasets, metrics, tree\n'), ((4099, 4132), 'numpy.asarray', 'np.asarray', (['data'], {'dtype': '"""float32"""'}), "(data, dtype='float32')\n", (4109, 4132), True, 'import numpy as np\n'), ((4142, 4175), 'numpy.asarray', 'np.asarray', (['labels'], {'dtype': '"""int32"""'}), "(labels, dtype='int32')\n", (4152, 4175), True, 'import numpy as np\n'), ((4223, 4284), 'sklearn.cross_validation.train_test_split', 'train_test_split', (['data', 'labels'], {'train_size': '(0.8)', 'test_size': '(0.2)'}), '(data, labels, train_size=0.8, test_size=0.2)\n', (4239, 4284), False, 'from sklearn.cross_validation import train_test_split\n'), ((4335, 4593), 'sklearn.tree.DecisionTreeClassifier', 'tree.DecisionTreeClassifier', ([], {'criterion': '"""entropy"""', 'splitter': '"""best"""', 'max_depth': 'None', 'min_samples_split': '(2)', 'min_samples_leaf': '(1)', 'min_weight_fraction_leaf': '(0.0)', 'max_features': 'None', 'random_state': 'None', 'max_leaf_nodes': 'None', 'class_weight': 'None', 'presort': '(False)'}), "(criterion='entropy', splitter='best', max_depth\n =None, min_samples_split=2, min_samples_leaf=1,\n min_weight_fraction_leaf=0.0, max_features=None, random_state=None,\n max_leaf_nodes=None, class_weight=None, presort=False)\n", (4362, 4593), False, 'from sklearn import datasets, metrics, tree\n'), ((4860, 4907), 'sklearn.metrics.confusion_matrix', 'metrics.confusion_matrix', (['testLabels', 'predicted'], {}), '(testLabels, predicted)\n', (4884, 4907), False, 'from sklearn import datasets, metrics, tree\n'), ((5077, 5190), 'sklearn.externals.joblib.dump', 'joblib.dump', (['tree_clf', '"""/home/rainer85ah/PycharmProjects/DiagnosticCancerSolution/Output/Tree_model.pkl"""'], {}), "(tree_clf,\n '/home/rainer85ah/PycharmProjects/DiagnosticCancerSolution/Output/Tree_model.pkl'\n )\n", (5088, 5190), False, 'from sklearn.externals import joblib\n'), ((4797, 4849), 'sklearn.metrics.classification_report', 'metrics.classification_report', (['testLabels', 'predicted'], {}), '(testLabels, predicted)\n', (4826, 4849), False, 'from sklearn import datasets, metrics, tree\n')]
|
"""
.. todo::
WRITEME
"""
import logging
from theano import function, shared
from pylearn2.optimization import linear_cg as cg
from pylearn2.optimization.feature_sign import feature_sign_search
import numpy as N
import theano.tensor as T
from pylearn2.utils.rng import make_np_rng
logger = logging.getLogger(__name__)
class LocalCoordinateCoding(object):
"""
.. todo::
WRITEME
Parameters
----------
nvis : WRITEME
nhid : WRITEME
coeff : WRITEME
"""
def __init__(self, nvis, nhid, coeff):
self.nvis = nvis
self.nhid = nhid
self.coeff = float(coeff)
self.rng = make_np_rng(None, [1, 2, 3], which_method="randn")
self.redo_everything()
def get_output_channels(self):
"""
.. todo::
WRITEME
"""
return self.nhid
def redo_everything(self):
"""
.. todo::
WRITEME
"""
self.W = shared(self.rng.randn(self.nhid, self.nvis), name='W')
self.W.T.name = 'W.T'
def weights_format(self):
"""
.. todo::
WRITEME
"""
return ['h', 'v']
def optimize_gamma(self, example):
"""
.. todo::
WRITEME
"""
#variable names chosen to follow the arguments to l1ls_featuresign
Y = N.zeros((self.nvis,))
Y[:] = example
c = (1e-10 + N.square(self.W.get_value(borrow=True) -
example).sum(axis=1))
A = self.W.get_value(borrow=True).T / c
x = feature_sign_search(A, Y, self.coeff)
g = x / c
return g
def train_batch(self, dataset, batch_size):
"""
.. todo::
WRITEME
"""
#TODO-- this results in compilation happening every time learn is
# called should cache the compilation results, including those
# inside cg
X = dataset.get_design_matrix()
m = X.shape[0]
assert X.shape[1] == self.nvis
gamma = N.zeros((batch_size, self.nhid))
cur_gamma = T.vector(name='cur_gamma')
cur_v = T.vector(name='cur_v')
recons = T.dot(cur_gamma, self.W)
recons.name = 'recons'
recons_diffs = cur_v - recons
recons_diffs.name = 'recons_diffs'
recons_diff_sq = T.sqr(recons_diffs)
recons_diff_sq.name = 'recons_diff'
recons_error = T.sum(recons_diff_sq)
recons_error.name = 'recons_error'
dict_dists = T.sum(T.sqr(self.W - cur_v), axis=1)
dict_dists.name = 'dict_dists'
abs_gamma = abs(cur_gamma)
abs_gamma.name = 'abs_gamma'
weighted_dists = T.dot(abs_gamma, dict_dists)
weighted_dists.name = 'weighted_dists'
penalty = self.coeff * weighted_dists
penalty.name = 'penalty'
#prevent directions of absolute flatness in the hessian
#W_sq = T.sqr(self.W)
#W_sq.name = 'W_sq'
#debug = T.sum(W_sq)
debug = 1e-10 * T.sum(dict_dists)
debug.name = 'debug'
#J = debug
J = recons_error + penalty + debug
J.name = 'J'
Jf = function([cur_v, cur_gamma], J)
start = self.rng.randint(m - batch_size + 1)
batch_X = X[start:start + batch_size, :]
#TODO-- optimize gamma
logger.info('optimizing gamma')
for i in xrange(batch_size):
#print str(i+1)+'/'+str(batch_size)
gamma[i, :] = self.optimize_gamma(batch_X[i, :])
logger.info('max min')
logger.info(N.abs(gamma).min(axis=0).max())
logger.info('min max')
logger.info(N.abs(gamma).max(axis=0).max())
#Optimize W
logger.info('optimizing W')
logger.warning("not tested since switching to Razvan's all-theano "
"implementation of linear cg")
cg.linear_cg(J, [self.W], max_iters=3)
err = 0.
for i in xrange(batch_size):
err += Jf(batch_X[i, :], gamma[i, :])
assert not N.isnan(err)
assert not N.isinf(err)
logger.info('err: {0}'.format(err))
return True
|
[
"logging.getLogger",
"pylearn2.optimization.feature_sign.feature_sign_search",
"pylearn2.utils.rng.make_np_rng",
"pylearn2.optimization.linear_cg.linear_cg",
"numpy.abs",
"theano.function",
"theano.tensor.sum",
"theano.tensor.vector",
"theano.tensor.sqr",
"numpy.zeros",
"numpy.isnan",
"numpy.isinf",
"theano.tensor.dot"
] |
[((297, 324), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (314, 324), False, 'import logging\n'), ((647, 697), 'pylearn2.utils.rng.make_np_rng', 'make_np_rng', (['None', '[1, 2, 3]'], {'which_method': '"""randn"""'}), "(None, [1, 2, 3], which_method='randn')\n", (658, 697), False, 'from pylearn2.utils.rng import make_np_rng\n'), ((1363, 1384), 'numpy.zeros', 'N.zeros', (['(self.nvis,)'], {}), '((self.nvis,))\n', (1370, 1384), True, 'import numpy as N\n'), ((1582, 1619), 'pylearn2.optimization.feature_sign.feature_sign_search', 'feature_sign_search', (['A', 'Y', 'self.coeff'], {}), '(A, Y, self.coeff)\n', (1601, 1619), False, 'from pylearn2.optimization.feature_sign import feature_sign_search\n'), ((2051, 2083), 'numpy.zeros', 'N.zeros', (['(batch_size, self.nhid)'], {}), '((batch_size, self.nhid))\n', (2058, 2083), True, 'import numpy as N\n'), ((2104, 2130), 'theano.tensor.vector', 'T.vector', ([], {'name': '"""cur_gamma"""'}), "(name='cur_gamma')\n", (2112, 2130), True, 'import theano.tensor as T\n'), ((2147, 2169), 'theano.tensor.vector', 'T.vector', ([], {'name': '"""cur_v"""'}), "(name='cur_v')\n", (2155, 2169), True, 'import theano.tensor as T\n'), ((2187, 2211), 'theano.tensor.dot', 'T.dot', (['cur_gamma', 'self.W'], {}), '(cur_gamma, self.W)\n', (2192, 2211), True, 'import theano.tensor as T\n'), ((2351, 2370), 'theano.tensor.sqr', 'T.sqr', (['recons_diffs'], {}), '(recons_diffs)\n', (2356, 2370), True, 'import theano.tensor as T\n'), ((2439, 2460), 'theano.tensor.sum', 'T.sum', (['recons_diff_sq'], {}), '(recons_diff_sq)\n', (2444, 2460), True, 'import theano.tensor as T\n'), ((2701, 2729), 'theano.tensor.dot', 'T.dot', (['abs_gamma', 'dict_dists'], {}), '(abs_gamma, dict_dists)\n', (2706, 2729), True, 'import theano.tensor as T\n'), ((3179, 3210), 'theano.function', 'function', (['[cur_v, cur_gamma]', 'J'], {}), '([cur_v, cur_gamma], J)\n', (3187, 3210), False, 'from theano import function, shared\n'), ((3894, 3932), 'pylearn2.optimization.linear_cg.linear_cg', 'cg.linear_cg', (['J', '[self.W]'], {'max_iters': '(3)'}), '(J, [self.W], max_iters=3)\n', (3906, 3932), True, 'from pylearn2.optimization import linear_cg as cg\n'), ((2532, 2553), 'theano.tensor.sqr', 'T.sqr', (['(self.W - cur_v)'], {}), '(self.W - cur_v)\n', (2537, 2553), True, 'import theano.tensor as T\n'), ((3034, 3051), 'theano.tensor.sum', 'T.sum', (['dict_dists'], {}), '(dict_dists)\n', (3039, 3051), True, 'import theano.tensor as T\n'), ((4058, 4070), 'numpy.isnan', 'N.isnan', (['err'], {}), '(err)\n', (4065, 4070), True, 'import numpy as N\n'), ((4090, 4102), 'numpy.isinf', 'N.isinf', (['err'], {}), '(err)\n', (4097, 4102), True, 'import numpy as N\n'), ((3584, 3596), 'numpy.abs', 'N.abs', (['gamma'], {}), '(gamma)\n', (3589, 3596), True, 'import numpy as N\n'), ((3667, 3679), 'numpy.abs', 'N.abs', (['gamma'], {}), '(gamma)\n', (3672, 3679), True, 'import numpy as N\n')]
|
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import os
import numpy as np
import time
import sys
import functools
import math
import paddle
import paddle.fluid as fluid
import paddle.dataset.flowers as flowers
import models
import reader
import argparse
from models.learning_rate import cosine_decay
from utility import add_arguments, print_arguments
parser = argparse.ArgumentParser(description=__doc__)
add_arg = functools.partial(add_arguments, argparser=parser)
# yapf: disable
add_arg('batch_size', int, 256, "Minibatch size.")
add_arg('use_gpu', bool, True, "Whether to use GPU or not.")
add_arg('total_images', int, 1281167, "Training image number.")
add_arg('num_epochs', int, 120, "number of epochs.")
add_arg('class_dim', int, 1000, "Class number.")
add_arg('image_shape', str, "3,224,224", "input image size")
add_arg('model_save_dir', str, "output", "model save directory")
add_arg('with_mem_opt', bool, True, "Whether to use memory optimization or not.")
add_arg('pretrained_model', str, None, "Whether to use pretrained model.")
add_arg('checkpoint', str, None, "Whether to resume checkpoint.")
add_arg('lr', float, 0.1, "set learning rate.")
add_arg('lr_strategy', str, "piecewise_decay", "Set the learning rate decay strategy.")
add_arg('model', str, "SE_ResNeXt50_32x4d", "Set the network to use.")
add_arg('enable_ce', bool, False, "If set True, enable continuous evaluation job.")
# yapf: enable
model_list = [m for m in dir(models) if "__" not in m]
def optimizer_setting(params):
ls = params["learning_strategy"]
if ls["name"] == "piecewise_decay":
if "total_images" not in params:
total_images = 1281167
else:
total_images = params["total_images"]
batch_size = ls["batch_size"]
step = int(total_images / batch_size + 1)
bd = [step * e for e in ls["epochs"]]
base_lr = params["lr"]
lr = []
lr = [base_lr * (0.1**i) for i in range(len(bd) + 1)]
optimizer = fluid.optimizer.Momentum(
learning_rate=fluid.layers.piecewise_decay(
boundaries=bd, values=lr),
momentum=0.9,
regularization=fluid.regularizer.L2Decay(1e-4))
elif ls["name"] == "cosine_decay":
if "total_images" not in params:
total_images = 1281167
else:
total_images = params["total_images"]
batch_size = ls["batch_size"]
step = int(total_images / batch_size + 1)
lr = params["lr"]
num_epochs = params["num_epochs"]
optimizer = fluid.optimizer.Momentum(
learning_rate=cosine_decay(
learning_rate=lr, step_each_epoch=step, epochs=num_epochs),
momentum=0.9,
regularization=fluid.regularizer.L2Decay(1e-4))
else:
lr = params["lr"]
optimizer = fluid.optimizer.Momentum(
learning_rate=lr,
momentum=0.9,
regularization=fluid.regularizer.L2Decay(1e-4))
return optimizer
def train(args):
# parameters from arguments
class_dim = args.class_dim
model_name = args.model
checkpoint = args.checkpoint
pretrained_model = args.pretrained_model
with_memory_optimization = args.with_mem_opt
model_save_dir = args.model_save_dir
image_shape = [int(m) for m in args.image_shape.split(",")]
assert model_name in model_list, "{} is not in lists: {}".format(args.model,
model_list)
image = fluid.layers.data(name='image', shape=image_shape, dtype='float32')
label = fluid.layers.data(name='label', shape=[1], dtype='int64')
# model definition
model = models.__dict__[model_name]()
if args.enable_ce:
assert model_name == "SE_ResNeXt50_32x4d"
fluid.default_startup_program().random_seed = 1000
model.params["enable_ce"] = True
class_dim = 102
if model_name == "GoogleNet":
out0, out1, out2 = model.net(input=image, class_dim=class_dim)
cost0 = fluid.layers.cross_entropy(input=out0, label=label)
cost1 = fluid.layers.cross_entropy(input=out1, label=label)
cost2 = fluid.layers.cross_entropy(input=out2, label=label)
avg_cost0 = fluid.layers.mean(x=cost0)
avg_cost1 = fluid.layers.mean(x=cost1)
avg_cost2 = fluid.layers.mean(x=cost2)
avg_cost = avg_cost0 + 0.3 * avg_cost1 + 0.3 * avg_cost2
acc_top1 = fluid.layers.accuracy(input=out0, label=label, k=1)
acc_top5 = fluid.layers.accuracy(input=out0, label=label, k=5)
else:
out = model.net(input=image, class_dim=class_dim)
cost = fluid.layers.cross_entropy(input=out, label=label)
avg_cost = fluid.layers.mean(x=cost)
acc_top1 = fluid.layers.accuracy(input=out, label=label, k=1)
acc_top5 = fluid.layers.accuracy(input=out, label=label, k=5)
test_program = fluid.default_main_program().clone(for_test=True)
# parameters from model and arguments
params = model.params
params["total_images"] = args.total_images
params["lr"] = args.lr
params["num_epochs"] = args.num_epochs
params["learning_strategy"]["batch_size"] = args.batch_size
params["learning_strategy"]["name"] = args.lr_strategy
# initialize optimizer
optimizer = optimizer_setting(params)
opts = optimizer.minimize(avg_cost)
if with_memory_optimization:
fluid.memory_optimize(fluid.default_main_program())
place = fluid.CUDAPlace(0) if args.use_gpu else fluid.CPUPlace()
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())
if checkpoint is not None:
fluid.io.load_persistables(exe, checkpoint)
if pretrained_model:
def if_exist(var):
return os.path.exists(os.path.join(pretrained_model, var.name))
fluid.io.load_vars(exe, pretrained_model, predicate=if_exist)
train_batch_size = args.batch_size
test_batch_size = 16
if not args.enable_ce:
train_reader = paddle.batch(reader.train(), batch_size=train_batch_size)
test_reader = paddle.batch(reader.val(), batch_size=test_batch_size)
else:
# use flowers dataset for CE and set use_xmap False to avoid disorder data
# but it is time consuming. For faster speed, need another dataset.
import random
random.seed(0)
np.random.seed(0)
train_reader = paddle.batch(
flowers.train(use_xmap=False), batch_size=train_batch_size)
test_reader = paddle.batch(
flowers.test(use_xmap=False), batch_size=test_batch_size)
feeder = fluid.DataFeeder(place=place, feed_list=[image, label])
train_exe = fluid.ParallelExecutor(
use_cuda=True if args.use_gpu else False, loss_name=avg_cost.name)
fetch_list = [avg_cost.name, acc_top1.name, acc_top5.name]
gpu = os.getenv("CUDA_VISIBLE_DEVICES") or ""
gpu_nums = len(gpu.split(","))
for pass_id in range(params["num_epochs"]):
train_info = [[], [], []]
test_info = [[], [], []]
train_time = []
for batch_id, data in enumerate(train_reader()):
t1 = time.time()
loss, acc1, acc5 = train_exe.run(fetch_list, feed=feeder.feed(data))
t2 = time.time()
period = t2 - t1
loss = np.mean(np.array(loss))
acc1 = np.mean(np.array(acc1))
acc5 = np.mean(np.array(acc5))
train_info[0].append(loss)
train_info[1].append(acc1)
train_info[2].append(acc5)
train_time.append(period)
if batch_id % 10 == 0:
print("Pass {0}, trainbatch {1}, loss {2}, \
acc1 {3}, acc5 {4} time {5}"
.format(pass_id, \
batch_id, loss, acc1, acc5, \
"%2.2f sec" % period))
sys.stdout.flush()
train_loss = np.array(train_info[0]).mean()
train_acc1 = np.array(train_info[1]).mean()
train_acc5 = np.array(train_info[2]).mean()
train_speed = np.array(train_time).mean() / train_batch_size
cnt = 0
for test_batch_id, data in enumerate(test_reader()):
t1 = time.time()
loss, acc1, acc5 = exe.run(test_program,
fetch_list=fetch_list,
feed=feeder.feed(data))
t2 = time.time()
period = t2 - t1
loss = np.mean(loss)
acc1 = np.mean(acc1)
acc5 = np.mean(acc5)
test_info[0].append(loss * len(data))
test_info[1].append(acc1 * len(data))
test_info[2].append(acc5 * len(data))
cnt += len(data)
if test_batch_id % 10 == 0:
print("Pass {0},testbatch {1},loss {2}, \
acc1 {3},acc5 {4},time {5}"
.format(pass_id, \
test_batch_id, loss, acc1, acc5, \
"%2.2f sec" % period))
sys.stdout.flush()
test_loss = np.sum(test_info[0]) / cnt
test_acc1 = np.sum(test_info[1]) / cnt
test_acc5 = np.sum(test_info[2]) / cnt
print("End pass {0}, train_loss {1}, train_acc1 {2}, train_acc5 {3}, "
"test_loss {4}, test_acc1 {5}, test_acc5 {6}".format(pass_id, \
train_loss, train_acc1, train_acc5, test_loss, test_acc1, \
test_acc5))
sys.stdout.flush()
model_path = os.path.join(model_save_dir + '/' + model_name,
str(pass_id))
if not os.path.isdir(model_path):
os.makedirs(model_path)
fluid.io.save_persistables(exe, model_path)
# This is for continuous evaluation only
if args.enable_ce and pass_id == args.num_epochs - 1:
if gpu_nums == 1:
# Use the mean cost/acc for training
print("kpis train_cost %s" % train_loss)
print("kpis train_acc_top1 %s" % train_acc1)
print("kpis train_acc_top5 %s" % train_acc5)
# Use the mean cost/acc for testing
print("kpis test_cost %s" % test_loss)
print("kpis test_acc_top1 %s" % test_acc1)
print("kpis test_acc_top5 %s" % test_acc5)
print("kpis train_speed %s" % train_speed)
else:
# Use the mean cost/acc for training
print("kpis train_cost_card%s %s" %
(gpu_nums, train_loss))
print("kpis train_acc_top1_card%s %s" %
(gpu_nums, train_acc1))
print("kpis train_acc_top5_card%s %s" %
(gpu_nums, train_acc5))
# Use the mean cost/acc for testing
print("kpis test_cost_card%s %s" %
(gpu_nums, test_loss))
print("kpis test_acc_top1_card%s %s" %
(gpu_nums, test_acc1))
print("kpis test_acc_top5_card%s %s" %
(gpu_nums, test_acc5))
print("kpis train_speed_card%s %s" %
(gpu_nums, train_speed))
def main():
args = parser.parse_args()
print_arguments(args)
train(args)
if __name__ == '__main__':
main()
|
[
"paddle.fluid.DataFeeder",
"paddle.dataset.flowers.test",
"paddle.fluid.layers.data",
"paddle.fluid.layers.cross_entropy",
"numpy.array",
"paddle.fluid.Executor",
"paddle.dataset.flowers.train",
"paddle.fluid.layers.piecewise_decay",
"reader.train",
"numpy.mean",
"argparse.ArgumentParser",
"paddle.fluid.default_startup_program",
"paddle.fluid.layers.mean",
"paddle.fluid.default_main_program",
"os.path.isdir",
"paddle.fluid.io.load_vars",
"numpy.random.seed",
"sys.stdout.flush",
"models.learning_rate.cosine_decay",
"paddle.fluid.io.save_persistables",
"paddle.fluid.io.load_persistables",
"paddle.fluid.CPUPlace",
"time.time",
"reader.val",
"os.getenv",
"os.makedirs",
"paddle.fluid.layers.accuracy",
"os.path.join",
"random.seed",
"numpy.sum",
"paddle.fluid.regularizer.L2Decay",
"functools.partial",
"paddle.fluid.CUDAPlace",
"paddle.fluid.ParallelExecutor",
"utility.print_arguments"
] |
[((425, 469), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '__doc__'}), '(description=__doc__)\n', (448, 469), False, 'import argparse\n'), ((480, 530), 'functools.partial', 'functools.partial', (['add_arguments'], {'argparser': 'parser'}), '(add_arguments, argparser=parser)\n', (497, 530), False, 'import functools\n'), ((3879, 3946), 'paddle.fluid.layers.data', 'fluid.layers.data', ([], {'name': '"""image"""', 'shape': 'image_shape', 'dtype': '"""float32"""'}), "(name='image', shape=image_shape, dtype='float32')\n", (3896, 3946), True, 'import paddle.fluid as fluid\n'), ((3959, 4016), 'paddle.fluid.layers.data', 'fluid.layers.data', ([], {'name': '"""label"""', 'shape': '[1]', 'dtype': '"""int64"""'}), "(name='label', shape=[1], dtype='int64')\n", (3976, 4016), True, 'import paddle.fluid as fluid\n'), ((5923, 5944), 'paddle.fluid.Executor', 'fluid.Executor', (['place'], {}), '(place)\n', (5937, 5944), True, 'import paddle.fluid as fluid\n'), ((6995, 7050), 'paddle.fluid.DataFeeder', 'fluid.DataFeeder', ([], {'place': 'place', 'feed_list': '[image, label]'}), '(place=place, feed_list=[image, label])\n', (7011, 7050), True, 'import paddle.fluid as fluid\n'), ((7068, 7162), 'paddle.fluid.ParallelExecutor', 'fluid.ParallelExecutor', ([], {'use_cuda': '(True if args.use_gpu else False)', 'loss_name': 'avg_cost.name'}), '(use_cuda=True if args.use_gpu else False, loss_name=\n avg_cost.name)\n', (7090, 7162), True, 'import paddle.fluid as fluid\n'), ((11723, 11744), 'utility.print_arguments', 'print_arguments', (['args'], {}), '(args)\n', (11738, 11744), False, 'from utility import add_arguments, print_arguments\n'), ((4403, 4454), 'paddle.fluid.layers.cross_entropy', 'fluid.layers.cross_entropy', ([], {'input': 'out0', 'label': 'label'}), '(input=out0, label=label)\n', (4429, 4454), True, 'import paddle.fluid as fluid\n'), ((4471, 4522), 'paddle.fluid.layers.cross_entropy', 'fluid.layers.cross_entropy', ([], {'input': 'out1', 'label': 'label'}), '(input=out1, label=label)\n', (4497, 4522), True, 'import paddle.fluid as fluid\n'), ((4539, 4590), 'paddle.fluid.layers.cross_entropy', 'fluid.layers.cross_entropy', ([], {'input': 'out2', 'label': 'label'}), '(input=out2, label=label)\n', (4565, 4590), True, 'import paddle.fluid as fluid\n'), ((4611, 4637), 'paddle.fluid.layers.mean', 'fluid.layers.mean', ([], {'x': 'cost0'}), '(x=cost0)\n', (4628, 4637), True, 'import paddle.fluid as fluid\n'), ((4658, 4684), 'paddle.fluid.layers.mean', 'fluid.layers.mean', ([], {'x': 'cost1'}), '(x=cost1)\n', (4675, 4684), True, 'import paddle.fluid as fluid\n'), ((4705, 4731), 'paddle.fluid.layers.mean', 'fluid.layers.mean', ([], {'x': 'cost2'}), '(x=cost2)\n', (4722, 4731), True, 'import paddle.fluid as fluid\n'), ((4817, 4868), 'paddle.fluid.layers.accuracy', 'fluid.layers.accuracy', ([], {'input': 'out0', 'label': 'label', 'k': '(1)'}), '(input=out0, label=label, k=1)\n', (4838, 4868), True, 'import paddle.fluid as fluid\n'), ((4888, 4939), 'paddle.fluid.layers.accuracy', 'fluid.layers.accuracy', ([], {'input': 'out0', 'label': 'label', 'k': '(5)'}), '(input=out0, label=label, k=5)\n', (4909, 4939), True, 'import paddle.fluid as fluid\n'), ((5023, 5073), 'paddle.fluid.layers.cross_entropy', 'fluid.layers.cross_entropy', ([], {'input': 'out', 'label': 'label'}), '(input=out, label=label)\n', (5049, 5073), True, 'import paddle.fluid as fluid\n'), ((5094, 5119), 'paddle.fluid.layers.mean', 'fluid.layers.mean', ([], {'x': 'cost'}), '(x=cost)\n', (5111, 5119), True, 'import paddle.fluid as fluid\n'), ((5139, 5189), 'paddle.fluid.layers.accuracy', 'fluid.layers.accuracy', ([], {'input': 'out', 'label': 'label', 'k': '(1)'}), '(input=out, label=label, k=1)\n', (5160, 5189), True, 'import paddle.fluid as fluid\n'), ((5209, 5259), 'paddle.fluid.layers.accuracy', 'fluid.layers.accuracy', ([], {'input': 'out', 'label': 'label', 'k': '(5)'}), '(input=out, label=label, k=5)\n', (5230, 5259), True, 'import paddle.fluid as fluid\n'), ((5856, 5874), 'paddle.fluid.CUDAPlace', 'fluid.CUDAPlace', (['(0)'], {}), '(0)\n', (5871, 5874), True, 'import paddle.fluid as fluid\n'), ((5896, 5912), 'paddle.fluid.CPUPlace', 'fluid.CPUPlace', ([], {}), '()\n', (5910, 5912), True, 'import paddle.fluid as fluid\n'), ((5957, 5988), 'paddle.fluid.default_startup_program', 'fluid.default_startup_program', ([], {}), '()\n', (5986, 5988), True, 'import paddle.fluid as fluid\n'), ((6030, 6073), 'paddle.fluid.io.load_persistables', 'fluid.io.load_persistables', (['exe', 'checkpoint'], {}), '(exe, checkpoint)\n', (6056, 6073), True, 'import paddle.fluid as fluid\n'), ((6213, 6274), 'paddle.fluid.io.load_vars', 'fluid.io.load_vars', (['exe', 'pretrained_model'], {'predicate': 'if_exist'}), '(exe, pretrained_model, predicate=if_exist)\n', (6231, 6274), True, 'import paddle.fluid as fluid\n'), ((6725, 6739), 'random.seed', 'random.seed', (['(0)'], {}), '(0)\n', (6736, 6739), False, 'import random\n'), ((6748, 6765), 'numpy.random.seed', 'np.random.seed', (['(0)'], {}), '(0)\n', (6762, 6765), True, 'import numpy as np\n'), ((7242, 7275), 'os.getenv', 'os.getenv', (['"""CUDA_VISIBLE_DEVICES"""'], {}), "('CUDA_VISIBLE_DEVICES')\n", (7251, 7275), False, 'import os\n'), ((9928, 9946), 'sys.stdout.flush', 'sys.stdout.flush', ([], {}), '()\n', (9944, 9946), False, 'import sys\n'), ((10151, 10194), 'paddle.fluid.io.save_persistables', 'fluid.io.save_persistables', (['exe', 'model_path'], {}), '(exe, model_path)\n', (10177, 10194), True, 'import paddle.fluid as fluid\n'), ((4165, 4196), 'paddle.fluid.default_startup_program', 'fluid.default_startup_program', ([], {}), '()\n', (4194, 4196), True, 'import paddle.fluid as fluid\n'), ((5280, 5308), 'paddle.fluid.default_main_program', 'fluid.default_main_program', ([], {}), '()\n', (5306, 5308), True, 'import paddle.fluid as fluid\n'), ((5813, 5841), 'paddle.fluid.default_main_program', 'fluid.default_main_program', ([], {}), '()\n', (5839, 5841), True, 'import paddle.fluid as fluid\n'), ((6404, 6418), 'reader.train', 'reader.train', ([], {}), '()\n', (6416, 6418), False, 'import reader\n'), ((6484, 6496), 'reader.val', 'reader.val', ([], {}), '()\n', (6494, 6496), False, 'import reader\n'), ((6815, 6844), 'paddle.dataset.flowers.train', 'flowers.train', ([], {'use_xmap': '(False)'}), '(use_xmap=False)\n', (6828, 6844), True, 'import paddle.dataset.flowers as flowers\n'), ((6923, 6951), 'paddle.dataset.flowers.test', 'flowers.test', ([], {'use_xmap': '(False)'}), '(use_xmap=False)\n', (6935, 6951), True, 'import paddle.dataset.flowers as flowers\n'), ((7530, 7541), 'time.time', 'time.time', ([], {}), '()\n', (7539, 7541), False, 'import time\n'), ((7640, 7651), 'time.time', 'time.time', ([], {}), '()\n', (7649, 7651), False, 'import time\n'), ((8637, 8648), 'time.time', 'time.time', ([], {}), '()\n', (8646, 8648), False, 'import time\n'), ((8844, 8855), 'time.time', 'time.time', ([], {}), '()\n', (8853, 8855), False, 'import time\n'), ((8904, 8917), 'numpy.mean', 'np.mean', (['loss'], {}), '(loss)\n', (8911, 8917), True, 'import numpy as np\n'), ((8937, 8950), 'numpy.mean', 'np.mean', (['acc1'], {}), '(acc1)\n', (8944, 8950), True, 'import numpy as np\n'), ((8970, 8983), 'numpy.mean', 'np.mean', (['acc5'], {}), '(acc5)\n', (8977, 8983), True, 'import numpy as np\n'), ((9541, 9561), 'numpy.sum', 'np.sum', (['test_info[0]'], {}), '(test_info[0])\n', (9547, 9561), True, 'import numpy as np\n'), ((9588, 9608), 'numpy.sum', 'np.sum', (['test_info[1]'], {}), '(test_info[1])\n', (9594, 9608), True, 'import numpy as np\n'), ((9635, 9655), 'numpy.sum', 'np.sum', (['test_info[2]'], {}), '(test_info[2])\n', (9641, 9655), True, 'import numpy as np\n'), ((10080, 10105), 'os.path.isdir', 'os.path.isdir', (['model_path'], {}), '(model_path)\n', (10093, 10105), False, 'import os\n'), ((10119, 10142), 'os.makedirs', 'os.makedirs', (['model_path'], {}), '(model_path)\n', (10130, 10142), False, 'import os\n'), ((2396, 2450), 'paddle.fluid.layers.piecewise_decay', 'fluid.layers.piecewise_decay', ([], {'boundaries': 'bd', 'values': 'lr'}), '(boundaries=bd, values=lr)\n', (2424, 2450), True, 'import paddle.fluid as fluid\n'), ((2522, 2555), 'paddle.fluid.regularizer.L2Decay', 'fluid.regularizer.L2Decay', (['(0.0001)'], {}), '(0.0001)\n', (2547, 2555), True, 'import paddle.fluid as fluid\n'), ((6162, 6202), 'os.path.join', 'os.path.join', (['pretrained_model', 'var.name'], {}), '(pretrained_model, var.name)\n', (6174, 6202), False, 'import os\n'), ((7708, 7722), 'numpy.array', 'np.array', (['loss'], {}), '(loss)\n', (7716, 7722), True, 'import numpy as np\n'), ((7751, 7765), 'numpy.array', 'np.array', (['acc1'], {}), '(acc1)\n', (7759, 7765), True, 'import numpy as np\n'), ((7794, 7808), 'numpy.array', 'np.array', (['acc5'], {}), '(acc5)\n', (7802, 7808), True, 'import numpy as np\n'), ((8298, 8316), 'sys.stdout.flush', 'sys.stdout.flush', ([], {}), '()\n', (8314, 8316), False, 'import sys\n'), ((8339, 8362), 'numpy.array', 'np.array', (['train_info[0]'], {}), '(train_info[0])\n', (8347, 8362), True, 'import numpy as np\n'), ((8391, 8414), 'numpy.array', 'np.array', (['train_info[1]'], {}), '(train_info[1])\n', (8399, 8414), True, 'import numpy as np\n'), ((8443, 8466), 'numpy.array', 'np.array', (['train_info[2]'], {}), '(train_info[2])\n', (8451, 8466), True, 'import numpy as np\n'), ((9501, 9519), 'sys.stdout.flush', 'sys.stdout.flush', ([], {}), '()\n', (9517, 9519), False, 'import sys\n'), ((2965, 3036), 'models.learning_rate.cosine_decay', 'cosine_decay', ([], {'learning_rate': 'lr', 'step_each_epoch': 'step', 'epochs': 'num_epochs'}), '(learning_rate=lr, step_each_epoch=step, epochs=num_epochs)\n', (2977, 3036), False, 'from models.learning_rate import cosine_decay\n'), ((3108, 3141), 'paddle.fluid.regularizer.L2Decay', 'fluid.regularizer.L2Decay', (['(0.0001)'], {}), '(0.0001)\n', (3133, 3141), True, 'import paddle.fluid as fluid\n'), ((3306, 3339), 'paddle.fluid.regularizer.L2Decay', 'fluid.regularizer.L2Decay', (['(0.0001)'], {}), '(0.0001)\n', (3331, 3339), True, 'import paddle.fluid as fluid\n'), ((8496, 8516), 'numpy.array', 'np.array', (['train_time'], {}), '(train_time)\n', (8504, 8516), True, 'import numpy as np\n')]
|
from __future__ import print_function
import os
import base64
import cStringIO
import time
import numpy
from PIL import Image
from flask import (Flask, request, render_template, url_for, flash, redirect,
send_file)
from SeamErasure import seam_erasure, obj_reader, util
from SeamErasure.lib import weight_data
app = Flask(__name__)
ALLOWED_EXTENSIONS = set(['png', 'tga', 'jpg', 'jpeg', 'gif', 'tif', 'tiff'])
def allowed_file(filename):
return ('.' in filename and filename.rsplit('.', 1)[1].lower() in
ALLOWED_EXTENSIONS)
def is_data_file(filename):
return "data" in request.form or ('.' in filename and
filename.rsplit('.', 1)[1].lower() == "data")
def upload_file(fileID):
""" Returns the uploaded file with fileID. None if no file uploaded. """
if request.method == 'POST':
if fileID not in request.files:
return None
else:
inFile = request.files[fileID]
if inFile.filename == '':
return None
elif inFile: # and allowed_file(file.filename)
return inFile
else:
return None
@app.route('/')
def index():
return render_template('min-form.html')
@app.route('/erased', methods=['GET', 'POST'])
def erase():
if request.method == 'POST':
try:
startTime = time.time()
# Check the uploaded files
obj_file = upload_file("obj-input")
if not obj_file or ('.' in obj_file.filename and
obj_file.filename.rsplit('.', 1)[1].lower() != "obj"):
return render_template('min-error.html',
error_msg="No OBJ model provided.")
tex_file = upload_file("tex-input")
if not tex_file:
return render_template('min-error.html',
error_msg="No texture image provided.")
mesh = obj_reader.quads_to_triangles(
obj_reader.parse_obj(obj_file))
isFloatTexture = isDataFile = False
if(is_data_file(tex_file.filename)):
textureData = weight_data.read_tex_from_file(tex_file)[0]
isFloatTexture, isDataFile = True, True
else:
textureData = numpy.array(Image.open(tex_file).transpose(
Image.FLIP_TOP_BOTTOM))
isFloatTexture = not issubclass(textureData.dtype.type,
numpy.integer)
if(not isFloatTexture):
textureData = textureData / 255.0
height, width, depth = (textureData.shape + (1,))[:3]
sv_methods = {"none": seam_erasure.SeamValueMethod.NONE,
"texture": seam_erasure.SeamValueMethod.TEXTURE,
"lerp": seam_erasure.SeamValueMethod.LERP}
sv_method = sv_methods[request.form["sv"]]
do_global = "global" in request.form
out = seam_erasure.erase_seam(mesh, textureData,
do_global=do_global, sv_method=sv_method,
display_energy_file=None)
out = out.reshape((height, width, -1))
if(out.shape[2] < 2):
out = numpy.squeeze(out, axis=2)
if(not isFloatTexture):
out = util.to_uint8(out)
base, ext = os.path.splitext(os.path.basename(tex_file.filename))
out_filename = base + "-erased" + ext
if isDataFile:
img_io = cStringIO.StringIO()
weight_data.write_tex_to_file(img_io, textureData)
img_io.seek(0)
return send_file(img_io, as_attachment=True,
attachment_filename=out_filename)
else:
texture = Image.fromarray(out).transpose(Image.FLIP_TOP_BOTTOM)
img_io = cStringIO.StringIO()
texture.save(img_io, format=Image.EXTENSION[ext])
img_io.seek(0)
if isFloatTexture:
return send_file(img_io, as_attachment=True,
attachment_filename=out_filename)
data_uri = base64.b64encode(img_io.getvalue())
try:
return render_template('min-results.html',
min_tex=data_uri, runtime=("%.2f" %
(time.time() - startTime)),
mime_type=Image.MIME[Image.EXTENSION[ext]])
except Exception:
return send_file(img_io, as_attachment=True,
attachment_filename=out_filename)
except Exception as e:
return render_template('min-error.html',
error_msg=("Unable to erase the texture (%s)." % e.message))
return render_template('min-form.html')
if __name__ == '__main__':
app.run(debug=True)
|
[
"flask.render_template",
"PIL.Image.fromarray",
"cStringIO.StringIO",
"SeamErasure.obj_reader.parse_obj",
"SeamErasure.lib.weight_data.write_tex_to_file",
"PIL.Image.open",
"flask.Flask",
"SeamErasure.lib.weight_data.read_tex_from_file",
"SeamErasure.seam_erasure.erase_seam",
"numpy.squeeze",
"os.path.basename",
"SeamErasure.util.to_uint8",
"flask.send_file",
"time.time"
] |
[((326, 341), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (331, 341), False, 'from flask import Flask, request, render_template, url_for, flash, redirect, send_file\n'), ((1175, 1207), 'flask.render_template', 'render_template', (['"""min-form.html"""'], {}), "('min-form.html')\n", (1190, 1207), False, 'from flask import Flask, request, render_template, url_for, flash, redirect, send_file\n'), ((4759, 4791), 'flask.render_template', 'render_template', (['"""min-form.html"""'], {}), "('min-form.html')\n", (4774, 4791), False, 'from flask import Flask, request, render_template, url_for, flash, redirect, send_file\n'), ((1340, 1351), 'time.time', 'time.time', ([], {}), '()\n', (1349, 1351), False, 'import time\n'), ((2931, 3046), 'SeamErasure.seam_erasure.erase_seam', 'seam_erasure.erase_seam', (['mesh', 'textureData'], {'do_global': 'do_global', 'sv_method': 'sv_method', 'display_energy_file': 'None'}), '(mesh, textureData, do_global=do_global, sv_method=\n sv_method, display_energy_file=None)\n', (2954, 3046), False, 'from SeamErasure import seam_erasure, obj_reader, util\n'), ((1598, 1667), 'flask.render_template', 'render_template', (['"""min-error.html"""'], {'error_msg': '"""No OBJ model provided."""'}), "('min-error.html', error_msg='No OBJ model provided.')\n", (1613, 1667), False, 'from flask import Flask, request, render_template, url_for, flash, redirect, send_file\n'), ((1789, 1862), 'flask.render_template', 'render_template', (['"""min-error.html"""'], {'error_msg': '"""No texture image provided."""'}), "('min-error.html', error_msg='No texture image provided.')\n", (1804, 1862), False, 'from flask import Flask, request, render_template, url_for, flash, redirect, send_file\n'), ((1950, 1980), 'SeamErasure.obj_reader.parse_obj', 'obj_reader.parse_obj', (['obj_file'], {}), '(obj_file)\n', (1970, 1980), False, 'from SeamErasure import seam_erasure, obj_reader, util\n'), ((3182, 3208), 'numpy.squeeze', 'numpy.squeeze', (['out'], {'axis': '(2)'}), '(out, axis=2)\n', (3195, 3208), False, 'import numpy\n'), ((3267, 3285), 'SeamErasure.util.to_uint8', 'util.to_uint8', (['out'], {}), '(out)\n', (3280, 3285), False, 'from SeamErasure import seam_erasure, obj_reader, util\n'), ((3328, 3363), 'os.path.basename', 'os.path.basename', (['tex_file.filename'], {}), '(tex_file.filename)\n', (3344, 3363), False, 'import os\n'), ((3467, 3487), 'cStringIO.StringIO', 'cStringIO.StringIO', ([], {}), '()\n', (3485, 3487), False, 'import cStringIO\n'), ((3504, 3554), 'SeamErasure.lib.weight_data.write_tex_to_file', 'weight_data.write_tex_to_file', (['img_io', 'textureData'], {}), '(img_io, textureData)\n', (3533, 3554), False, 'from SeamErasure.lib import weight_data\n'), ((3610, 3681), 'flask.send_file', 'send_file', (['img_io'], {'as_attachment': '(True)', 'attachment_filename': 'out_filename'}), '(img_io, as_attachment=True, attachment_filename=out_filename)\n', (3619, 3681), False, 'from flask import Flask, request, render_template, url_for, flash, redirect, send_file\n'), ((3825, 3845), 'cStringIO.StringIO', 'cStringIO.StringIO', ([], {}), '()\n', (3843, 3845), False, 'import cStringIO\n'), ((4637, 4734), 'flask.render_template', 'render_template', (['"""min-error.html"""'], {'error_msg': "('Unable to erase the texture (%s).' % e.message)"}), "('min-error.html', error_msg=\n 'Unable to erase the texture (%s).' % e.message)\n", (4652, 4734), False, 'from flask import Flask, request, render_template, url_for, flash, redirect, send_file\n'), ((2110, 2150), 'SeamErasure.lib.weight_data.read_tex_from_file', 'weight_data.read_tex_from_file', (['tex_file'], {}), '(tex_file)\n', (2140, 2150), False, 'from SeamErasure.lib import weight_data\n'), ((4006, 4077), 'flask.send_file', 'send_file', (['img_io'], {'as_attachment': '(True)', 'attachment_filename': 'out_filename'}), '(img_io, as_attachment=True, attachment_filename=out_filename)\n', (4015, 4077), False, 'from flask import Flask, request, render_template, url_for, flash, redirect, send_file\n'), ((3746, 3766), 'PIL.Image.fromarray', 'Image.fromarray', (['out'], {}), '(out)\n', (3761, 3766), False, 'from PIL import Image\n'), ((4491, 4562), 'flask.send_file', 'send_file', (['img_io'], {'as_attachment': '(True)', 'attachment_filename': 'out_filename'}), '(img_io, as_attachment=True, attachment_filename=out_filename)\n', (4500, 4562), False, 'from flask import Flask, request, render_template, url_for, flash, redirect, send_file\n'), ((2270, 2290), 'PIL.Image.open', 'Image.open', (['tex_file'], {}), '(tex_file)\n', (2280, 2290), False, 'from PIL import Image\n'), ((4335, 4346), 'time.time', 'time.time', ([], {}), '()\n', (4344, 4346), False, 'import time\n')]
|
# Copyright 2018 <NAME>. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""
DDPG implementation in Tensorflow Eager Execution
"""
import numpy as np
import tensorflow as tf
from utils import PytorchInitializer
layers = tf.keras.layers
regularizers = tf.keras.regularizers
losses = tf.keras.losses
class Actor(tf.keras.Model):
def __init__(self, state_dim, action_dim, max_action, name="Actor"):
super().__init__(name=name)
self.l1 = layers.Dense(400, kernel_initializer=PytorchInitializer(),
name="L1")
self.l2 = layers.Dense(300, kernel_initializer=PytorchInitializer(),
name="L2")
self.l3 = layers.Dense(action_dim, kernel_initializer=PytorchInitializer(),
name="L3")
self.max_action = max_action
# 後段の処理のために早めにshapeを確定させる
dummy_state = tf.constant(np.zeros(shape=[1, state_dim], dtype=np.float32))
self(dummy_state)
def call(self, inputs):
with tf.device("/gpu:0"):
features = tf.nn.relu(self.l1(inputs))
features = tf.nn.relu(self.l2(features))
features = self.l3(features)
action = self.max_action * tf.nn.tanh(features)
return action
class Critic(tf.keras.Model):
def __init__(self, state_dim, action_dim, wd=1e-2, name="Critic"):
super().__init__(name=name)
self.l1 = layers.Dense(400, kernel_initializer=PytorchInitializer(),
kernel_regularizer=regularizers.l2(wd), bias_regularizer=regularizers.l2(wd),
name="L1")
self.l2 = layers.Dense(300, kernel_initializer=PytorchInitializer(),
kernel_regularizer=regularizers.l2(wd), bias_regularizer=regularizers.l2(wd),
name="L2")
self.l3 = layers.Dense(1, kernel_initializer=PytorchInitializer(),
kernel_regularizer=regularizers.l2(wd), bias_regularizer=regularizers.l2(wd),
name="L3")
dummy_state = tf.constant(np.zeros(shape=[1, state_dim], dtype=np.float32))
dummy_action = tf.constant(np.zeros(shape=[1, action_dim], dtype=np.float32))
self([dummy_state, dummy_action])
def call(self, inputs):
with tf.device("/gpu:0"):
x, u = inputs
x = tf.nn.relu(self.l1(x))
inner_feat = tf.concat([x, u], axis=1)
x = tf.nn.relu(self.l2(inner_feat))
x = self.l3(x)
return x
class DDPG(tf.contrib.checkpoint.Checkpointable):
def __init__(self, state_dim, action_dim, max_action):
self.actor = Actor(state_dim, action_dim, max_action)
self.actor_target = Actor(state_dim, action_dim, max_action)
# initialize target network
for param, target_param in zip(self.actor.weights, self.actor_target.weights):
target_param.assign(param)
self.actor_optimizer = tf.train.AdamOptimizer(learning_rate=1e-4)
self.critic = Critic(state_dim, action_dim)
self.critic_target = Critic(state_dim, action_dim)
# initialize target network
for param, target_param in zip(self.critic.weights, self.critic_target.weights):
target_param.assign(param)
self.critic_optimizer = tf.train.AdamOptimizer(learning_rate=1e-3)
def select_action(self, state):
"""
:param np.ndarray state:
:return:
"""
assert isinstance(state, np.ndarray)
assert len(state.shape) == 1
state = np.expand_dims(state, axis=0).astype(np.float32)
action = self.actor(state).numpy()
return action[0]
def train(self, replay_buffer, iterations, batch_size=64, discount=0.99, tau=0.001):
for it in range(iterations):
state, next_state, action, reward, done = replay_buffer.sample(batch_size)
state = np.array(state, dtype=np.float32)
next_state = np.array(next_state, dtype=np.float32)
action = np.array(action, dtype=np.float32)
reward = np.array(reward, dtype=np.float32)
done = np.array(done, dtype=np.float32)
not_done = 1 - done
with tf.device("/gpu:0"):
with tf.GradientTape() as tape:
target_Q = self.critic_target([next_state, self.actor_target(next_state)])
target_Q = reward + (not_done * discount * target_Q)
# detach => stop_gradient
target_Q = tf.stop_gradient(target_Q)
current_Q = self.critic([state, action])
# Compute critic loss + L2 loss
critic_loss = tf.reduce_mean(losses.MSE(current_Q, target_Q)) + 0.5*tf.add_n(self.critic.losses)
critic_grad = tape.gradient(critic_loss, self.critic.trainable_variables)
self.critic_optimizer.apply_gradients(zip(critic_grad, self.critic.trainable_variables))
with tf.GradientTape() as tape:
next_action = self.actor(state)
actor_loss = -tf.reduce_mean(self.critic([state, next_action]))
actor_grad = tape.gradient(actor_loss, self.actor.trainable_variables)
self.actor_optimizer.apply_gradients(zip(actor_grad, self.actor.trainable_variables))
# Update target networks
for param, target_param in zip(self.critic.weights, self.critic_target.weights):
target_param.assign(tau * param + (1 - tau) * target_param)
for param, target_param in zip(self.actor.weights, self.actor_target.weights):
target_param.assign(tau * param + (1 - tau) * target_param)
class DDPG_fast(tf.contrib.checkpoint.Checkpointable):
def __init__(self, state_dim, action_dim, max_action):
self.actor = Actor(state_dim, action_dim, max_action)
self.actor_target = Actor(state_dim, action_dim, max_action)
self.actor_optimizer = tf.train.AdamOptimizer(learning_rate=1e-4)
# initialize target network
for param, target_param in zip(self.actor.weights, self.actor_target.weights):
target_param.assign(param)
self.critic = Critic(state_dim, action_dim)
self.critic_target = Critic(state_dim, action_dim)
self.critic_optimizer = tf.train.AdamOptimizer(learning_rate=1e-3)
# initialize target network
for param, target_param in zip(self.critic.weights, self.critic_target.weights):
target_param.assign(param)
def select_action(self, state):
"""
:param np.ndarray state:
:return:
"""
assert isinstance(state, np.ndarray)
assert len(state.shape) == 1
state = np.expand_dims(state, axis=0).astype(np.float32)
action = self._select_action_body(tf.constant(state))
return action.numpy()[0]
@tf.contrib.eager.defun
def _select_action_body(self, state):
"""
:param np.ndarray state:
:return:
"""
action = self.actor(state)
return action
def train(self, replay_buffer, iterations, batch_size=64, discount=0.99, tau=0.001):
for it in range(iterations):
state, next_state, action, reward, done = replay_buffer.sample(batch_size)
state = np.array(state, dtype=np.float32)
next_state = np.array(next_state, dtype=np.float32)
action = np.array(action, dtype=np.float32)
reward = np.array(reward, dtype=np.float32)
done = np.array(done, dtype=np.float32)
not_done = 1 - done
self._train_body(state, next_state, action, reward, not_done, discount, tau)
@tf.contrib.eager.defun
def _train_body(self, state, next_state, action, reward, not_done, discount, tau):
with tf.device("/gpu:0"):
with tf.GradientTape() as tape:
target_Q = self.critic_target([next_state, self.actor_target(next_state)])
target_Q = reward + (not_done * discount * target_Q)
# detach => stop_gradient
target_Q = tf.stop_gradient(target_Q)
current_Q = self.critic([state, action])
# Compute critic loss + L2 loss
critic_loss = tf.reduce_mean(losses.MSE(current_Q, target_Q)) + 0.5*tf.add_n(self.critic.losses)
critic_grad = tape.gradient(critic_loss, self.critic.trainable_variables)
self.critic_optimizer.apply_gradients(zip(critic_grad, self.critic.trainable_variables))
with tf.GradientTape() as tape:
next_action = self.actor(state)
actor_loss = -tf.reduce_mean(self.critic([state, next_action]))
actor_grad = tape.gradient(actor_loss, self.actor.trainable_variables)
self.actor_optimizer.apply_gradients(zip(actor_grad, self.actor.trainable_variables))
# Update target networks
for param, target_param in zip(self.critic.weights, self.critic_target.weights):
target_param.assign(tau * param + (1 - tau) * target_param)
for param, target_param in zip(self.actor.weights, self.actor_target.weights):
target_param.assign(tau * param + (1 - tau) * target_param)
|
[
"tensorflow.device",
"tensorflow.nn.tanh",
"utils.PytorchInitializer",
"tensorflow.GradientTape",
"numpy.array",
"tensorflow.concat",
"numpy.zeros",
"tensorflow.constant",
"tensorflow.stop_gradient",
"numpy.expand_dims",
"tensorflow.add_n",
"tensorflow.train.AdamOptimizer"
] |
[((3624, 3668), 'tensorflow.train.AdamOptimizer', 'tf.train.AdamOptimizer', ([], {'learning_rate': '(0.0001)'}), '(learning_rate=0.0001)\n', (3646, 3668), True, 'import tensorflow as tf\n'), ((3977, 4020), 'tensorflow.train.AdamOptimizer', 'tf.train.AdamOptimizer', ([], {'learning_rate': '(0.001)'}), '(learning_rate=0.001)\n', (3999, 4020), True, 'import tensorflow as tf\n'), ((6716, 6760), 'tensorflow.train.AdamOptimizer', 'tf.train.AdamOptimizer', ([], {'learning_rate': '(0.0001)'}), '(learning_rate=0.0001)\n', (6738, 6760), True, 'import tensorflow as tf\n'), ((7066, 7109), 'tensorflow.train.AdamOptimizer', 'tf.train.AdamOptimizer', ([], {'learning_rate': '(0.001)'}), '(learning_rate=0.001)\n', (7088, 7109), True, 'import tensorflow as tf\n'), ((1514, 1562), 'numpy.zeros', 'np.zeros', ([], {'shape': '[1, state_dim]', 'dtype': 'np.float32'}), '(shape=[1, state_dim], dtype=np.float32)\n', (1522, 1562), True, 'import numpy as np\n'), ((1632, 1651), 'tensorflow.device', 'tf.device', (['"""/gpu:0"""'], {}), "('/gpu:0')\n", (1641, 1651), True, 'import tensorflow as tf\n'), ((2737, 2785), 'numpy.zeros', 'np.zeros', ([], {'shape': '[1, state_dim]', 'dtype': 'np.float32'}), '(shape=[1, state_dim], dtype=np.float32)\n', (2745, 2785), True, 'import numpy as np\n'), ((2822, 2871), 'numpy.zeros', 'np.zeros', ([], {'shape': '[1, action_dim]', 'dtype': 'np.float32'}), '(shape=[1, action_dim], dtype=np.float32)\n', (2830, 2871), True, 'import numpy as np\n'), ((2957, 2976), 'tensorflow.device', 'tf.device', (['"""/gpu:0"""'], {}), "('/gpu:0')\n", (2966, 2976), True, 'import tensorflow as tf\n'), ((3069, 3094), 'tensorflow.concat', 'tf.concat', (['[x, u]'], {'axis': '(1)'}), '([x, u], axis=1)\n', (3078, 3094), True, 'import tensorflow as tf\n'), ((4586, 4619), 'numpy.array', 'np.array', (['state'], {'dtype': 'np.float32'}), '(state, dtype=np.float32)\n', (4594, 4619), True, 'import numpy as np\n'), ((4645, 4683), 'numpy.array', 'np.array', (['next_state'], {'dtype': 'np.float32'}), '(next_state, dtype=np.float32)\n', (4653, 4683), True, 'import numpy as np\n'), ((4705, 4739), 'numpy.array', 'np.array', (['action'], {'dtype': 'np.float32'}), '(action, dtype=np.float32)\n', (4713, 4739), True, 'import numpy as np\n'), ((4761, 4795), 'numpy.array', 'np.array', (['reward'], {'dtype': 'np.float32'}), '(reward, dtype=np.float32)\n', (4769, 4795), True, 'import numpy as np\n'), ((4815, 4847), 'numpy.array', 'np.array', (['done'], {'dtype': 'np.float32'}), '(done, dtype=np.float32)\n', (4823, 4847), True, 'import numpy as np\n'), ((7576, 7594), 'tensorflow.constant', 'tf.constant', (['state'], {}), '(state)\n', (7587, 7594), True, 'import tensorflow as tf\n'), ((8069, 8102), 'numpy.array', 'np.array', (['state'], {'dtype': 'np.float32'}), '(state, dtype=np.float32)\n', (8077, 8102), True, 'import numpy as np\n'), ((8128, 8166), 'numpy.array', 'np.array', (['next_state'], {'dtype': 'np.float32'}), '(next_state, dtype=np.float32)\n', (8136, 8166), True, 'import numpy as np\n'), ((8188, 8222), 'numpy.array', 'np.array', (['action'], {'dtype': 'np.float32'}), '(action, dtype=np.float32)\n', (8196, 8222), True, 'import numpy as np\n'), ((8244, 8278), 'numpy.array', 'np.array', (['reward'], {'dtype': 'np.float32'}), '(reward, dtype=np.float32)\n', (8252, 8278), True, 'import numpy as np\n'), ((8298, 8330), 'numpy.array', 'np.array', (['done'], {'dtype': 'np.float32'}), '(done, dtype=np.float32)\n', (8306, 8330), True, 'import numpy as np\n'), ((8581, 8600), 'tensorflow.device', 'tf.device', (['"""/gpu:0"""'], {}), "('/gpu:0')\n", (8590, 8600), True, 'import tensorflow as tf\n'), ((1097, 1117), 'utils.PytorchInitializer', 'PytorchInitializer', ([], {}), '()\n', (1115, 1117), False, 'from utils import PytorchInitializer\n'), ((1216, 1236), 'utils.PytorchInitializer', 'PytorchInitializer', ([], {}), '()\n', (1234, 1236), False, 'from utils import PytorchInitializer\n'), ((1342, 1362), 'utils.PytorchInitializer', 'PytorchInitializer', ([], {}), '()\n', (1360, 1362), False, 'from utils import PytorchInitializer\n'), ((1837, 1857), 'tensorflow.nn.tanh', 'tf.nn.tanh', (['features'], {}), '(features)\n', (1847, 1857), True, 'import tensorflow as tf\n'), ((2075, 2095), 'utils.PytorchInitializer', 'PytorchInitializer', ([], {}), '()\n', (2093, 2095), False, 'from utils import PytorchInitializer\n'), ((2303, 2323), 'utils.PytorchInitializer', 'PytorchInitializer', ([], {}), '()\n', (2321, 2323), False, 'from utils import PytorchInitializer\n'), ((2529, 2549), 'utils.PytorchInitializer', 'PytorchInitializer', ([], {}), '()\n', (2547, 2549), False, 'from utils import PytorchInitializer\n'), ((4232, 4261), 'numpy.expand_dims', 'np.expand_dims', (['state'], {'axis': '(0)'}), '(state, axis=0)\n', (4246, 4261), True, 'import numpy as np\n'), ((4898, 4917), 'tensorflow.device', 'tf.device', (['"""/gpu:0"""'], {}), "('/gpu:0')\n", (4907, 4917), True, 'import tensorflow as tf\n'), ((7485, 7514), 'numpy.expand_dims', 'np.expand_dims', (['state'], {'axis': '(0)'}), '(state, axis=0)\n', (7499, 7514), True, 'import numpy as np\n'), ((8620, 8637), 'tensorflow.GradientTape', 'tf.GradientTape', ([], {}), '()\n', (8635, 8637), True, 'import tensorflow as tf\n'), ((8876, 8902), 'tensorflow.stop_gradient', 'tf.stop_gradient', (['target_Q'], {}), '(target_Q)\n', (8892, 8902), True, 'import tensorflow as tf\n'), ((9329, 9346), 'tensorflow.GradientTape', 'tf.GradientTape', ([], {}), '()\n', (9344, 9346), True, 'import tensorflow as tf\n'), ((4941, 4958), 'tensorflow.GradientTape', 'tf.GradientTape', ([], {}), '()\n', (4956, 4958), True, 'import tensorflow as tf\n'), ((5213, 5239), 'tensorflow.stop_gradient', 'tf.stop_gradient', (['target_Q'], {}), '(target_Q)\n', (5229, 5239), True, 'import tensorflow as tf\n'), ((5690, 5707), 'tensorflow.GradientTape', 'tf.GradientTape', ([], {}), '()\n', (5705, 5707), True, 'import tensorflow as tf\n'), ((9094, 9122), 'tensorflow.add_n', 'tf.add_n', (['self.critic.losses'], {}), '(self.critic.losses)\n', (9102, 9122), True, 'import tensorflow as tf\n'), ((5443, 5471), 'tensorflow.add_n', 'tf.add_n', (['self.critic.losses'], {}), '(self.critic.losses)\n', (5451, 5471), True, 'import tensorflow as tf\n')]
|
import numpy as np
from scipy.io import loadmat
import os
import logging
from scipy.signal import butter, filtfilt
def mat2npy(mat_chanmap_dir):
mat_chanmap = loadmat(mat_chanmap_dir)
x = mat_chanmap['xcoords']
y = mat_chanmap['ycoords']
npy_chanmap = np.hstack([x,y])
#np.save('chanmap.npy', npy_chanmap) # you can't just go saving this wherever
return npy_chanmap
def merge_filtered_files(filtered_location, output_directory, delete=True):
filenames = os.listdir(filtered_location)
filenames_sorted = sorted(filenames)
f_out = os.path.join(output_directory, "standardized.bin")
f = open(f_out, 'wb')
for fname in filenames_sorted:
if '.ipynb' in fname or 'standardized' in fname:
continue
res = np.load(os.path.join(filtered_location, fname)).astype('int16') # was float32
res.tofile(f)
if delete:
os.remove(os.path.join(filtered_location, fname))
# Added functions from yass to avoid mandatory yass install
"""
Filtering functions
"""
def _butterworth(ts, low_frequency, high_factor, order, sampling_frequency):
"""Butterworth filter
Parameters
----------
ts: np.array
T numpy array, where T is the number of time samples
low_frequency: int
Low pass frequency (Hz)
high_factor: float
High pass factor (proportion of sampling rate)
order: int
Order of Butterworth filter
sampling_frequency: int
Sampling frequency (Hz)
Notes
-----
This function can only be applied to a one dimensional array, to apply
it to multiple channels use butterworth
Raises
------
NotImplementedError
If a multidmensional array is passed
"""
low = float(low_frequency) / sampling_frequency * 2
high = float(high_factor) * 2
b, a = butter(order, low, btype='high', analog=False)
if ts.ndim == 1:
return filtfilt(b, a, ts)
else:
T, C = ts.shape
output = np.zeros((T, C), 'float32')
for c in range(C):
output[:, c] = filtfilt(b, a, ts[:, c])
return output
def _mean_standard_deviation(rec, centered=False):
"""Determine standard deviation of noise in each channel
Parameters
----------
rec : matrix [length of recording, number of channels]
centered : bool
if not standardized, center it
Returns
-------
sd : vector [number of channels]
standard deviation in each channel
"""
# find standard deviation using robust method
if not centered:
centers = np.mean(rec, axis=0)
rec = rec - centers[None]
else:
centers = np.zeros(rec.shape[1], 'float32')
return np.median(np.abs(rec), 0) / 0.6745, centers
def _standardize(rec, sd=None, centers=None):
"""Determine standard deviation of noise in each channel
Parameters
----------
rec : matrix [length of recording, number of channels]
recording
sd : vector [number of chnanels,]
standard deviation
centered : bool
if not standardized, center it
Returns
-------
matrix [length of recording, number of channels]
standardized recording
"""
# find standard deviation using robust method
if (sd is None) or (centers is None):
sd, centers = _mean_standard_deviation(rec, centered=False)
# standardize all channels with SD> 0.1 (Voltage?) units
# Cat: TODO: ensure that this is actually correct for all types of channels
idx1 = np.where(sd >= 0.1)[0]
rec[:, idx1] = np.divide(rec[:, idx1] - centers[idx1][None], sd[idx1])
# zero out bad channels
idx2 = np.where(sd < 0.1)[0]
rec[:, idx2] = 0.
return rec
# return np.divide(rec, sd)
def filter_standardize_batch(batch_id, reader, fname_mean_sd,
apply_filter, out_dtype, output_directory,
low_frequency=None, high_factor=None,
order=None, sampling_frequency=None):
"""Butterworth filter for a one dimensional time series
Parameters
----------
ts: np.array
T numpy array, where T is the number of time samples
low_frequency: int
Low pass frequency (Hz)
high_factor: float
High pass factor (proportion of sampling rate)
order: int
Order of Butterworth filter
sampling_frequency: int
Sampling frequency (Hz)
Notes
-----
This function can only be applied to a one dimensional array, to apply
it to multiple channels use butterworth
Raises
------
NotImplementedError
If a multidmensional array is passed
"""
logger = logging.getLogger(__name__)
# filter
if apply_filter:
# read a batch
ts = reader.read_data_batch(batch_id, add_buffer=True)
ts = _butterworth(ts, low_frequency, high_factor,
order, sampling_frequency)
ts = ts[reader.buffer:-reader.buffer]
else:
ts = reader.read_data_batch(batch_id, add_buffer=False)
# standardize
temp = np.load(fname_mean_sd)
sd = temp['sd']
centers = temp['centers']
ts = _standardize(ts, sd, centers)
# save
fname = os.path.join(
output_directory,
"standardized_{}.npy".format(
str(batch_id).zfill(6)))
np.save(fname, ts.astype(out_dtype))
# fname = os.path.join(
# output_directory,
# "standardized_{}.bin".format(
# str(batch_id).zfill(6)))
# f = open(fname, 'wb')
# f.write(ts.astype(out_dtype))
def get_std(ts,
sampling_frequency,
fname,
apply_filter=False,
low_frequency=None,
high_factor=None,
order=None):
"""Butterworth filter for a one dimensional time series
Parameters
----------
ts: np.array
T numpy array, where T is the number of time samples
low_frequency: int
Low pass frequency (Hz)
high_factor: float
High pass factor (proportion of sampling rate)
order: int
Order of Butterworth filter
sampling_frequency: int
Sampling frequency (Hz)
Notes
-----
This function can only be applied to a one dimensional array, to apply
it to multiple channels use butterworth
Raises
------
NotImplementedError
If a multidmensional array is passed
"""
# filter
if apply_filter:
ts = _butterworth(ts, low_frequency, high_factor,
order, sampling_frequency)
# standardize
sd, centers = _mean_standard_deviation(ts)
# save
np.savez(fname,
centers=centers,
sd=sd)
|
[
"logging.getLogger",
"numpy.mean",
"numpy.savez",
"os.listdir",
"numpy.abs",
"numpy.hstack",
"scipy.signal.filtfilt",
"numpy.where",
"scipy.io.loadmat",
"os.path.join",
"scipy.signal.butter",
"numpy.zeros",
"numpy.load",
"numpy.divide"
] |
[((164, 188), 'scipy.io.loadmat', 'loadmat', (['mat_chanmap_dir'], {}), '(mat_chanmap_dir)\n', (171, 188), False, 'from scipy.io import loadmat\n'), ((274, 291), 'numpy.hstack', 'np.hstack', (['[x, y]'], {}), '([x, y])\n', (283, 291), True, 'import numpy as np\n'), ((495, 524), 'os.listdir', 'os.listdir', (['filtered_location'], {}), '(filtered_location)\n', (505, 524), False, 'import os\n'), ((578, 628), 'os.path.join', 'os.path.join', (['output_directory', '"""standardized.bin"""'], {}), "(output_directory, 'standardized.bin')\n", (590, 628), False, 'import os\n'), ((1853, 1899), 'scipy.signal.butter', 'butter', (['order', 'low'], {'btype': '"""high"""', 'analog': '(False)'}), "(order, low, btype='high', analog=False)\n", (1859, 1899), False, 'from scipy.signal import butter, filtfilt\n'), ((3591, 3646), 'numpy.divide', 'np.divide', (['(rec[:, idx1] - centers[idx1][None])', 'sd[idx1]'], {}), '(rec[:, idx1] - centers[idx1][None], sd[idx1])\n', (3600, 3646), True, 'import numpy as np\n'), ((4715, 4742), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (4732, 4742), False, 'import logging\n'), ((5125, 5147), 'numpy.load', 'np.load', (['fname_mean_sd'], {}), '(fname_mean_sd)\n', (5132, 5147), True, 'import numpy as np\n'), ((6683, 6722), 'numpy.savez', 'np.savez', (['fname'], {'centers': 'centers', 'sd': 'sd'}), '(fname, centers=centers, sd=sd)\n', (6691, 6722), True, 'import numpy as np\n'), ((1937, 1955), 'scipy.signal.filtfilt', 'filtfilt', (['b', 'a', 'ts'], {}), '(b, a, ts)\n', (1945, 1955), False, 'from scipy.signal import butter, filtfilt\n'), ((2007, 2034), 'numpy.zeros', 'np.zeros', (['(T, C)', '"""float32"""'], {}), "((T, C), 'float32')\n", (2015, 2034), True, 'import numpy as np\n'), ((2603, 2623), 'numpy.mean', 'np.mean', (['rec'], {'axis': '(0)'}), '(rec, axis=0)\n', (2610, 2623), True, 'import numpy as np\n'), ((2686, 2719), 'numpy.zeros', 'np.zeros', (['rec.shape[1]', '"""float32"""'], {}), "(rec.shape[1], 'float32')\n", (2694, 2719), True, 'import numpy as np\n'), ((3549, 3568), 'numpy.where', 'np.where', (['(sd >= 0.1)'], {}), '(sd >= 0.1)\n', (3557, 3568), True, 'import numpy as np\n'), ((3687, 3705), 'numpy.where', 'np.where', (['(sd < 0.1)'], {}), '(sd < 0.1)\n', (3695, 3705), True, 'import numpy as np\n'), ((2089, 2113), 'scipy.signal.filtfilt', 'filtfilt', (['b', 'a', 'ts[:, c]'], {}), '(b, a, ts[:, c])\n', (2097, 2113), False, 'from scipy.signal import butter, filtfilt\n'), ((923, 961), 'os.path.join', 'os.path.join', (['filtered_location', 'fname'], {}), '(filtered_location, fname)\n', (935, 961), False, 'import os\n'), ((2742, 2753), 'numpy.abs', 'np.abs', (['rec'], {}), '(rec)\n', (2748, 2753), True, 'import numpy as np\n'), ((790, 828), 'os.path.join', 'os.path.join', (['filtered_location', 'fname'], {}), '(filtered_location, fname)\n', (802, 828), False, 'import os\n')]
|
#
# Copyright (c) 2021 Idiap Research Institute, https://www.idiap.ch/
# Written by <NAME> <<EMAIL>>
#
""" Computes the proportion of novel bigrams in the summary. """
import numpy as np
import pandas as pd
from interface import Evaluation
from eval_utils import preprocess_article, preprocess_summary
class NovelBigrams(Evaluation):
def __init__(self, input_dir, sent_sep='<q>'):
super().__init__(input_dir)
self.name = 'novel_bigrams'
self.sent_sep = sent_sep
def run(self):
# read articles and summaries
articles = self.read_articles()
summaries = self.read_candidate_summaries()
assert len(articles) == len(summaries)
# compute novel bigrams for each article-summary pair
novel_bigrams = []
for article, summary in zip(articles, summaries):
article_words = preprocess_article(article)
summary_tokenized_sents = preprocess_summary(summary, self.sent_sep)
novel_bigrams.append(NovelBigrams.compute_novel_bigrams(article_words, summary_tokenized_sents))
novel_bigrams = [score for score in novel_bigrams if score is not None] # filter bad summaries
# write results
df = pd.DataFrame({'novel_bigrams': np.mean(novel_bigrams)}, index=[0])
df.to_csv(self.get_output_path(), index=False)
@staticmethod
def compute_novel_bigrams(article_words, summary_tokenized_sents):
""" Computes the proportion of novel bigrams in the summary. """
bigrams_article = set((article_words[i], article_words[i + 1]) for i in range(len(article_words) - 1))
bigrams_summary = set()
for sentence_words in summary_tokenized_sents:
bigrams_summary |= set((sentence_words[i], sentence_words[i + 1]) for i in range(len(sentence_words) - 1))
return len(bigrams_summary - bigrams_article) / len(bigrams_summary) if len(bigrams_summary) > 0 else None
if __name__ == '__main__':
import argparse
parser = argparse.ArgumentParser(description='Computes the proportion of novel bigrams in the summary.')
parser.add_argument('--eval_dir', required=True, help='Evaluation directory')
args = parser.parse_args()
NovelBigrams(args.eval_dir).run()
|
[
"numpy.mean",
"eval_utils.preprocess_summary",
"eval_utils.preprocess_article",
"argparse.ArgumentParser"
] |
[((2008, 2108), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Computes the proportion of novel bigrams in the summary."""'}), "(description=\n 'Computes the proportion of novel bigrams in the summary.')\n", (2031, 2108), False, 'import argparse\n'), ((869, 896), 'eval_utils.preprocess_article', 'preprocess_article', (['article'], {}), '(article)\n', (887, 896), False, 'from eval_utils import preprocess_article, preprocess_summary\n'), ((935, 977), 'eval_utils.preprocess_summary', 'preprocess_summary', (['summary', 'self.sent_sep'], {}), '(summary, self.sent_sep)\n', (953, 977), False, 'from eval_utils import preprocess_article, preprocess_summary\n'), ((1260, 1282), 'numpy.mean', 'np.mean', (['novel_bigrams'], {}), '(novel_bigrams)\n', (1267, 1282), True, 'import numpy as np\n')]
|
from scipy.special import factorial
from itertools import count
import numpy as np
from tmps.utils import pauli, fock
def get_boson_boson_dim(alpha, cutoff_coh):
"""
Find the cutoff for the local dimension (identical everywhere) from the chosen accuracy alpha for the impurity
coherent state.
"""
#
pop = lambda x: np.exp(-np.abs(alpha) ** 2 / 2) * alpha ** x / np.sqrt(factorial(x, exact=True))
cutoff_dim = 2
for n in count(cutoff_dim, 1):
if np.abs(pop(n))**2 < cutoff_coh:
cutoff_dim = n
break
return cutoff_dim
def get_spin_boson_chain_hamiltonian(omega_0, c0, omega, t, bath_local_dim, finite_T=False):
"""
Returns local and coupling parts of the Spin-Boson model chain Hamiltonian
used in Sec. 4.4.1 and 4.4.2 of the thesis.
:param omega_0: Spin energy
:param c0: Spin-Bath coupling
:param omega: Bath energies
:param t: Bath-bath couplings
:param bath_local_dim: Local dimension of the bath
:param finite_T: If set True builds the Hamiltonian for Sec. 4.4.2. If False builds the Hamiltonian for Sec. 4.4.1
:returns: List of local Hamiltonians, List of coupling Hamiltonians
"""
if not finite_T:
# Local Hamiltonian of the System:
spin_loc = omega_0 / 2 * pauli.X
# Coupling between System and bath:
spin_coupl = pauli.Z
else:
# Local Hamiltonian of the System:
spin_loc = omega_0 / 2 * pauli.Z
# Coupling between System and bath:
spin_coupl = np.array([[0, 0], [1, 0]], dtype=np.complex128)
# Local Hamiltonian of the bath
fock_n = fock.n(bath_local_dim)
bath_loc = [energy * fock_n for energy in omega]
# Bath coupling
bath_coupling_op = np.kron(fock.a(bath_local_dim), fock.a_dag(bath_local_dim)) + \
np.kron(fock.a_dag(bath_local_dim), fock.a(bath_local_dim))
bath_bath_coupl = [coupling * bath_coupling_op for coupling in t]
# Spin-Bath coupling
spin_bath_coupl = c0 * (np.kron(spin_coupl, fock.a_dag(bath_local_dim)) +
np.kron(spin_coupl.conj().T, fock.a(bath_local_dim)))
return [spin_loc] + bath_loc, [spin_bath_coupl] + bath_bath_coupl
def get_spin_boson_star_hamiltonian(omega_0, system_index, gamma, xi, bath_local_dim, finite_T=False):
"""
Returns local and coupling parts of the Spin-Boson model star Hamiltonian
used in Sec. 4.4.1 and 4.4.2 of the thesis.
:param omega_0: Spin energy
:param system_index: Index of the system in the auxiliary chain
:param gamma: System-Bath couplings
:param xi: Bath energies
:param bath_local_dim: Local dimension of the bath
:param finite_T: If set True uses the Hamiltonian for Sec. 4.4.2. If False builds the Hamiltonian for Sec. 4.4.1
:returns: List of local Hamiltonians, List of coupling Hamiltonians
"""
if not finite_T:
# Local Hamiltonian of the System:
spin_loc = omega_0 / 2 * pauli.X
# Coupling between System and bath:
spin_coupl = pauli.Z
else:
# Local Hamiltonian of the System:
spin_loc = omega_0 / 2 * pauli.Z
# Coupling between System and bath:
spin_coupl = np.array([[0, 0], [1, 0]], dtype=np.complex128)
# Local Hamiltonian of the bath
fock_n = fock.n(bath_local_dim)
bath_loc = [energy * fock_n for energy in xi]
# Coupling operators for the bath to the left of the system
left_bath_coupling_op = np.kron(fock.a(bath_local_dim), spin_coupl.conj().T) + \
np.kron(fock.a_dag(bath_local_dim), spin_coupl)
left_bath_coupl = [coupling * left_bath_coupling_op for coupling in gamma[:system_index]]
# Coupling operators for the bath to the right of the system
right_bath_coupling_op = np.kron(spin_coupl.conj().T, fock.a(bath_local_dim)) + \
np.kron(spin_coupl, fock.a_dag(bath_local_dim))
right_bath_coupl = [coupling * right_bath_coupling_op for coupling in gamma[system_index:]]
return bath_loc[:system_index] + [spin_loc] + bath_loc[system_index:], left_bath_coupl + right_bath_coupl
def get_boson_boson_chain_hamiltonian(omega_0, c0, omega, t, cutoff_dim):
"""
Returns local and coupling parts of the Spin-Boson model chain Hamiltonian
used in Sec. 4.4.3 of the thesis.
:param omega_0: Spin energy
:param c0: Spin-Bath coupling
:param omega: Bath energies
:param t: Bath-bath couplings
:param cutoff_dim: Local dimension of the impurity and bath
:returns: List of local Hamiltonians, List of coupling Hamiltonians
"""
# Local Hamiltonian of the System:
sys_loc = omega_0 * fock.n(cutoff_dim)
# Coupling between System and bath:
sys_coupl = fock.a(cutoff_dim)
# Local Hamiltonian of the bath
fock_n = fock.n(cutoff_dim)
bath_loc = [energy * fock_n for energy in omega]
# Bath coupling
bath_coupling_op = np.kron(fock.a(cutoff_dim), fock.a_dag(cutoff_dim)) + \
np.kron(fock.a_dag(cutoff_dim), fock.a(cutoff_dim))
bath_bath_coupl = [coupling * bath_coupling_op for coupling in t]
# Spin-Bath coupling
spin_bath_coupl = c0 * (np.kron(sys_coupl, fock.a_dag(cutoff_dim)) +
np.kron(sys_coupl.conj().T, fock.a(cutoff_dim)))
return [sys_loc] + bath_loc, [spin_bath_coupl] + bath_bath_coupl
def get_boson_boson_star_hamiltonian(omega_0, system_index, gamma, xi, cutoff_dim):
"""
Returns local and coupling parts of the Spin-Boson model star Hamiltonian
used in Sec. 4.4.3 of the thesis.
:param omega_0: Spin energy
:param system_index: Index of the system in the auxiliary chain
:param gamma: System-Bath couplings
:param xi: Bath energies
:param cutoff_dim: Local dimension of the impurity and bath
:returns: List of local Hamiltonians, List of coupling Hamiltonians
"""
# Local Hamiltonian of the System:
sys_loc = omega_0 * fock.n(cutoff_dim)
# Coupling between System and bath:
sys_coupl = fock.a(cutoff_dim)
# Local Hamiltonian of the bath
fock_n = fock.n(cutoff_dim)
bath_loc = [energy * fock_n for energy in xi]
# Coupling operators for the bath to the left of the system
left_bath_coupling_op = np.kron(fock.a(cutoff_dim), sys_coupl.conj().T) + \
np.kron(fock.a_dag(cutoff_dim), sys_coupl)
left_bath_coupl = [coupling * left_bath_coupling_op for coupling in gamma[:system_index]]
# Coupling operators for the bath to the right of the system
right_bath_coupling_op = np.kron(sys_coupl.conj().T, fock.a(cutoff_dim)) + \
np.kron(sys_coupl, fock.a_dag(cutoff_dim))
right_bath_coupl = [coupling * right_bath_coupling_op for coupling in gamma[system_index:]]
return bath_loc[:system_index] + [sys_loc] + bath_loc[system_index:], left_bath_coupl + right_bath_coupl
|
[
"tmps.utils.fock.a_dag",
"numpy.abs",
"scipy.special.factorial",
"numpy.array",
"tmps.utils.fock.n",
"tmps.utils.fock.a",
"itertools.count"
] |
[((462, 482), 'itertools.count', 'count', (['cutoff_dim', '(1)'], {}), '(cutoff_dim, 1)\n', (467, 482), False, 'from itertools import count\n'), ((1654, 1676), 'tmps.utils.fock.n', 'fock.n', (['bath_local_dim'], {}), '(bath_local_dim)\n', (1660, 1676), False, 'from tmps.utils import pauli, fock\n'), ((3352, 3374), 'tmps.utils.fock.n', 'fock.n', (['bath_local_dim'], {}), '(bath_local_dim)\n', (3358, 3374), False, 'from tmps.utils import pauli, fock\n'), ((4803, 4821), 'tmps.utils.fock.a', 'fock.a', (['cutoff_dim'], {}), '(cutoff_dim)\n', (4809, 4821), False, 'from tmps.utils import pauli, fock\n'), ((4872, 4890), 'tmps.utils.fock.n', 'fock.n', (['cutoff_dim'], {}), '(cutoff_dim)\n', (4878, 4890), False, 'from tmps.utils import pauli, fock\n'), ((6104, 6122), 'tmps.utils.fock.a', 'fock.a', (['cutoff_dim'], {}), '(cutoff_dim)\n', (6110, 6122), False, 'from tmps.utils import pauli, fock\n'), ((6173, 6191), 'tmps.utils.fock.n', 'fock.n', (['cutoff_dim'], {}), '(cutoff_dim)\n', (6179, 6191), False, 'from tmps.utils import pauli, fock\n'), ((1557, 1604), 'numpy.array', 'np.array', (['[[0, 0], [1, 0]]'], {'dtype': 'np.complex128'}), '([[0, 0], [1, 0]], dtype=np.complex128)\n', (1565, 1604), True, 'import numpy as np\n'), ((3254, 3301), 'numpy.array', 'np.array', (['[[0, 0], [1, 0]]'], {'dtype': 'np.complex128'}), '([[0, 0], [1, 0]], dtype=np.complex128)\n', (3262, 3301), True, 'import numpy as np\n'), ((4727, 4745), 'tmps.utils.fock.n', 'fock.n', (['cutoff_dim'], {}), '(cutoff_dim)\n', (4733, 4745), False, 'from tmps.utils import pauli, fock\n'), ((6028, 6046), 'tmps.utils.fock.n', 'fock.n', (['cutoff_dim'], {}), '(cutoff_dim)\n', (6034, 6046), False, 'from tmps.utils import pauli, fock\n'), ((1782, 1804), 'tmps.utils.fock.a', 'fock.a', (['bath_local_dim'], {}), '(bath_local_dim)\n', (1788, 1804), False, 'from tmps.utils import pauli, fock\n'), ((1806, 1832), 'tmps.utils.fock.a_dag', 'fock.a_dag', (['bath_local_dim'], {}), '(bath_local_dim)\n', (1816, 1832), False, 'from tmps.utils import pauli, fock\n'), ((1869, 1895), 'tmps.utils.fock.a_dag', 'fock.a_dag', (['bath_local_dim'], {}), '(bath_local_dim)\n', (1879, 1895), False, 'from tmps.utils import pauli, fock\n'), ((1897, 1919), 'tmps.utils.fock.a', 'fock.a', (['bath_local_dim'], {}), '(bath_local_dim)\n', (1903, 1919), False, 'from tmps.utils import pauli, fock\n'), ((3526, 3548), 'tmps.utils.fock.a', 'fock.a', (['bath_local_dim'], {}), '(bath_local_dim)\n', (3532, 3548), False, 'from tmps.utils import pauli, fock\n'), ((3611, 3637), 'tmps.utils.fock.a_dag', 'fock.a_dag', (['bath_local_dim'], {}), '(bath_local_dim)\n', (3621, 3637), False, 'from tmps.utils import pauli, fock\n'), ((3868, 3890), 'tmps.utils.fock.a', 'fock.a', (['bath_local_dim'], {}), '(bath_local_dim)\n', (3874, 3890), False, 'from tmps.utils import pauli, fock\n'), ((3945, 3971), 'tmps.utils.fock.a_dag', 'fock.a_dag', (['bath_local_dim'], {}), '(bath_local_dim)\n', (3955, 3971), False, 'from tmps.utils import pauli, fock\n'), ((4996, 5014), 'tmps.utils.fock.a', 'fock.a', (['cutoff_dim'], {}), '(cutoff_dim)\n', (5002, 5014), False, 'from tmps.utils import pauli, fock\n'), ((5016, 5038), 'tmps.utils.fock.a_dag', 'fock.a_dag', (['cutoff_dim'], {}), '(cutoff_dim)\n', (5026, 5038), False, 'from tmps.utils import pauli, fock\n'), ((5075, 5097), 'tmps.utils.fock.a_dag', 'fock.a_dag', (['cutoff_dim'], {}), '(cutoff_dim)\n', (5085, 5097), False, 'from tmps.utils import pauli, fock\n'), ((5099, 5117), 'tmps.utils.fock.a', 'fock.a', (['cutoff_dim'], {}), '(cutoff_dim)\n', (5105, 5117), False, 'from tmps.utils import pauli, fock\n'), ((6343, 6361), 'tmps.utils.fock.a', 'fock.a', (['cutoff_dim'], {}), '(cutoff_dim)\n', (6349, 6361), False, 'from tmps.utils import pauli, fock\n'), ((6423, 6445), 'tmps.utils.fock.a_dag', 'fock.a_dag', (['cutoff_dim'], {}), '(cutoff_dim)\n', (6433, 6445), False, 'from tmps.utils import pauli, fock\n'), ((6674, 6692), 'tmps.utils.fock.a', 'fock.a', (['cutoff_dim'], {}), '(cutoff_dim)\n', (6680, 6692), False, 'from tmps.utils import pauli, fock\n'), ((6746, 6768), 'tmps.utils.fock.a_dag', 'fock.a_dag', (['cutoff_dim'], {}), '(cutoff_dim)\n', (6756, 6768), False, 'from tmps.utils import pauli, fock\n'), ((404, 428), 'scipy.special.factorial', 'factorial', (['x'], {'exact': '(True)'}), '(x, exact=True)\n', (413, 428), False, 'from scipy.special import factorial\n'), ((2065, 2091), 'tmps.utils.fock.a_dag', 'fock.a_dag', (['bath_local_dim'], {}), '(bath_local_dim)\n', (2075, 2091), False, 'from tmps.utils import pauli, fock\n'), ((2152, 2174), 'tmps.utils.fock.a', 'fock.a', (['bath_local_dim'], {}), '(bath_local_dim)\n', (2158, 2174), False, 'from tmps.utils import pauli, fock\n'), ((5262, 5284), 'tmps.utils.fock.a_dag', 'fock.a_dag', (['cutoff_dim'], {}), '(cutoff_dim)\n', (5272, 5284), False, 'from tmps.utils import pauli, fock\n'), ((5344, 5362), 'tmps.utils.fock.a', 'fock.a', (['cutoff_dim'], {}), '(cutoff_dim)\n', (5350, 5362), False, 'from tmps.utils import pauli, fock\n'), ((357, 370), 'numpy.abs', 'np.abs', (['alpha'], {}), '(alpha)\n', (363, 370), True, 'import numpy as np\n')]
|
import numpy as np
class Material:
"""send color as list of 3 floats in range of 0-1"""
def __init__(self, color, reflection=0, transparency=0, emission=np.array((0, 0, 0)), refraction_ind=1):
self.color = np.array(color)
self.emission = emission # only for light sources
self.reflection = reflection
self.transparency = transparency
self.refraction_ind = refraction_ind
|
[
"numpy.array"
] |
[((164, 183), 'numpy.array', 'np.array', (['(0, 0, 0)'], {}), '((0, 0, 0))\n', (172, 183), True, 'import numpy as np\n'), ((225, 240), 'numpy.array', 'np.array', (['color'], {}), '(color)\n', (233, 240), True, 'import numpy as np\n')]
|
import gym
from gym import error, spaces, utils
from gym.utils import seeding
from eplus.envs import pyEp
import socket
from eplus.envs.socket_builder import socket_builder
import numpy as np
import os
class DataCenterEnv(gym.Env):
def __init__(self, config):
#timestep=12, days=1, eplus_path=None,
# weather_file = 'weather/SPtMasterTable_587017_2012_amy.epw'):
cur_dir = os.path.dirname(__file__)
#print("File directory: ", cur_dir)
# buildings/1ZoneDataCenter/1ZoneDataCenter.idf is the EnergyPlus file
# used for this environment. The 1ZoneDataCenter folder also contains
# variables.cfg which configures the external input and output
# variables
self.idf_file = cur_dir + '/buildings/1ZoneDataCenter/1ZoneDataCenter.idf'
# EnergyPlus weather file
if "weather_file" in config:
self.weather_file = cur_dir + '/' + config["weather_file"]
else:
self.weather_file = cur_dir + '/weather/SPtMasterTable_587017_2012_amy.epw'
#self.weather_file = cur_dir + '/weather/SPtMasterTable_587017_2012_amy.epw'
if "eplus_path" in config:
self.eplus_path = config["eplus_path"]
else:
# Using EnergyPlus version 8.80, path to the executable
# Assuming Mac
self.eplus_path = '/Applications/EnergyPlus-8-8-0/'
# EnergyPlus number of timesteps in an hour
if "timestep" in config:
self.epTimeStep = config["timestep"]
else:
self.epTimeStep = 12
# EnergyPlus number of simulation days
if "days" in config:
self.simDays = config["days"]
else:
self.simDays = 1
# Number of steps per day
self.DAYSTEPS = int(24 * self.epTimeStep)
# Total number of steps
self.MAXSTEPS = int(self.simDays * self.DAYSTEPS)
# Time difference between each step in seconds
self.deltaT = (60/self.epTimeStep)*60
# Outputs given by EnergyPlus, defined in variables.cfg
self.outputs = []
# Inputs expected by EnergyPlus, defined in variables.cfg
self.inputs = []
# Current step of the simulation
self.kStep = 0
# Instance of EnergyPlus simulation
self.ep = None
# state can be all the inputs required to make a control decision
# getting all the outputs coming from EnergyPlus for the time being
self.observation_space = spaces.Box(np.array([0, -50, 0]), #zone temp, outdoor drybulb temp, relative humidity
np.array([60, 70, 100]), dtype=np.float32)
# actions are all the control inputs
#self.action_space = spaces.Tuple(( #spaces.Box(low=22, high=27, shape=(1,),dtype=np.float32), #cooling setpoint
# spaces.Box(low=6, high=7, shape=(1,),dtype=np.float32), #chiller setpoint
# spaces.Box(low=0, high=1, shape=(1,),dtype=np.float32) #lighting setpoint
# ))
self.clg_min = 20 #cooling setpoint min in celcius
self.clg_max = 35 #cooling setpoint max in celcius
self.htg_min = 5 #heating setpoint min in celcius
self.htg_max = 20 #heating setpoint max in celcius
#self.action_space = spaces.Box(np.array([self.clg_min,self.htg_min]),
# np.array([self.clg_max, self.htg_max]), dtype=np.float32)
# Normalized action space
self.action_space = spaces.Box(np.array([0,0]),
np.array([1,1]), dtype=np.float32)
def step(self, action):
# while(self.kStep < self.MAXSTEPS):
# current time from start of simulation
time = self.kStep * self.deltaT
# current time from start of day
dayTime = time % 86400
if dayTime == 0:
print("Day: ", int(self.kStep/self.DAYSTEPS)+1)
#inputs should be same as actions
#bring the actions in the correct range
#For Ray: assuming mean 0 and std dev 1 by ray
#action[0] = action[0]*(self.clg_max - self.clg_min)+(self.clg_min+self.clg_max)/2.0
#action[1] = action[1]*(self.htg_max - self.htg_min)+(self.htg_min+self.htg_max)/2.0
#For Coach: input is 0 to 1 range
action[0] = action[0]*(self.clg_max - self.clg_min)+(self.clg_min)
action[1] = action[1]*(self.htg_max - self.htg_min)+(self.htg_min)
#force action to be within limits
cooling_setpoint = np.clip(action, self.clg_min, self.clg_max)[0]
heating_setpoint = np.clip(action, self.htg_min, self.htg_max)[1]
self.inputs = [cooling_setpoint, heating_setpoint]
input_packet = self.ep.encode_packet_simple(self.inputs, time)
self.ep.write(input_packet)
#after EnergyPlus runs the simulation step, it returns the outputs
output_packet = self.ep.read()
self.outputs = self.ep.decode_packet_simple(output_packet)
#print("Outputs:", self.outputs)
if not self.outputs:
print("Outputs:", self.outputs)
print("Actions:", action)
next_state = self.reset()
return next_state, 0, False, {}
# reward needs to be a combination of energy and comfort requirement
energy_coeff = -0.00001
heating_coeff = -100
cooling_coeff = -100
energy = self.outputs[0]
zone_temperature = self.outputs[1] #taking mid-zone 2 as an example
heating_setpoint = 15 #fixed lower limit in celcius
cooling_setpoint = 30 #fixed upper limit in celcius
heating_penalty = max(heating_setpoint - zone_temperature, 0)
cooling_penalty = max(zone_temperature - cooling_setpoint, 0)
# punish if action is out of limits
action_penalty_coeff = -100
max_penalty = max(self.clg_min - action[0], 0)
min_penalty = max(action[0] - self.clg_max, 0)
action_penalty = action_penalty_coeff * (max_penalty + min_penalty)
max_penalty = max(self.htg_min - action[1], 0)
min_penalty = max(action[1] - self.htg_max, 0)
action_penalty += action_penalty_coeff * (max_penalty + min_penalty)
# final reward
reward = energy_coeff * energy \
+ heating_coeff * heating_penalty \
+ cooling_coeff * cooling_penalty \
+ action_penalty
# state can be all the inputs required to make a control decision
# zone temp, outside drybulb temp, outside wetbulb temp, relative humidity
next_state = np.array([self.outputs[1], self.outputs[2], self.outputs[4]])
# fake state space
#next_state = np.array([3, 2, 1, 0])
#print("energy: %.2f, reward: %.2f, action: %.2f, %.2f" \
# % (energy, reward, action[0], action[1]))
#print("zone temp: %.2f, drybulb: %.2f, humidity: %.2f"\
# %tuple(next_state))
# increment simulation step count
self.kStep += 1
# done when number of steps of simulation reaches its maximum (e.g. 1 day)
done = False
if self.kStep >= (self.MAXSTEPS):
#requires one more step to close the simulation
input_packet = self.ep.encode_packet_simple(self.inputs, time)
self.ep.write(input_packet)
#output is empty in the final step
#but it is required to read this output for termination
output_packet = self.ep.read()
last_output = self.ep.decode_packet_simple(output_packet)
print("Finished simulation")
print("Last action: ", action)
print("Last reward: ", reward)
done = True
self.ep.close()
self.ep = None
# extra information we want to pass
info = {}
# print("State:", next_state, "Reward:", reward)
return next_state, reward, done, info
def reset(self):
# stop existing energyplus simulation
if self.ep:
print("Closing the old simulation and socket.")
self.ep.close() #needs testing: check if it stops the simulation
self.ep = None
# start new simulation
print("Starting a new simulation..")
self.kStep = 0
idf_dir = os.path.dirname(self.idf_file)
builder = socket_builder(idf_dir)
configs = builder.build()
self.ep = pyEp.ep_process('localhost', configs[0], self.idf_file, self.weather_file, self.eplus_path)
# read the initial outputs from EnergyPlus
# these outputs are from warmup phase, so this does not count as a simulation step
self.outputs = self.ep.decode_packet_simple(self.ep.read())
return np.array([self.outputs[1], self.outputs[2], self.outputs[4]])
#return np.array([3,2,1,0])
def render(self, mode='human', close=False):
pass
|
[
"eplus.envs.pyEp.ep_process",
"numpy.clip",
"eplus.envs.socket_builder.socket_builder",
"os.path.dirname",
"numpy.array"
] |
[((425, 450), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (440, 450), False, 'import os\n'), ((6761, 6822), 'numpy.array', 'np.array', (['[self.outputs[1], self.outputs[2], self.outputs[4]]'], {}), '([self.outputs[1], self.outputs[2], self.outputs[4]])\n', (6769, 6822), True, 'import numpy as np\n'), ((8513, 8543), 'os.path.dirname', 'os.path.dirname', (['self.idf_file'], {}), '(self.idf_file)\n', (8528, 8543), False, 'import os\n'), ((8562, 8585), 'eplus.envs.socket_builder.socket_builder', 'socket_builder', (['idf_dir'], {}), '(idf_dir)\n', (8576, 8585), False, 'from eplus.envs.socket_builder import socket_builder\n'), ((8640, 8735), 'eplus.envs.pyEp.ep_process', 'pyEp.ep_process', (['"""localhost"""', 'configs[0]', 'self.idf_file', 'self.weather_file', 'self.eplus_path'], {}), "('localhost', configs[0], self.idf_file, self.weather_file,\n self.eplus_path)\n", (8655, 8735), False, 'from eplus.envs import pyEp\n'), ((8958, 9019), 'numpy.array', 'np.array', (['[self.outputs[1], self.outputs[2], self.outputs[4]]'], {}), '([self.outputs[1], self.outputs[2], self.outputs[4]])\n', (8966, 9019), True, 'import numpy as np\n'), ((2563, 2584), 'numpy.array', 'np.array', (['[0, -50, 0]'], {}), '([0, -50, 0])\n', (2571, 2584), True, 'import numpy as np\n'), ((2682, 2705), 'numpy.array', 'np.array', (['[60, 70, 100]'], {}), '([60, 70, 100])\n', (2690, 2705), True, 'import numpy as np\n'), ((3657, 3673), 'numpy.array', 'np.array', (['[0, 0]'], {}), '([0, 0])\n', (3665, 3673), True, 'import numpy as np\n'), ((3709, 3725), 'numpy.array', 'np.array', (['[1, 1]'], {}), '([1, 1])\n', (3717, 3725), True, 'import numpy as np\n'), ((4671, 4714), 'numpy.clip', 'np.clip', (['action', 'self.clg_min', 'self.clg_max'], {}), '(action, self.clg_min, self.clg_max)\n', (4678, 4714), True, 'import numpy as np\n'), ((4745, 4788), 'numpy.clip', 'np.clip', (['action', 'self.htg_min', 'self.htg_max'], {}), '(action, self.htg_min, self.htg_max)\n', (4752, 4788), True, 'import numpy as np\n')]
|
# Copyright (c) 2019-2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import cv2
import numpy as np
import math
import os
import random
from nvidia.dali.pipeline import Pipeline
import nvidia.dali.ops as ops
import nvidia.dali.types as types
import nvidia.dali as dali
from test_utils import compare_pipelines
from sequences_test_utils import ArgData, ArgDesc, get_video_input_cases, ParamsProvider, sequence_suite_helper, ArgCb
test_data_root = os.environ['DALI_EXTRA_PATH']
caffe_db_folder = os.path.join(test_data_root, 'db', 'lmdb')
def get_output_size(angle, input_size, parity_correction=True):
cosa = abs(math.cos(angle))
sina = abs(math.sin(angle))
(h, w) = input_size[0:2]
eps = 1e-2
out_w = int(math.ceil(w*cosa + h*sina - eps))
out_h = int(math.ceil(h*cosa + w*sina - eps))
if not parity_correction:
return (out_h, out_w)
if sina <= cosa:
if out_w % 2 != w % 2:
out_w += 1
if out_h % 2 != h % 2:
out_h += 1
else:
if out_w % 2 != h % 2:
out_w += 1
if out_h % 2 != w % 2:
out_h += 1
return (out_h, out_w)
def get_3d_lin_rotation(angle, axis):
# mirrors transform.h:rotation3D
if not angle:
return np.eye((3, 3), dtype=np.float32)
axis_norm = np.linalg.norm(axis)
axis = [dim / axis_norm for dim in axis]
u, v, w = axis
cosa = math.cos(angle)
sina = math.sin(angle)
return np.array([
[u*u + (v*v+w*w)*cosa, u*v*(1-cosa) - w*sina, u*w*(1-cosa) + v*sina],
[u*v*(1-cosa) + w*sina, v*v + (u*u+w*w)*cosa, v*w*(1-cosa) - u*sina],
[u*w*(1-cosa) - v*sina, v*w*(1-cosa) + u*sina, w*w + (u*u+v*v)*cosa],
], dtype=np.float32)
def get_3d_output_size(angle, axis, input_size, parity_correction=False):
transform = np.abs(get_3d_lin_rotation(angle, axis))
eps = 1e-2
in_size = np.array(input_size[2::-1], dtype=np.int32)
out_size = np.int32(np.ceil(np.matmul(transform, in_size) - eps))
if parity_correction:
dominant_axis = np.argmax(transform, axis=1)
out_size += (out_size % 2) ^ (in_size[dominant_axis] % 2)
return out_size[::-1]
def get_transform(angle, input_size, output_size):
cosa = math.cos(angle)
sina = math.sin(angle)
(out_h, out_w) = output_size[0:2]
(in_h, in_w) = input_size[0:2]
t1 = np.array([
[1, 0, -out_w*0.5],
[0, 1, -out_h*0.5],
[0, 0, 1]])
r = np.array([
[cosa, -sina, 0],
[sina, cosa, 0],
[0, 0, 1]])
t2 = np.array([
[1, 0, in_w*0.5],
[0, 1, in_h*0.5],
[0, 0, 1]])
return (np.matmul(t2, np.matmul(r, t1)))[0:2,0:3]
def ToCVMatrix(matrix):
offset = np.matmul(matrix, np.array([[0.5], [0.5], [1]]))
result = matrix.copy()
result[0][2] = offset[0] - 0.5
result[1][2] = offset[1] - 0.5
return result
def CVRotate(output_type, input_type, fixed_size):
def warp_fn(img, angle):
in_size = img.shape[0:2]
angle = math.radians(angle)
out_size = fixed_size if fixed_size is not None else get_output_size(angle, in_size)
matrix = get_transform(angle, in_size, out_size)
matrix = ToCVMatrix(matrix)
if output_type == dali.types.FLOAT or input_type == dali.types.FLOAT:
img = np.float32(img)
out_size_wh = (out_size[1], out_size[0])
out = cv2.warpAffine(img, matrix, out_size_wh, borderMode = cv2.BORDER_CONSTANT, borderValue = [42,42,42],
flags = (cv2.INTER_LINEAR|cv2.WARP_INVERSE_MAP))
if output_type == dali.types.UINT8 and input_type == dali.types.FLOAT:
out = np.uint8(np.clip(out, 0, 255))
return out
return warp_fn
class RotatePipeline(Pipeline):
def __init__(self, device, batch_size, output_type, input_type, fixed_size=None, num_threads=3, device_id=0, num_gpus=1):
super(RotatePipeline, self).__init__(batch_size, num_threads, device_id, seed=7865, exec_async=False, exec_pipelined=False)
self.name = device
self.input = ops.readers.Caffe(path = caffe_db_folder, shard_id = device_id, num_shards = num_gpus)
self.decode = ops.decoders.Image(device = "cpu", output_type = types.RGB)
if input_type != dali.types.UINT8:
self.cast = ops.Cast(device = device, dtype = input_type)
else:
self.cast = None
self.uniform = ops.random.Uniform(range = (-180.0, 180.0), seed = 42)
self.rotate = ops.Rotate(device = device, size=fixed_size, fill_value = 42, dtype = output_type)
def define_graph(self):
self.jpegs, self.labels = self.input(name = "Reader")
images = self.decode(self.jpegs)
if self.rotate.device == "gpu":
images = images.gpu()
if self.cast:
images = self.cast(images)
outputs = self.rotate(images, angle = self.uniform())
return outputs
class CVPipeline(Pipeline):
def __init__(self, batch_size, output_type, input_type, fixed_size, num_threads=3, device_id=0, num_gpus=1):
super(CVPipeline, self).__init__(batch_size, num_threads, device_id, seed=7865, exec_async=False, exec_pipelined=False)
self.name = "cv"
self.input = ops.readers.Caffe(path = caffe_db_folder, shard_id = device_id, num_shards = num_gpus)
self.decode = ops.decoders.Image(device = "cpu", output_type = types.RGB)
self.rotate = ops.PythonFunction(function=CVRotate(output_type, input_type, fixed_size),
output_layouts="HWC")
self.uniform = ops.random.Uniform(range = (-180.0, 180.0), seed = 42)
self.iter = 0
def define_graph(self):
self.jpegs, self.labels = self.input(name = "Reader")
images = self.decode(self.jpegs)
angles = self.uniform()
outputs = self.rotate(images, angles)
return outputs
def compare(pipe1, pipe2, eps):
pipe1.build()
pipe2.build()
epoch_size = pipe1.epoch_size("Reader")
batch_size = pipe1.max_batch_size
niter = 1 if batch_size >= epoch_size else 2
compare_pipelines(pipe1, pipe2, batch_size, niter, eps)
io_types = [
(dali.types.UINT8, dali.types.UINT8),
(dali.types.UINT8, dali.types.FLOAT),
(dali.types.FLOAT, dali.types.UINT8),
(dali.types.FLOAT, dali.types.FLOAT)
]
def create_pipeline(backend, *args):
if backend == "cv":
return CVPipeline(*args)
else:
return RotatePipeline(backend, *args)
def run_cases(backend1, backend2, epsilon):
for batch_size in [1, 4, 19]:
for output_size in [None, (160,240)]:
for (itype, otype) in io_types:
def run_case(backend1, backend2, *args):
pipe1 = create_pipeline(backend1, *args)
pipe2 = create_pipeline(backend2, *args)
compare(pipe1, pipe2, epsilon)
yield run_case, backend1, backend2, batch_size, otype, itype, output_size
def test_gpu_vs_cv():
for test in run_cases("gpu", "cv", 8):
yield test
def test_cpu_vs_cv():
for test in run_cases("cpu", "cv", 8):
yield test
def test_gpu_vs_cpu():
for test in run_cases("gpu", "cpu", 1):
yield test
def infer_sequence_size(input_shapes, angles, axes=None):
assert(len(input_shapes) == len(angles))
assert(axes is None or len(axes) == len(angles))
if axes is None:
no_correction_shapes = [
np.array(get_output_size(math.radians(angle), shape, False), dtype=np.int32)
for shape, angle in zip(input_shapes, angles)]
corrected_shapes = [
np.array(get_output_size(math.radians(angle), shape, True), dtype=np.int32)
for shape, angle in zip(input_shapes, angles)]
else:
no_correction_shapes = [
np.array(get_3d_output_size(math.radians(angle), axis, shape, False), dtype=np.int32)
for shape, angle, axis in zip(input_shapes, angles, axes)]
corrected_shapes = [
np.array(get_3d_output_size(math.radians(angle), axis, shape, True), dtype=np.int32)
for shape, angle, axis in zip(input_shapes, angles, axes)]
max_shape = np.max(no_correction_shapes, axis=0)
parity = np.sum(np.array(corrected_shapes, dtype=np.int32) % 2, axis=0)
for i in range(len(max_shape)):
if max_shape[i] % 2 != (2 * parity[i] > len(input_shapes)):
max_shape[i] += 1
return max_shape
def sequence_batch_output_size(unfolded_extents, input_batch, angle_batch, axis_batch=None):
def iter_by_groups():
assert(sum(unfolded_extents) == len(input_batch))
assert(len(input_batch) == len(angle_batch))
assert(axis_batch is None or len(axis_batch) == len(angle_batch))
offset = 0
for group in unfolded_extents:
yield input_batch[offset:offset + group], angle_batch[offset:offset + group],\
None if axis_batch is None else axis_batch[offset:offset + group]
offset += group
sequence_output_shape = [
infer_sequence_size([frame.shape for frame in input_frames], angles, axes)
for input_frames, angles, axes in iter_by_groups()]
return [
output_shape for output_shape, num_frames in zip(sequence_output_shape, unfolded_extents)
for _ in range(num_frames)]
class RotatePerFrameParamsProvider(ParamsProvider):
"""
Provides per frame angle argument input to the video rotate operator test.
The expanded baseline pipeline must be provided with additional argument ``size``
to make allowance for coalescing of inferred frames sizes
"""
def __init__(self, input_params):
super().__init__(input_params)
def expand_params(self):
assert(self.num_expand == 1)
expanded_params = super().expand_params()
params_dict = {param_data.desc.name: param_data for param_data in expanded_params}
expanded_angles = params_dict.get('angle')
expanded_axis = params_dict.get('axis')
assert expanded_angles is not None and 'size' not in self.fixed_params and 'size' not in params_dict
sequence_extents = [
[sample.shape[0] for sample in input_batch]
for input_batch in self.input_data]
output_size_params = (sequence_extents, self.unfolded_input, expanded_angles.data)
if expanded_axis is not None:
output_size_params += (expanded_axis.data,)
output_sizes = [
sequence_batch_output_size(*args)
for args in zip(*output_size_params)]
expanded_params.append(ArgData(ArgDesc("size", False, "cpu"), output_sizes))
return expanded_params
def __repr__(self):
return "{}({})".format(repr(self.__class__), repr(self.input_params))
def test_video():
def small_angle(sample_desc):
return np.array(sample_desc.rng.uniform(-44., 44.), dtype=np.float32)
def random_angle(sample_desc):
return np.array(sample_desc.rng.uniform(-180., 180.), dtype=np.float32)
def random_output(sample_desc):
return np.array([sample_desc.rng.randint(300, 400), rng.randint(300, 400)])
video_test_cases = [
(dali.fn.rotate, {'angle': 45.}, []),
(dali.fn.rotate, {}, [ArgCb("angle", small_angle, False)]),
(dali.fn.rotate, {}, [ArgCb("angle", random_angle, False)]),
(dali.fn.rotate, {}, RotatePerFrameParamsProvider([ArgCb("angle", small_angle, True)])),
(dali.fn.rotate, {}, RotatePerFrameParamsProvider([ArgCb("angle", random_angle, True)])),
(dali.fn.rotate, {}, [ArgCb("angle", small_angle, True), ArgCb("size", random_output, False)]),
]
rng = random.Random(42)
video_cases = get_video_input_cases("FHWC", rng, larger_shape=(512, 287))
input_cases = [("FHWC", input_data) for input_data in video_cases]
yield from sequence_suite_helper(rng, "F", input_cases, video_test_cases)
def test_3d_sequence():
rng = random.Random(42)
num_batches = 4
max_batch_size = 8
max_frames_num = 32
input_layout = "FDHWC"
np_rng = np.random.default_rng(42)
def get_random_sample():
num_frames = rng.randint(1, max_frames_num)
d, h, w = tuple(rng.randint(10, 50) for _ in range(3))
return np.int32(np_rng.uniform(0, 255, (num_frames, d, h, w, 3)))
def get_random_batch():
return [get_random_sample() for _ in range(rng.randint(1, max_batch_size))]
input_cases = [(input_layout, [get_random_batch() for _ in range(num_batches)])]
def random_angle(sample_desc):
return np.array(sample_desc.rng.uniform(-180., 180.), dtype=np.float32)
def random_axis(sample_desc):
return np.array([sample_desc.rng.uniform(-1, 1) for _ in range(3)], dtype=np.float32)
test_cases = [
(dali.fn.rotate, {'angle': 45., 'axis': np.array([1, 0, 0], dtype=np.float32)}, []),
(dali.fn.rotate, {'size': (50, 30, 20)}, [ArgCb("angle", random_angle, True), ArgCb("axis", random_axis, True)]),
(dali.fn.rotate, {}, RotatePerFrameParamsProvider([ArgCb("angle", random_angle, True), ArgCb("axis", random_axis, True)])),
]
yield from sequence_suite_helper(rng, "F", input_cases, test_cases)
|
[
"numpy.clip",
"numpy.random.default_rng",
"math.cos",
"numpy.array",
"nvidia.dali.ops.readers.Caffe",
"numpy.linalg.norm",
"sequences_test_utils.ArgDesc",
"random.Random",
"numpy.max",
"math.sin",
"numpy.matmul",
"test_utils.compare_pipelines",
"sequences_test_utils.get_video_input_cases",
"numpy.eye",
"cv2.warpAffine",
"nvidia.dali.ops.decoders.Image",
"numpy.argmax",
"nvidia.dali.ops.Cast",
"math.radians",
"sequences_test_utils.ArgCb",
"math.ceil",
"sequences_test_utils.sequence_suite_helper",
"os.path.join",
"nvidia.dali.ops.random.Uniform",
"nvidia.dali.ops.Rotate",
"numpy.float32"
] |
[((1055, 1097), 'os.path.join', 'os.path.join', (['test_data_root', '"""db"""', '"""lmdb"""'], {}), "(test_data_root, 'db', 'lmdb')\n", (1067, 1097), False, 'import os\n'), ((1829, 1849), 'numpy.linalg.norm', 'np.linalg.norm', (['axis'], {}), '(axis)\n', (1843, 1849), True, 'import numpy as np\n'), ((1919, 1934), 'math.cos', 'math.cos', (['angle'], {}), '(angle)\n', (1927, 1934), False, 'import math\n'), ((1944, 1959), 'math.sin', 'math.sin', (['angle'], {}), '(angle)\n', (1952, 1959), False, 'import math\n'), ((1969, 2302), 'numpy.array', 'np.array', (['[[u * u + (v * v + w * w) * cosa, u * v * (1 - cosa) - w * sina, u * w * (1 -\n cosa) + v * sina], [u * v * (1 - cosa) + w * sina, v * v + (u * u + w *\n w) * cosa, v * w * (1 - cosa) - u * sina], [u * w * (1 - cosa) - v *\n sina, v * w * (1 - cosa) + u * sina, w * w + (u * u + v * v) * cosa]]'], {'dtype': 'np.float32'}), '([[u * u + (v * v + w * w) * cosa, u * v * (1 - cosa) - w * sina, u *\n w * (1 - cosa) + v * sina], [u * v * (1 - cosa) + w * sina, v * v + (u *\n u + w * w) * cosa, v * w * (1 - cosa) - u * sina], [u * w * (1 - cosa) -\n v * sina, v * w * (1 - cosa) + u * sina, w * w + (u * u + v * v) * cosa\n ]], dtype=np.float32)\n', (1977, 2302), True, 'import numpy as np\n'), ((2381, 2424), 'numpy.array', 'np.array', (['input_size[2::-1]'], {'dtype': 'np.int32'}), '(input_size[2::-1], dtype=np.int32)\n', (2389, 2424), True, 'import numpy as np\n'), ((2718, 2733), 'math.cos', 'math.cos', (['angle'], {}), '(angle)\n', (2726, 2733), False, 'import math\n'), ((2745, 2760), 'math.sin', 'math.sin', (['angle'], {}), '(angle)\n', (2753, 2760), False, 'import math\n'), ((2844, 2909), 'numpy.array', 'np.array', (['[[1, 0, -out_w * 0.5], [0, 1, -out_h * 0.5], [0, 0, 1]]'], {}), '([[1, 0, -out_w * 0.5], [0, 1, -out_h * 0.5], [0, 0, 1]])\n', (2852, 2909), True, 'import numpy as np\n'), ((2939, 2995), 'numpy.array', 'np.array', (['[[cosa, -sina, 0], [sina, cosa, 0], [0, 0, 1]]'], {}), '([[cosa, -sina, 0], [sina, cosa, 0], [0, 0, 1]])\n', (2947, 2995), True, 'import numpy as np\n'), ((3030, 3091), 'numpy.array', 'np.array', (['[[1, 0, in_w * 0.5], [0, 1, in_h * 0.5], [0, 0, 1]]'], {}), '([[1, 0, in_w * 0.5], [0, 1, in_h * 0.5], [0, 0, 1]])\n', (3038, 3091), True, 'import numpy as np\n'), ((6502, 6557), 'test_utils.compare_pipelines', 'compare_pipelines', (['pipe1', 'pipe2', 'batch_size', 'niter', 'eps'], {}), '(pipe1, pipe2, batch_size, niter, eps)\n', (6519, 6557), False, 'from test_utils import compare_pipelines\n'), ((8445, 8481), 'numpy.max', 'np.max', (['no_correction_shapes'], {'axis': '(0)'}), '(no_correction_shapes, axis=0)\n', (8451, 8481), True, 'import numpy as np\n'), ((11767, 11784), 'random.Random', 'random.Random', (['(42)'], {}), '(42)\n', (11780, 11784), False, 'import random\n'), ((11803, 11862), 'sequences_test_utils.get_video_input_cases', 'get_video_input_cases', (['"""FHWC"""', 'rng'], {'larger_shape': '(512, 287)'}), "('FHWC', rng, larger_shape=(512, 287))\n", (11824, 11862), False, 'from sequences_test_utils import ArgData, ArgDesc, get_video_input_cases, ParamsProvider, sequence_suite_helper, ArgCb\n'), ((12046, 12063), 'random.Random', 'random.Random', (['(42)'], {}), '(42)\n', (12059, 12063), False, 'import random\n'), ((12161, 12186), 'numpy.random.default_rng', 'np.random.default_rng', (['(42)'], {}), '(42)\n', (12182, 12186), True, 'import numpy as np\n'), ((1179, 1194), 'math.cos', 'math.cos', (['angle'], {}), '(angle)\n', (1187, 1194), False, 'import math\n'), ((1211, 1226), 'math.sin', 'math.sin', (['angle'], {}), '(angle)\n', (1219, 1226), False, 'import math\n'), ((1288, 1324), 'math.ceil', 'math.ceil', (['(w * cosa + h * sina - eps)'], {}), '(w * cosa + h * sina - eps)\n', (1297, 1324), False, 'import math\n'), ((1338, 1374), 'math.ceil', 'math.ceil', (['(h * cosa + w * sina - eps)'], {}), '(h * cosa + w * sina - eps)\n', (1347, 1374), False, 'import math\n'), ((1782, 1814), 'numpy.eye', 'np.eye', (['(3, 3)'], {'dtype': 'np.float32'}), '((3, 3), dtype=np.float32)\n', (1788, 1814), True, 'import numpy as np\n'), ((2538, 2566), 'numpy.argmax', 'np.argmax', (['transform'], {'axis': '(1)'}), '(transform, axis=1)\n', (2547, 2566), True, 'import numpy as np\n'), ((3222, 3251), 'numpy.array', 'np.array', (['[[0.5], [0.5], [1]]'], {}), '([[0.5], [0.5], [1]])\n', (3230, 3251), True, 'import numpy as np\n'), ((3480, 3499), 'math.radians', 'math.radians', (['angle'], {}), '(angle)\n', (3492, 3499), False, 'import math\n'), ((3831, 3980), 'cv2.warpAffine', 'cv2.warpAffine', (['img', 'matrix', 'out_size_wh'], {'borderMode': 'cv2.BORDER_CONSTANT', 'borderValue': '[42, 42, 42]', 'flags': '(cv2.INTER_LINEAR | cv2.WARP_INVERSE_MAP)'}), '(img, matrix, out_size_wh, borderMode=cv2.BORDER_CONSTANT,\n borderValue=[42, 42, 42], flags=cv2.INTER_LINEAR | cv2.WARP_INVERSE_MAP)\n', (3845, 3980), False, 'import cv2\n'), ((4477, 4562), 'nvidia.dali.ops.readers.Caffe', 'ops.readers.Caffe', ([], {'path': 'caffe_db_folder', 'shard_id': 'device_id', 'num_shards': 'num_gpus'}), '(path=caffe_db_folder, shard_id=device_id, num_shards=num_gpus\n )\n', (4494, 4562), True, 'import nvidia.dali.ops as ops\n'), ((4586, 4641), 'nvidia.dali.ops.decoders.Image', 'ops.decoders.Image', ([], {'device': '"""cpu"""', 'output_type': 'types.RGB'}), "(device='cpu', output_type=types.RGB)\n", (4604, 4641), True, 'import nvidia.dali.ops as ops\n'), ((4822, 4872), 'nvidia.dali.ops.random.Uniform', 'ops.random.Uniform', ([], {'range': '(-180.0, 180.0)', 'seed': '(42)'}), '(range=(-180.0, 180.0), seed=42)\n', (4840, 4872), True, 'import nvidia.dali.ops as ops\n'), ((4899, 4975), 'nvidia.dali.ops.Rotate', 'ops.Rotate', ([], {'device': 'device', 'size': 'fixed_size', 'fill_value': '(42)', 'dtype': 'output_type'}), '(device=device, size=fixed_size, fill_value=42, dtype=output_type)\n', (4909, 4975), True, 'import nvidia.dali.ops as ops\n'), ((5647, 5732), 'nvidia.dali.ops.readers.Caffe', 'ops.readers.Caffe', ([], {'path': 'caffe_db_folder', 'shard_id': 'device_id', 'num_shards': 'num_gpus'}), '(path=caffe_db_folder, shard_id=device_id, num_shards=num_gpus\n )\n', (5664, 5732), True, 'import nvidia.dali.ops as ops\n'), ((5756, 5811), 'nvidia.dali.ops.decoders.Image', 'ops.decoders.Image', ([], {'device': '"""cpu"""', 'output_type': 'types.RGB'}), "(device='cpu', output_type=types.RGB)\n", (5774, 5811), True, 'import nvidia.dali.ops as ops\n'), ((5999, 6049), 'nvidia.dali.ops.random.Uniform', 'ops.random.Uniform', ([], {'range': '(-180.0, 180.0)', 'seed': '(42)'}), '(range=(-180.0, 180.0), seed=42)\n', (6017, 6049), True, 'import nvidia.dali.ops as ops\n'), ((11949, 12011), 'sequences_test_utils.sequence_suite_helper', 'sequence_suite_helper', (['rng', '"""F"""', 'input_cases', 'video_test_cases'], {}), "(rng, 'F', input_cases, video_test_cases)\n", (11970, 12011), False, 'from sequences_test_utils import ArgData, ArgDesc, get_video_input_cases, ParamsProvider, sequence_suite_helper, ArgCb\n'), ((13186, 13242), 'sequences_test_utils.sequence_suite_helper', 'sequence_suite_helper', (['rng', '"""F"""', 'input_cases', 'test_cases'], {}), "(rng, 'F', input_cases, test_cases)\n", (13207, 13242), False, 'from sequences_test_utils import ArgData, ArgDesc, get_video_input_cases, ParamsProvider, sequence_suite_helper, ArgCb\n'), ((3140, 3156), 'numpy.matmul', 'np.matmul', (['r', 't1'], {}), '(r, t1)\n', (3149, 3156), True, 'import numpy as np\n'), ((3760, 3775), 'numpy.float32', 'np.float32', (['img'], {}), '(img)\n', (3770, 3775), True, 'import numpy as np\n'), ((4711, 4752), 'nvidia.dali.ops.Cast', 'ops.Cast', ([], {'device': 'device', 'dtype': 'input_type'}), '(device=device, dtype=input_type)\n', (4719, 4752), True, 'import nvidia.dali.ops as ops\n'), ((8500, 8542), 'numpy.array', 'np.array', (['corrected_shapes'], {'dtype': 'np.int32'}), '(corrected_shapes, dtype=np.int32)\n', (8508, 8542), True, 'import numpy as np\n'), ((2455, 2484), 'numpy.matmul', 'np.matmul', (['transform', 'in_size'], {}), '(transform, in_size)\n', (2464, 2484), True, 'import numpy as np\n'), ((4083, 4103), 'numpy.clip', 'np.clip', (['out', '(0)', '(255)'], {}), '(out, 0, 255)\n', (4090, 4103), True, 'import numpy as np\n'), ((10709, 10738), 'sequences_test_utils.ArgDesc', 'ArgDesc', (['"""size"""', '(False)', '"""cpu"""'], {}), "('size', False, 'cpu')\n", (10716, 10738), False, 'from sequences_test_utils import ArgData, ArgDesc, get_video_input_cases, ParamsProvider, sequence_suite_helper, ArgCb\n'), ((11344, 11378), 'sequences_test_utils.ArgCb', 'ArgCb', (['"""angle"""', 'small_angle', '(False)'], {}), "('angle', small_angle, False)\n", (11349, 11378), False, 'from sequences_test_utils import ArgData, ArgDesc, get_video_input_cases, ParamsProvider, sequence_suite_helper, ArgCb\n'), ((11412, 11447), 'sequences_test_utils.ArgCb', 'ArgCb', (['"""angle"""', 'random_angle', '(False)'], {}), "('angle', random_angle, False)\n", (11417, 11447), False, 'from sequences_test_utils import ArgData, ArgDesc, get_video_input_cases, ParamsProvider, sequence_suite_helper, ArgCb\n'), ((11676, 11709), 'sequences_test_utils.ArgCb', 'ArgCb', (['"""angle"""', 'small_angle', '(True)'], {}), "('angle', small_angle, True)\n", (11681, 11709), False, 'from sequences_test_utils import ArgData, ArgDesc, get_video_input_cases, ParamsProvider, sequence_suite_helper, ArgCb\n'), ((11711, 11746), 'sequences_test_utils.ArgCb', 'ArgCb', (['"""size"""', 'random_output', '(False)'], {}), "('size', random_output, False)\n", (11716, 11746), False, 'from sequences_test_utils import ArgData, ArgDesc, get_video_input_cases, ParamsProvider, sequence_suite_helper, ArgCb\n'), ((12878, 12915), 'numpy.array', 'np.array', (['[1, 0, 0]'], {'dtype': 'np.float32'}), '([1, 0, 0], dtype=np.float32)\n', (12886, 12915), True, 'import numpy as np\n'), ((12969, 13003), 'sequences_test_utils.ArgCb', 'ArgCb', (['"""angle"""', 'random_angle', '(True)'], {}), "('angle', random_angle, True)\n", (12974, 13003), False, 'from sequences_test_utils import ArgData, ArgDesc, get_video_input_cases, ParamsProvider, sequence_suite_helper, ArgCb\n'), ((13005, 13037), 'sequences_test_utils.ArgCb', 'ArgCb', (['"""axis"""', 'random_axis', '(True)'], {}), "('axis', random_axis, True)\n", (13010, 13037), False, 'from sequences_test_utils import ArgData, ArgDesc, get_video_input_cases, ParamsProvider, sequence_suite_helper, ArgCb\n'), ((7777, 7796), 'math.radians', 'math.radians', (['angle'], {}), '(angle)\n', (7789, 7796), False, 'import math\n'), ((7942, 7961), 'math.radians', 'math.radians', (['angle'], {}), '(angle)\n', (7954, 7961), False, 'import math\n'), ((8121, 8140), 'math.radians', 'math.radians', (['angle'], {}), '(angle)\n', (8133, 8140), False, 'import math\n'), ((8307, 8326), 'math.radians', 'math.radians', (['angle'], {}), '(angle)\n', (8319, 8326), False, 'import math\n'), ((11510, 11543), 'sequences_test_utils.ArgCb', 'ArgCb', (['"""angle"""', 'small_angle', '(True)'], {}), "('angle', small_angle, True)\n", (11515, 11543), False, 'from sequences_test_utils import ArgData, ArgDesc, get_video_input_cases, ParamsProvider, sequence_suite_helper, ArgCb\n'), ((11607, 11641), 'sequences_test_utils.ArgCb', 'ArgCb', (['"""angle"""', 'random_angle', '(True)'], {}), "('angle', random_angle, True)\n", (11612, 11641), False, 'from sequences_test_utils import ArgData, ArgDesc, get_video_input_cases, ParamsProvider, sequence_suite_helper, ArgCb\n'), ((13096, 13130), 'sequences_test_utils.ArgCb', 'ArgCb', (['"""angle"""', 'random_angle', '(True)'], {}), "('angle', random_angle, True)\n", (13101, 13130), False, 'from sequences_test_utils import ArgData, ArgDesc, get_video_input_cases, ParamsProvider, sequence_suite_helper, ArgCb\n'), ((13132, 13164), 'sequences_test_utils.ArgCb', 'ArgCb', (['"""axis"""', 'random_axis', '(True)'], {}), "('axis', random_axis, True)\n", (13137, 13164), False, 'from sequences_test_utils import ArgData, ArgDesc, get_video_input_cases, ParamsProvider, sequence_suite_helper, ArgCb\n')]
|
#%%
import os
print(os.getcwd())
from Blocks import ReLU, SequentialNN, Dense, Hinge, SGD
from dataset_utils import load_mnist
import numpy as np
from convolution_layer import ConvLayer
from maxpool_layer import MaxPool2x2
from flatten_layer import FlattenLayer
import sys
def iterate_minibatches(x, y, batch_size=16, verbose=True):
assert len(x) == len(y)
indices = np.arange(len(x))
np.random.shuffle(indices)
for i, start_idx in enumerate(range(0, len(x) - batch_size + 1, batch_size)):
if verbose:
print('\rBatch: {}/{}'.format(i + 1, len(x) // batch_size), end='')
sys.stdout.flush()
excerpt = indices[start_idx:start_idx + batch_size]
yield x[excerpt], y[excerpt]
def get_cnn():
nn = SequentialNN()
nn.add(ConvLayer(1, 2, filter_size=3)) # The output is of size N_obj 2 28 28
nn.add(ReLU()) # The output is of size N_obj 2 28 28
nn.add(MaxPool2x2()) # The output is of size N_obj 2 14 14
nn.add(ConvLayer(2, 4, filter_size=3)) # The output is of size N_obj 4 14 14
nn.add(ReLU()) # The output is of size N_obj 4 14 14
nn.add(MaxPool2x2()) # The output is of size N_obj 4 7 7
nn.add(FlattenLayer()) # The output is of size N_obj 196
nn.add(Dense(4 * 7 * 7, 32))
nn.add(ReLU())
nn.add(Dense(32, 1))
return nn
nn = get_cnn()
loss = Hinge()
optimizer = SGD(nn)
train = list(load_mnist(dataset='training', path='.'))
train_images = np.array([im[1] for im in train])
train_targets = np.array([im[0] for im in train])
# We will train a 0 vs. 1 classifier
x_train = train_images[train_targets < 2][:1000]
y_train = train_targets[train_targets < 2][:1000]
y_train = y_train * 2 - 1
y_train = y_train.reshape((-1, 1))
x_train = x_train.astype('float32') / 255.0
x_train = x_train.reshape((-1, 1, 28, 28))
# It will train for about 5 minutes
num_epochs = 3
batch_size = 32
# We will store the results here
history = {'loss': [], 'accuracy': []}
# `num_epochs` represents the number of iterations
for epoch in range(num_epochs):
print('Epoch {}/{}'.format(epoch + 1, num_epochs))
# We perform iteration a one-by-one iteration of the mini-batches
for x_batch, y_batch in iterate_minibatches(x_train, y_train, batch_size):
# Predict the target value
y_pred = nn.forward(x_batch)
# Compute the gradient of the loss
loss_grad = loss.backward(y_pred, y_batch)
# Perform backwards pass
nn.backward(x_batch, loss_grad)
# Update the params
optimizer.update_params()
# Save loss and accuracy values
history['loss'].append(loss.forward(y_pred, y_batch))
prediction_is_correct = (y_pred > 0) == (y_batch > 0)
history['accuracy'].append(np.mean(prediction_is_correct))
print()
#%%
import matplotlib.pyplot as plt
# Let's plot the results to get a better insight
plt.figure(figsize=(8, 5))
ax_1 = plt.subplot()
ax_1.plot(history['loss'], c='g', lw=2, label='train loss')
ax_1.set_ylabel('loss', fontsize=16)
ax_1.set_xlabel('#batches', fontsize=16)
ax_2 = plt.twinx(ax_1)
ax_2.plot(history['accuracy'], lw=3, label='train accuracy')
ax_2.set_ylabel('accuracy', fontsize=16)
|
[
"flatten_layer.FlattenLayer",
"numpy.mean",
"convolution_layer.ConvLayer",
"Blocks.SGD",
"Blocks.SequentialNN",
"maxpool_layer.MaxPool2x2",
"matplotlib.pyplot.twinx",
"os.getcwd",
"numpy.array",
"matplotlib.pyplot.figure",
"Blocks.Dense",
"Blocks.Hinge",
"Blocks.ReLU",
"sys.stdout.flush",
"matplotlib.pyplot.subplot",
"dataset_utils.load_mnist",
"numpy.random.shuffle"
] |
[((1357, 1364), 'Blocks.Hinge', 'Hinge', ([], {}), '()\n', (1362, 1364), False, 'from Blocks import ReLU, SequentialNN, Dense, Hinge, SGD\n'), ((1377, 1384), 'Blocks.SGD', 'SGD', (['nn'], {}), '(nn)\n', (1380, 1384), False, 'from Blocks import ReLU, SequentialNN, Dense, Hinge, SGD\n'), ((1456, 1489), 'numpy.array', 'np.array', (['[im[1] for im in train]'], {}), '([im[1] for im in train])\n', (1464, 1489), True, 'import numpy as np\n'), ((1506, 1539), 'numpy.array', 'np.array', (['[im[0] for im in train]'], {}), '([im[0] for im in train])\n', (1514, 1539), True, 'import numpy as np\n'), ((2887, 2913), 'matplotlib.pyplot.figure', 'plt.figure', ([], {'figsize': '(8, 5)'}), '(figsize=(8, 5))\n', (2897, 2913), True, 'import matplotlib.pyplot as plt\n'), ((2922, 2935), 'matplotlib.pyplot.subplot', 'plt.subplot', ([], {}), '()\n', (2933, 2935), True, 'import matplotlib.pyplot as plt\n'), ((3082, 3097), 'matplotlib.pyplot.twinx', 'plt.twinx', (['ax_1'], {}), '(ax_1)\n', (3091, 3097), True, 'import matplotlib.pyplot as plt\n'), ((20, 31), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (29, 31), False, 'import os\n'), ((400, 426), 'numpy.random.shuffle', 'np.random.shuffle', (['indices'], {}), '(indices)\n', (417, 426), True, 'import numpy as np\n'), ((764, 778), 'Blocks.SequentialNN', 'SequentialNN', ([], {}), '()\n', (776, 778), False, 'from Blocks import ReLU, SequentialNN, Dense, Hinge, SGD\n'), ((1399, 1439), 'dataset_utils.load_mnist', 'load_mnist', ([], {'dataset': '"""training"""', 'path': '"""."""'}), "(dataset='training', path='.')\n", (1409, 1439), False, 'from dataset_utils import load_mnist\n'), ((791, 821), 'convolution_layer.ConvLayer', 'ConvLayer', (['(1)', '(2)'], {'filter_size': '(3)'}), '(1, 2, filter_size=3)\n', (800, 821), False, 'from convolution_layer import ConvLayer\n'), ((872, 878), 'Blocks.ReLU', 'ReLU', ([], {}), '()\n', (876, 878), False, 'from Blocks import ReLU, SequentialNN, Dense, Hinge, SGD\n'), ((929, 941), 'maxpool_layer.MaxPool2x2', 'MaxPool2x2', ([], {}), '()\n', (939, 941), False, 'from maxpool_layer import MaxPool2x2\n'), ((993, 1023), 'convolution_layer.ConvLayer', 'ConvLayer', (['(2)', '(4)'], {'filter_size': '(3)'}), '(2, 4, filter_size=3)\n', (1002, 1023), False, 'from convolution_layer import ConvLayer\n'), ((1074, 1080), 'Blocks.ReLU', 'ReLU', ([], {}), '()\n', (1078, 1080), False, 'from Blocks import ReLU, SequentialNN, Dense, Hinge, SGD\n'), ((1131, 1143), 'maxpool_layer.MaxPool2x2', 'MaxPool2x2', ([], {}), '()\n', (1141, 1143), False, 'from maxpool_layer import MaxPool2x2\n'), ((1193, 1207), 'flatten_layer.FlattenLayer', 'FlattenLayer', ([], {}), '()\n', (1205, 1207), False, 'from flatten_layer import FlattenLayer\n'), ((1254, 1274), 'Blocks.Dense', 'Dense', (['(4 * 7 * 7)', '(32)'], {}), '(4 * 7 * 7, 32)\n', (1259, 1274), False, 'from Blocks import ReLU, SequentialNN, Dense, Hinge, SGD\n'), ((1287, 1293), 'Blocks.ReLU', 'ReLU', ([], {}), '()\n', (1291, 1293), False, 'from Blocks import ReLU, SequentialNN, Dense, Hinge, SGD\n'), ((1306, 1318), 'Blocks.Dense', 'Dense', (['(32)', '(1)'], {}), '(32, 1)\n', (1311, 1318), False, 'from Blocks import ReLU, SequentialNN, Dense, Hinge, SGD\n'), ((622, 640), 'sys.stdout.flush', 'sys.stdout.flush', ([], {}), '()\n', (638, 640), False, 'import sys\n'), ((2756, 2786), 'numpy.mean', 'np.mean', (['prediction_is_correct'], {}), '(prediction_is_correct)\n', (2763, 2786), True, 'import numpy as np\n')]
|
# Normal-exponential using out-of-band probes
# normex: negative control probes
# noob: ‘out-of-band’ Infinium I probes
# Lib
import logging
import numpy as np
import pandas as pd
from statsmodels import robust
from scipy.stats import norm, lognorm
# App
from ..models import ControlType, ArrayType
from ..models.sketchy_probes import qualityMask450, qualityMaskEPIC, qualityMaskEPICPLUS, qualityMaskmouse
__all__ = ['preprocess_noob']
LOGGER = logging.getLogger(__name__)
def preprocess_noob(container, offset=15, pval_probes_df=None, quality_mask_df=None, nonlinear_dye_correction=True, debug=False, unit_test_oob=False): # v1.4.5+
""" NOOB pythonized copy of https://github.com/zwdzwd/sesame/blob/master/R/background_correction.R
- The function takes a SigSet and returns a modified SigSet with the background subtracted.
- Background is modelled in a normal distribution and true signal in an exponential distribution.
- The Norm-Exp deconvolution is parameterized using Out-Of-Band (oob) probes.
- includes snps, but not control probes yet
- output should replace the container instead of returning debug dataframes
- II RED and II GREEN both have data, but manifest doesn't have a way to track this, so function tracks it.
- keep IlmnID as index for meth/unmeth snps, and convert fg_green
if nonlinear_dye_correction=True, this uses a sesame method in place of minfi method, in a later step.
if unit_test_oob==True, returns the intermediate data instead of updating the SigSet/SampleDataContainer.
"""
if debug:
print(f"DEBUG NOOB {debug} nonlinear_dye_correction={nonlinear_dye_correction}, pval_probes_df={pval_probes_df.shape if isinstance(pval_probes_df,pd.DataFrame) else 'None'}, quality_mask_df={quality_mask_df.shape if isinstance(quality_mask_df,pd.DataFrame) else 'None'}")
# stack- need one long list of values, regardless of Meth/Uneth
ibG = pd.concat([
container.ibG.reset_index().rename(columns={'Meth': 'mean_value'}).assign(used='M'),
container.ibG.reset_index().rename(columns={'Unmeth': 'mean_value'}).assign(used='U')
])
ibG = ibG[ ~ibG['mean_value'].isna() ].drop(columns=['Meth','Unmeth'])
ibR = pd.concat([
container.ibR.reset_index().rename(columns={'Meth': 'mean_value'}).assign(used='M'), #.drop(columns=['Meth','Unmeth']),
container.ibR.reset_index().rename(columns={'Unmeth': 'mean_value'}).assign(used='U') #.drop(columns=['Meth','Unmeth'])
])
ibR = ibR[ ~ibR['mean_value'].isna() ].drop(columns=['Meth','Unmeth'])
# out-of-band is Green-Unmeth and Red-Meth
# exclude failing probes
pval = pval_probes_df.loc[ pval_probes_df['poobah_pval'] > container.poobah_sig ].index if isinstance(pval_probes_df, pd.DataFrame) else []
qmask = quality_mask_df.loc[ quality_mask_df['quality_mask'] == 0 ].index if isinstance(quality_mask_df, pd.DataFrame) else []
# the ignored errors here should only be from probes that are both pval failures and qmask failures.
Rmeth = list(container.oobR['Meth'].drop(index=pval, errors='ignore').drop(index=qmask, errors='ignore'))
Runmeth = list(container.oobR['Unmeth'].drop(index=pval, errors='ignore').drop(index=qmask, errors='ignore'))
oobR = pd.DataFrame( Rmeth + Runmeth, columns=['mean_value'])
Gmeth = list(container.oobG['Meth'].drop(index=pval, errors='ignore').drop(index=qmask, errors='ignore'))
Gunmeth = list(container.oobG['Unmeth'].drop(index=pval, errors='ignore').drop(index=qmask, errors='ignore'))
oobG = pd.DataFrame( Gmeth + Gunmeth, columns=['mean_value'])
# minfi test
# ref fg_green = 442614 | vs ibG 442672 = 396374 + 46240
# ref fg_red = 528410 | vs ibR 528482 = 439279 + 89131
# ref oob_green = 178374
# ref oob_red = 92578
#oobR = pd.DataFrame( data={'mean_value': container.oobR['Meth']})
#oobG = pd.DataFrame( data={'mean_value': container.oobG['Unmeth']})
#print(f" oobR {oobR.shape} oobG {oobG.shape}")
#import pdb;pdb.set_trace()
debug_warnings = ""
if oobR['mean_value'].isna().sum() > 0:
debug_warnings += f" NOOB: oobG had {oobG['mean_value'].isna().sum()} NaNs"
oobR = oobR.dropna()
if oobG['mean_value'].isna().sum() > 0:
debug_warnings += f" NOOB: oobG had {oobG['mean_value'].isna().sum()} NaNs"
oobG = oobG.dropna()
if ibG['mean_value'].isna().sum() > 0 or ibR['mean_value'].isna().sum() > 0:
raise ValueError("ibG or ibR is missing probe intensities. need to filter them out.")
if debug:
print(f"ibG {len(ibG)} ibR {len(ibR)} oobG {len(oobG)} oobR {len(oobR)} | {debug_warnings}")
# set minimum intensity to 1
ibG_affected = len(ibG.loc[ ibG['mean_value'] < 1 ].index)
ibR_affected = len(ibR.loc[ ibR['mean_value'] < 1 ].index)
ibG.loc[ ibG['mean_value'] < 1, 'mean_value'] = 1
ibR.loc[ ibR['mean_value'] < 1, 'mean_value'] = 1
oobG_affected = len(oobG[ oobG['mean_value'] < 1])
oobR_affected = len(oobR[ oobR['mean_value'] < 1])
oobG.loc[ oobG.mean_value < 1, 'mean_value'] = 1
oobR.loc[ oobR.mean_value < 1, 'mean_value'] = 1
if debug:
if ibR_affected > 0 or ibR_affected > 0:
print(f"ib: Set {ibR_affected} red and {ibG_affected} green to 1.0 ({len(ibR[ ibR['mean_value'] == 1 ].index)}, {len(ibG[ ibG['mean_value'] == 1 ].index)})")
if oobG_affected > 0 or oobR_affected > 0:
print(f"oob: Set {oobR_affected} red and {oobG_affected} green to 1.0 ({len(oobR[ oobR['mean_value'] == 1 ].index)}, {len(oobG[ oobG['mean_value'] == 1 ].index)})")
# do background correction in each channel; returns "normalized in-band signal"
ibG_nl, params_green = normexp_bg_corrected(ibG, oobG, offset, sample_name=container.sample.name)
ibR_nl, params_red = normexp_bg_corrected(ibR, oobR, offset, sample_name=container.sample.name)
noob_green = ibG_nl.round({'bg_corrected':0})
noob_red = ibR_nl.round({'bg_corrected':0})
if unit_test_oob:
return {
'oobR': oobR,
'oobG': oobG,
'noob_green': noob_green,
'noob_red': noob_red,
}
# by default, this last step is omitted for sesame
if nonlinear_dye_correction == True:
# update() expects noob_red/green to have IlmnIDs in index, and contain bg_corrected for ALL probes.
container.update_probe_means(noob_green, noob_red)
elif nonlinear_dye_correction == False:
# this "linear" method may be anologous to the ratio quantile normalization described in Nature: https://www.nature.com/articles/s41598-020-72664-6
normexp_bg_correct_control(container.ctrl_green, params_green)
normexp_bg_correct_control(container.ctrl_red, params_red)
mask_green = container.ctrl_green['Control_Type'].isin(ControlType.normalization_green())
mask_red = container.ctrl_red['Control_Type'].isin(ControlType.normalization_red())
avg_green = container.ctrl_green[mask_green]['bg_corrected'].mean()
avg_red = container.ctrl_red[mask_red]['bg_corrected'].mean()
rg_ratios = avg_red / avg_green
red_factor = 1 / rg_ratios
container.update_probe_means(noob_green, noob_red, red_factor)
container._SigSet__minfi_noob = True
elif nonlinear_dye_correction is None:
if debug:
LOGGER.info("skipping linear/nonlinear dye-bias correction step")
# skips the minfi-linear step and won't trigger the sesame nonlinear dye bias step downstream, if you REALLY want it uncorrected. Mostly for debugging / benchmarking.
container.update_probe_means(noob_green, noob_red)
class BackgroundCorrectionParams():
""" used in apply_bg_correction """
__slots__ = (
'bg_mean',
'bg_mad',
'mean_signal',
'offset',
)
def __init__(self, bg_mean, bg_mad, mean_signal, offset):
# note: default offset was 15. In v1.3.3 (Jan 2020) I kept 15, after finding this made results match sesame's NOOB output exactly, if dye step ommitted.
# offset is specified in the preprocess_noob() function.
self.bg_mean = bg_mean
self.bg_mad = bg_mad
self.mean_signal = mean_signal
self.offset = offset
def normexp_bg_corrected(fg_probes, ctrl_probes, offset, sample_name=None):
""" analogous to sesame's backgroundCorrectionNoobCh1 """
fg_means = fg_probes['mean_value']
if fg_means.min() == fg_means.max():
LOGGER.error(f"{sample_name}: min and max intensity are same. Sample probably bad.")
params = BackgroundCorrectionParams(bg_mean=1.0, bg_mad=1.0, mean_signal=1.0, offset=15)
fg_probes['bg_corrected'] = 1.0
return fg_probes, params
fg_mean, _fg_mad = huber(fg_means)
bg_mean, bg_mad = huber(ctrl_probes['mean_value'])
mean_signal = np.maximum(fg_mean - bg_mean, 10) # "alpha" in sesame function
params = BackgroundCorrectionParams(bg_mean, bg_mad, mean_signal, offset)
corrected_signals = apply_bg_correction(fg_means, params)
fg_probes['bg_corrected'] = corrected_signals
fg_probes['bg_corrected'] = fg_probes['bg_corrected'].round(1)
return fg_probes, params
def normexp_bg_correct_control(control_probes, params):
"""Function for getting xcs controls for preprocessNoob"""
control_means = control_probes['mean_value']
corrected_signals = apply_bg_correction(control_means, params)
control_probes['bg_corrected'] = corrected_signals
return control_probes
def apply_bg_correction(mean_values, params):
""" this function won't work with float16 in practice (underflow). limits use to float32 """
if not isinstance(params, BackgroundCorrectionParams):
raise ValueError('params is not a BackgroundCorrectionParams instance')
np.seterr(under='ignore') # 'raise to explore fixing underflow warning here'
bg_mean = params.bg_mean #mu
bg_mad = params.bg_mad #sigma
mean_signal = params.mean_signal #alpha
offset = params.offset
mu_sf = mean_values - bg_mean - (bg_mad ** 2) / mean_signal
#try:
# signal_part_one = mu_sf + (bg_mad ** 2)
# signal_part_two = np.exp(norm(mu_sf, bg_mad).logpdf(0) - norm(mu_sf, bg_mad).logsf(0))
# signal = signal_part_one * signal_part_two
#except:
# print(signal_part_one, norm(mu_sf, bg_mad).logpdf(0), norm(mu_sf, bg_mad).logsf(0))
# norm is from scipy.stats
signal = mu_sf + (bg_mad ** 2) * np.exp(norm(mu_sf, bg_mad).logpdf(0) - norm(mu_sf, bg_mad).logsf(0))
""" COMPARE with sesame:
signal <- mu.sf + sigma2 * exp(
dnorm(0, mean = mu.sf, sd = sigma, log = TRUE) -
pnorm(
0, mean = mu.sf, sd = sigma,
lower.tail = FALSE, log.p = TRUE))
"""
# sesame: "Limit of numerical accuracy reached with very low intensity or very high background:
# setting adjusted intensities to small value"
signal = np.maximum(signal, 1e-6)
true_signal = signal + offset
return true_signal
def huber(vector):
"""Huber function. Designed to mirror MASS huber function in R
Parameters
----------
vector: list
list of float values
Returns
-------
local_median: float
calculated mu value
mad_scale: float
calculated s value
"""
num_values = len(vector)
positive_factor = 1.5
convergence_tol = 1.0e-6
mad_scale = robust.mad(vector)
local_median = np.median(vector)
init_local_median = local_median
if not (local_median or mad_scale):
return local_median, mad_scale
while True:
yy = np.minimum(
np.maximum(
local_median - positive_factor * mad_scale,
vector,
),
local_median + positive_factor * mad_scale,
)
init_local_median = sum(yy) / num_values
if abs(local_median - init_local_median) < convergence_tol * mad_scale:
return local_median, mad_scale
local_median = init_local_median
def _apply_sesame_quality_mask(data_container):
""" adapted from sesame's qualityMask function, which is applied just after poobah
to remove probes Wanding thinks are sketchy.
OUTPUT: this pandas DataFrame will have NaNs for probes to be excluded and 0.0 for probes to be retained. NaNs converted to 1.0 in final processing output.
SESAME:
masked <- sesameDataGet(paste0(sset@platform, '.probeInfo'))$mask
to use TCGA masking, only applies to HM450
"""
if data_container.array_type not in (
# ArrayType.ILLUMINA_27K,
ArrayType.ILLUMINA_450K,
ArrayType.ILLUMINA_EPIC,
ArrayType.ILLUMINA_EPIC_PLUS,
ArrayType.ILLUMINA_MOUSE):
LOGGER.info(f"Quality masking is not supported for {data_container.array_type}.")
return
# load set of probes to remove from local file
if data_container.array_type == ArrayType.ILLUMINA_450K:
probes = qualityMask450
elif data_container.array_type == ArrayType.ILLUMINA_EPIC:
probes = qualityMaskEPIC
elif data_container.array_type == ArrayType.ILLUMINA_EPIC_PLUS:
# this is a bit of a hack; probe names don't match epic, so I'm temporarily renaming, then filtering, then reverting.
probes = qualityMaskEPICPLUS
elif data_container.array_type == ArrayType.ILLUMINA_MOUSE:
probes = qualityMaskmouse
# v1.6+: the 1.0s are good probes and the 0.0 are probes to be excluded.
cgs = pd.DataFrame( np.zeros((len(data_container.man.index), 1)), index=data_container.man.index, columns=['quality_mask'])
cgs['quality_mask'] = 1.0
snps = pd.DataFrame( np.zeros((len(data_container.snp_man.index), 1)), index=data_container.snp_man.index, columns=['quality_mask'])
snps['quality_mask'] = 1.0
df = pd.concat([cgs, snps])
df.loc[df.index.isin(probes), 'quality_mask'] = 0
#LOGGER.info(f"DEBUG quality_mask: {df.shape}, {df['quality_mask'].value_counts()} from {probes.shape} probes")
return df
""" ##### DEPRECATED (<v1.5.0) #####
def _old_reprocess_noob_sesame_v144(container, offset=15, debug=False):
''' NOOB pythonized copy of https://github.com/zwdzwd/sesame/blob/master/R/background_correction.R
- The function takes a SigSet and returns a modified SigSet with that background subtracted.
- Background is modelled in a normal distribution and true signal in an exponential distribution.
- The Norm-Exp deconvolution is parameterized using Out-Of-Band (oob) probes.
- includes snps, but not control probes yet
- output should replace the container instead of returning debug dataframes
- II RED and II GREEN both have data, but manifest doesn't have a way to track this, so function tracks it.
'''
# get in-band red and green channel probe means
#ibR <- c(IR(sset), II(sset)[,'U']) # in-band red signal = IR_meth + IR_unmeth + II[unmeth]
#ibG <- c(IG(sset), II(sset)[,'M']) # in-band green signal = IG_meth + IG_unmeth + II[meth]
# cols: mean_value, IlmnID, probe_type (I,II); index: illumina_id
#CHECKED: AddressA or AddressB for each probe subtype matches probes.py
raw = container.snp_methylated.data_frame
snp_IR_meth = (raw[(raw['Infinium_Design_Type'] == 'I') & (raw['Color_Channel'] == 'Red')][['mean_value','AddressB_ID']]
.reset_index().rename(columns={'AddressB_ID':'illumina_id'}).set_index('illumina_id'))
snp_IR_meth['Channel'] = 'Red'
snp_IG_meth = (raw[(raw['Infinium_Design_Type'] == 'I') & (raw['Color_Channel'] == 'Grn')][['mean_value','AddressB_ID']]
.reset_index().rename(columns={'AddressB_ID':'illumina_id'}).set_index('illumina_id'))
snp_IG_meth['Channel'] = 'Grn'
snp_II_meth = (raw[(raw['Infinium_Design_Type'] == 'II')][['mean_value','AddressA_ID']]
.reset_index().rename(columns={'AddressA_ID':'illumina_id'}).set_index('illumina_id'))
snp_II_meth['Channel'] = 'Grn'
raw = container.snp_unmethylated.data_frame
snp_IR_unmeth = (raw[(raw['Infinium_Design_Type'] == 'I') & (raw['Color_Channel'] == 'Red')][['mean_value','AddressA_ID']]
.reset_index().rename(columns={'AddressA_ID':'illumina_id'}).set_index('illumina_id'))
snp_IR_unmeth['Channel'] = 'Red'
snp_IG_unmeth = (raw[(raw['Infinium_Design_Type'] == 'I') & (raw['Color_Channel'] == 'Grn')][['mean_value','AddressA_ID']]
.reset_index().rename(columns={'AddressA_ID':'illumina_id'}).set_index('illumina_id'))
snp_IG_unmeth['Channel'] = 'Grn'
snp_II_unmeth = (raw[(raw['Infinium_Design_Type'] == 'II')][['mean_value','AddressA_ID']]
.reset_index().rename(columns={'AddressA_ID':'illumina_id'}).set_index('illumina_id'))
snp_II_unmeth['Channel'] = 'Red'
if debug:
print('snp probes:', snp_IR_meth.shape, snp_IG_unmeth.shape, snp_II_meth.shape, snp_II_unmeth.shape)
#--> copy over snps, but first get snps with illumina_id in index
# swap index on all snps from IlmnID to illumina_id
## note: 350076 II + 89203 IR + 46298 IG = 485577 (including rs probes, but excl controls)
ibG = container.fg_green # --> self.raw_dataset.get_fg_values(self.manifest, Channel.GREEN)
ibG['Channel'] = 'Grn'
ibG.index.name = 'illumina_id'
ibR = container.fg_red # --> self.raw_dataset.get_fg_values(self.manifest, Channel.RED)
ibR['Channel'] = 'Red'
ibR.index.name = 'illumina_id'
# to match sesame, extra probes are IR_unmeth and IG_unmeth in ibR red and ibG green, respectively.
ibG = pd.concat([ibG,
snp_IG_meth,
snp_IG_unmeth,
snp_II_meth
], sort=True).drop('probe_type', axis=1)
# sort=True, because column order varies
ibR = pd.concat([ibR,
snp_IR_meth,
snp_IR_unmeth,
snp_II_unmeth
], sort=True).drop('probe_type', axis=1)
if debug:
print('in-bound Green:', ibG.shape) # green IG is AddressB, (meth) according to PROBE_SUBSETS
print('in-bound Red:', ibR.shape) # red IR is AddressA (unmeth) according to PROBE_SUBSETS
### at this point, ibG ibR probe counts match sesame EXACTLY
# set minimum intensity to 1
ibR_affected = len(ibR.loc[ ibR['mean_value'] < 1 ].index)
ibG_affected = len(ibG.loc[ ibG['mean_value'] < 1 ].index)
ibR.loc[ ibR['mean_value'] < 1, 'mean_value'] = 1
ibG.loc[ ibG['mean_value'] < 1, 'mean_value'] = 1
if debug:
print(f"IB: Set {ibR_affected} red and {ibG_affected} green to 1.0 ({len(ibR[ ibR['mean_value'] == 1 ].index)}, {len(ibG[ ibG['mean_value'] == 1 ].index)})")
red_dupes = len(ibR.index)-len(ibR.drop_duplicates().index)
grn_dupes = len(ibG.index)-len(ibG.drop_duplicates().index)
if debug and (red_dupes or grn_dupes):
print(f"duplicate probes: {red_dupes} red and {grn_dupes} green")
ref = container.manifest.data_frame # [['Infinium_Design_Type','Color_Channel']]
# using a copy .oobG and .oobR here; does not update the idat or other source data probe_means
# adopted from raw_dataset.filter_oob_probes here
oobR = (container.oobR.merge(container.manifest.data_frame[['AddressB_ID']],
how='left',
left_index=True,
right_index=True)
.reset_index()
.rename(columns={'AddressB_ID':'illumina_id', 'Unnamed: 0': 'IlmnID'})
.set_index('illumina_id')
)
oobR = pd.DataFrame(list(oobR['meth']) + list(oobR['unmeth']), columns=['mean_value'])
oobG = (container.oobG.merge(container.manifest.data_frame[['AddressA_ID']],
how='left',
left_index=True,
right_index=True)
.reset_index()
.rename(columns={'AddressA_ID':'illumina_id', 'Unnamed: 0': 'IlmnID'})
.set_index('illumina_id')
)
oobG = pd.DataFrame(list(oobG['meth']) + list(oobG['unmeth']), columns=['mean_value'])
oobG_affected = len(oobG[ oobG['mean_value'] < 1])
oobG.loc[ oobG.mean_value < 1, 'mean_value'] = 1
oobR_affected = len(oobR[ oobR['mean_value'] < 1])
oobR.loc[ oobR.mean_value < 1, 'mean_value'] = 1
# here: do bg_subtract AND normalization step here ...
## do background correction in each channel; returns "normalized in-band signal"
ibR_nl, params_red = normexp_bg_corrected(ibR, oobR, offset, sample_name=container.sample.name)
#<- .backgroundCorrectionNoobCh1(ibR, oobR(sset), ctl(sset)$R, getBackgroundR(sset, bgR), offset=offset)
ibG_nl, params_green = normexp_bg_corrected(ibG, oobG, offset, sample_name=container.sample.name)
# <- .backgroundCorrectionNoobCh1(ibG, oobG(sset), ctl(sset)$G, getBackgroundG(sset, bgG), offset=offset)
ibG_nl = ibG_nl.round({'bg_corrected':0})
ibR_nl = ibR_nl.round({'bg_corrected':0})
#print('ibG_nl', ibG_nl.shape)
#print('ibR_nl', ibR_nl.shape)
noob_green = ibG_nl
noob_red = ibR_nl
if debug:
print(f"OOB: Set {oobR_affected} red and {oobG_affected} green to 1.0; shapes: {oobG.shape}, {oobR.shape}")
print(f"noob_red with Grn: {len(noob_red[noob_red['Channel'] == 'Grn'])} noob_green with Red: {len(noob_green[noob_green['Channel'] == 'Red'])}")
ref_IG = ref[(ref['Color_Channel']=='Grn') & (ref['Infinium_Design_Type']=='I')]
ref_IR = ref[(ref['Color_Channel']=='Red') & (ref['Infinium_Design_Type']=='I')]
ref_II = ref[ref['Infinium_Design_Type']=='II'] # II channel is NaN, but BOTH channels have data
print(f"from manifest: ref_IG {ref_IG.shape} ref_IR {ref_IR.shape} ref_II {ref_II.shape}")
# Combine and return red (IG + IR + II_unmeth) and green (IG + IR + II_meth)
# ibR_nl has IlmnID and illumina_id (index); ref has IlmnID as index
# ref_meth/ref_unmeth from probes.py
ref_meth = pd.concat([
ref[(ref['Color_Channel'].isna()) & (ref['Infinium_Design_Type']=='II')]['AddressA_ID'].reset_index().rename(columns={'AddressA_ID':'illumina_id'}),
ref[(ref['Color_Channel']=='Grn') & (ref['Infinium_Design_Type']== 'I')]['AddressB_ID'].reset_index().rename(columns={'AddressB_ID':'illumina_id'}),
ref[(ref['Color_Channel']=='Red') & (ref['Infinium_Design_Type']== 'I')]['AddressB_ID'].reset_index().rename(columns={'AddressB_ID':'illumina_id'}),
]) #.set_index('illumina_id') # .drop('illumina_id', axis=1)
ref_unmeth = pd.concat([
ref[(ref['Color_Channel'].isna()) & (ref['Infinium_Design_Type']=='II')]['AddressA_ID'].reset_index().rename(columns={'AddressA_ID':'illumina_id'}),
ref[(ref['Color_Channel']=='Grn') & (ref['Infinium_Design_Type']== 'I')]['AddressA_ID'].reset_index().rename(columns={'AddressA_ID':'illumina_id'}),
ref[(ref['Color_Channel']=='Red') & (ref['Infinium_Design_Type']== 'I')]['AddressA_ID'].reset_index().rename(columns={'AddressA_ID':'illumina_id'}),
]) #.set_index('illumina_id') # .drop('illumina_id', axis=1)
noob_meth_G = noob_green[noob_green.index.isin(ref_meth['illumina_id'])]
noob_unmeth_G = noob_green[noob_green.index.isin(ref_unmeth['illumina_id'])]
noob_meth_R = noob_red[noob_red.index.isin(ref_meth['illumina_id'])]
noob_unmeth_R = noob_red[noob_red.index.isin(ref_unmeth['illumina_id'])]
noob_meth_dupes = pd.concat([noob_meth_G, noob_meth_R])
noob_unmeth_dupes = pd.concat([noob_unmeth_G, noob_unmeth_R])
# CONFIRMED: this dedupe method below matches sesame's output exactly for noob_meth
noob_meth = (noob_meth_dupes[~noob_meth_dupes.index.duplicated(keep='first')]
.set_index('IlmnID')
.sort_index()
.rename(columns={'bg_corrected':'meth'})
)
# conveniently, the FIRST value of each duplicate probe appears to be the one we want for both meth/unmeth R/G channels
noob_unmeth = (noob_unmeth_dupes[~noob_unmeth_dupes.index.duplicated(keep='first')]
.set_index('IlmnID')
.sort_index()
.rename(columns={'bg_corrected':'unmeth'})
)
# update II, IG, IR, oobR, oobG, ctrl_red, ctrl_green
# --> --> probes.py subsets concatenate these:
# fg_green
# GREEN + AddressA + II
# GREEN + AddressA + IG
# GREEN + AddressB + IG
# oob_green
# RED + AddressA + IR
# fg_red
# RED + AddressA + II
# RED + AddressA + IR
# RED + AddressB + IR
# oob_red
# GREEN + AddressB + IG
#
# methylated
# GREEN + AddressA + II
# GREEN + AddressB + I
# RED + AddressB + I
# unmethylated
# RED + AddressA + II
# GREEN + AddressA + I
# RED + AddressA + I
# RETROFITTING BELOW -- may not work, as sesame works with noob_meth / noob_unmeth instead
try:
container.methylated.set_bg_corrected(noob_green, noob_red)
container.unmethylated.set_bg_corrected(noob_green, noob_red)
container.methylated.set_noob(1.0)
container.unmethylated.set_noob(1.0)
except ValueError as e:
print(e)
if debug:
LOGGER.warning("could not update container methylated / unmethylated noob values, because preprocess_sesame_noob has already run once.")
# output df should have sample meth or unmeth in a column with sample name and IlmnID as index. 485512 rows
if debug:
return {
'noob_meth': noob_meth,
'noob_unmeth': noob_unmeth,
'oobR': oobR,
'oobG': oobG,
'noob_green': noob_green,
'noob_red': noob_red,
'dupe_meth': noob_meth_dupes,
'dupe_unmeth': noob_unmeth_dupes,
}
return # noob_meth, noob_unmeth
"""
|
[
"logging.getLogger",
"numpy.median",
"scipy.stats.norm",
"statsmodels.robust.mad",
"pandas.concat",
"pandas.DataFrame",
"numpy.maximum",
"numpy.seterr"
] |
[((450, 477), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (467, 477), False, 'import logging\n'), ((3266, 3319), 'pandas.DataFrame', 'pd.DataFrame', (['(Rmeth + Runmeth)'], {'columns': "['mean_value']"}), "(Rmeth + Runmeth, columns=['mean_value'])\n", (3278, 3319), True, 'import pandas as pd\n'), ((3556, 3609), 'pandas.DataFrame', 'pd.DataFrame', (['(Gmeth + Gunmeth)'], {'columns': "['mean_value']"}), "(Gmeth + Gunmeth, columns=['mean_value'])\n", (3568, 3609), True, 'import pandas as pd\n'), ((8862, 8895), 'numpy.maximum', 'np.maximum', (['(fg_mean - bg_mean)', '(10)'], {}), '(fg_mean - bg_mean, 10)\n', (8872, 8895), True, 'import numpy as np\n'), ((9820, 9845), 'numpy.seterr', 'np.seterr', ([], {'under': '"""ignore"""'}), "(under='ignore')\n", (9829, 9845), True, 'import numpy as np\n'), ((10964, 10989), 'numpy.maximum', 'np.maximum', (['signal', '(1e-06)'], {}), '(signal, 1e-06)\n', (10974, 10989), True, 'import numpy as np\n'), ((11444, 11462), 'statsmodels.robust.mad', 'robust.mad', (['vector'], {}), '(vector)\n', (11454, 11462), False, 'from statsmodels import robust\n'), ((11482, 11499), 'numpy.median', 'np.median', (['vector'], {}), '(vector)\n', (11491, 11499), True, 'import numpy as np\n'), ((13859, 13881), 'pandas.concat', 'pd.concat', (['[cgs, snps]'], {}), '([cgs, snps])\n', (13868, 13881), True, 'import pandas as pd\n'), ((11671, 11733), 'numpy.maximum', 'np.maximum', (['(local_median - positive_factor * mad_scale)', 'vector'], {}), '(local_median - positive_factor * mad_scale, vector)\n', (11681, 11733), True, 'import numpy as np\n'), ((10491, 10510), 'scipy.stats.norm', 'norm', (['mu_sf', 'bg_mad'], {}), '(mu_sf, bg_mad)\n', (10495, 10510), False, 'from scipy.stats import norm, lognorm\n'), ((10523, 10542), 'scipy.stats.norm', 'norm', (['mu_sf', 'bg_mad'], {}), '(mu_sf, bg_mad)\n', (10527, 10542), False, 'from scipy.stats import norm, lognorm\n')]
|
# Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import logging
from typing import List
import numpy as np
from pydantic import BaseModel, validator
from ray.rllib.agents.dqn import ApexTrainer, R2D2Trainer # noqa
from ray.rllib.agents.impala import ImpalaTrainer # noqa
from ray.rllib.agents.ppo import PPOTrainer # noqa
from compiler_gym.datasets import BenchmarkUri
from compiler_gym.envs import CompilerEnv
from compiler_gym.util.timer import Timer
logger = logging.getLogger(__name__)
class InferenceResult(BaseModel):
"""Represents the result of running an RL agent on a problem."""
# The benchmark URI.
benchmark: str
inference_walltime_seconds: float
commandline: str
episode_len: int
instruction_count_init: int
instruction_count_final: int
instruction_count_oz: int
instruction_count_reduction: float
"""The final instruction count, normalized to -Oz."""
object_size_init: int
object_size_final: int
object_size_oz: int
object_size_reduction: float
"""The final object size, normalized to -Oz."""
runtimes_init: List[float]
runtimes_final: List[float]
runtimes_o3: List[float]
runtime_reduction: float
"""The final runtime, normalized to -Oz."""
@classmethod
def from_agent(
cls, env: CompilerEnv, agent, runtime: bool = True, runtimes_count: int = 30
):
# We calculate our own reward at the end, no need for incremental
# rewards during inference.
env.reward_space = None
# Run inference on the environment.
observation, done = env.reset(), False
with Timer() as inference_timer:
while not done:
action = agent.compute_action(observation)
observation, _, done, _ = env.step(action)
instruction_count_init = env.unwrapped.observation["IrInstructionCountO0"]
instruction_count_final = env.unwrapped.observation["IrInstructionCount"]
instruction_count_oz = env.unwrapped.observation["IrInstructionCountOz"]
object_size_init = env.unwrapped.observation["ObjectTextSizeO0"]
object_size_final = env.unwrapped.observation["ObjectTextSizeBytes"]
object_size_oz = env.unwrapped.observation["ObjectTextSizeOz"]
runtimes_init = []
runtimes_o3 = []
runtimes_final = []
try:
if runtime and env.unwrapped.observation["IsRunnable"]:
env.send_param(
"llvm.set_runtimes_per_observation_count", str(runtimes_count)
)
env.unwrapped.observation["Runtime"] # warmup
runtimes_final = env.unwrapped.observation["Runtime"].tolist()
assert (
len(runtimes_final) == runtimes_count
), f"{len(runtimes_final)} != {runtimes_count}"
env.reset()
env.send_param(
"llvm.set_runtimes_per_observation_count", str(runtimes_count)
)
env.unwrapped.observation["Runtime"] # warmup
runtimes_init = env.unwrapped.observation["Runtime"].tolist()
assert (
len(runtimes_init) == runtimes_count
), f"{len(runtimes_init)} != {runtimes_count}"
env.send_param("llvm.apply_baseline_optimizations", "-O3")
env.unwrapped.observation["Runtime"] # warmup
runtimes_o3 = env.unwrapped.observation["Runtime"].tolist()
assert (
len(runtimes_o3) == runtimes_count
), f"{len(runtimes_o3)} != {runtimes_count}"
except Exception as e: # pylint: disable=broad-except
logger.warning("Failed to compute runtime: %s", e)
return cls(
benchmark=env.benchmark.uri,
inference_walltime_seconds=inference_timer.time,
commandline=env.commandline(),
episode_len=len(env.actions),
instruction_count_init=instruction_count_init,
instruction_count_final=instruction_count_final,
instruction_count_oz=instruction_count_oz,
instruction_count_reduction=instruction_count_oz
/ max(instruction_count_final, 1),
object_size_init=object_size_init,
object_size_final=object_size_final,
object_size_oz=object_size_oz,
object_size_reduction=object_size_oz / max(object_size_final, 1),
runtimes_init=runtimes_init,
runtimes_final=runtimes_final,
runtimes_o3=runtimes_o3,
runtime_reduction=np.median(runtimes_o3 or [0])
/ max(np.median(runtimes_final or [0]), 1),
)
@validator("benchmark", pre=True)
def validate_benchmark(cls, value):
if isinstance(value, BenchmarkUri):
return str(value)
return value
|
[
"logging.getLogger",
"numpy.median",
"compiler_gym.util.timer.Timer",
"pydantic.validator"
] |
[((596, 623), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (613, 623), False, 'import logging\n'), ((4873, 4905), 'pydantic.validator', 'validator', (['"""benchmark"""'], {'pre': '(True)'}), "('benchmark', pre=True)\n", (4882, 4905), False, 'from pydantic import BaseModel, validator\n'), ((1754, 1761), 'compiler_gym.util.timer.Timer', 'Timer', ([], {}), '()\n', (1759, 1761), False, 'from compiler_gym.util.timer import Timer\n'), ((4771, 4800), 'numpy.median', 'np.median', (['(runtimes_o3 or [0])'], {}), '(runtimes_o3 or [0])\n', (4780, 4800), True, 'import numpy as np\n'), ((4819, 4851), 'numpy.median', 'np.median', (['(runtimes_final or [0])'], {}), '(runtimes_final or [0])\n', (4828, 4851), True, 'import numpy as np\n')]
|
"""
TO DO:
1. Lot of edge cases not accounted for
2. Could use some unit testing scripts for sanity check
3. What are the bounds for years?
"""
import mysql
from mysql.connector import Error
import re
import numpy as np
def reject_outliers(data, m = 6.):
d = np.abs(data - np.median(data))
mdev = np.median(d)
s = d/mdev if mdev else 0.
return data[s<m]
def tag_year():
try:
conn = mysql.connector.connect(host='127.0.0.1',port = 3307,database='explorer_db',user='root',password = '')
if conn.is_connected():
print("Connection successful: ",conn.get_server_info())
cur = conn.cursor(buffered = True)
cur1 = conn.cursor()
cur.execute("SELECT event_key,htext FROM event WHERE htext IS NOT NULL AND event_year IS NULL")
count = 0
cent = {"first":"1st","second":"2nd","third":"3rd","fourth":"4th","fifth":"5th","sixth":"6th","seventh":"7th","eighth":"8th","ninth":"9th","tenth":"10th",
"eleventh":"11th","twelfth":"12th","thirteenth":"13th","fourteenth":"14th","fifteenth":"15th",
"sixteenth":"16th","seventeenth":"17th","eighteenth":"18th","nineteenth":"19th","twentieth":"20th","twentyfirst":"21st"}
mylist = list()
for row in cur:
text = row[1].lower()
pos = text.find("references[edit]")
pos2 = text.find("further reading[edit]")
if pos!=0:
sub1 = text[:pos]
sub2 = text[pos2:]
text = sub1+sub2
#print(text,"\n\n")
if "century" in text:
#print("YES\n\n")
mylist = re.findall("\d+[a-z][a-z]\s*-*century",text)
#print(mylist)
sec_list = re.findall("[f,s,t,e,n][a-z][a-z]+\s*-*century",text)
#print(sec_list)
sec_list = [i.replace(i[:i.find(" century")],cent[i[:i.find(" century")]]) for i in sec_list if (i[:i.find(" century")]) in cent]
mylist = mylist+sec_list
#print(mylist)
mylist = [re.sub(r"[a-z][a-z]\s*-*century","00",i) for i in mylist]
#print(mylist)
years = re.findall('([1][0-9][0-9][0-9])',row[1])
years2 = re.findall('([2][0-1][0-2][0-9])',row[1])
years = years+years2 + mylist
if not years:
allyear = "NULL"
else:
allyear = np.array([int(i) for i in years])
allyear = reject_outliers(allyear)
cur1.execute('''UPDATE event set event_year = %s WHERE event_key = %s''',(str(allyear[0]),row[0]))
#print(allyear)
print(len(allyear),count)
count+=1
conn.commit()
cur.close()
cur1.close()
conn.close()
print(count,"rows")
print("Done check database!")
except Error as e:
print("Error while connecting to MySQL", e)
|
[
"re.sub",
"re.findall",
"mysql.connector.connect",
"numpy.median"
] |
[((330, 342), 'numpy.median', 'np.median', (['d'], {}), '(d)\n', (339, 342), True, 'import numpy as np\n'), ((438, 544), 'mysql.connector.connect', 'mysql.connector.connect', ([], {'host': '"""127.0.0.1"""', 'port': '(3307)', 'database': '"""explorer_db"""', 'user': '"""root"""', 'password': '""""""'}), "(host='127.0.0.1', port=3307, database='explorer_db',\n user='root', password='')\n", (461, 544), False, 'import mysql\n'), ((302, 317), 'numpy.median', 'np.median', (['data'], {}), '(data)\n', (311, 317), True, 'import numpy as np\n'), ((2220, 2262), 're.findall', 're.findall', (['"""([1][0-9][0-9][0-9])"""', 'row[1]'], {}), "('([1][0-9][0-9][0-9])', row[1])\n", (2230, 2262), False, 'import re\n'), ((2283, 2325), 're.findall', 're.findall', (['"""([2][0-1][0-2][0-9])"""', 'row[1]'], {}), "('([2][0-1][0-2][0-9])', row[1])\n", (2293, 2325), False, 'import re\n'), ((1664, 1711), 're.findall', 're.findall', (['"""\\\\d+[a-z][a-z]\\\\s*-*century"""', 'text'], {}), "('\\\\d+[a-z][a-z]\\\\s*-*century', text)\n", (1674, 1711), False, 'import re\n'), ((1767, 1822), 're.findall', 're.findall', (['"""[f,s,t,e,n][a-z][a-z]+\\\\s*-*century"""', 'text'], {}), "('[f,s,t,e,n][a-z][a-z]+\\\\s*-*century', text)\n", (1777, 1822), False, 'import re\n'), ((2098, 2140), 're.sub', 're.sub', (['"""[a-z][a-z]\\\\s*-*century"""', '"""00"""', 'i'], {}), "('[a-z][a-z]\\\\s*-*century', '00', i)\n", (2104, 2140), False, 'import re\n')]
|
"""
Implements Pseudo-outcome based Two-step Nets, namely the DR-learner, the PW-learner and the
RA-learner.
"""
# Author: <NAME>
from typing import Callable, Optional, Tuple
import jax.numpy as jnp
import numpy as onp
import pandas as pd
from sklearn.model_selection import StratifiedKFold
import catenets.logger as log
from catenets.models.constants import (
DEFAULT_AVG_OBJECTIVE,
DEFAULT_BATCH_SIZE,
DEFAULT_CF_FOLDS,
DEFAULT_LAYERS_OUT,
DEFAULT_LAYERS_OUT_T,
DEFAULT_LAYERS_R,
DEFAULT_LAYERS_R_T,
DEFAULT_N_ITER,
DEFAULT_N_ITER_MIN,
DEFAULT_N_ITER_PRINT,
DEFAULT_NONLIN,
DEFAULT_PATIENCE,
DEFAULT_PENALTY_L2,
DEFAULT_SEED,
DEFAULT_STEP_SIZE,
DEFAULT_STEP_SIZE_T,
DEFAULT_UNITS_OUT,
DEFAULT_UNITS_OUT_T,
DEFAULT_UNITS_R,
DEFAULT_UNITS_R_T,
DEFAULT_VAL_SPLIT,
)
from catenets.models.jax.base import BaseCATENet, train_output_net_only
from catenets.models.jax.disentangled_nets import predict_snet3, train_snet3
from catenets.models.jax.flextenet import predict_flextenet, train_flextenet
from catenets.models.jax.model_utils import check_shape_1d_data, check_X_is_np
from catenets.models.jax.offsetnet import predict_offsetnet, train_offsetnet
from catenets.models.jax.representation_nets import (
predict_snet1,
predict_snet2,
train_snet1,
train_snet2,
)
from catenets.models.jax.snet import predict_snet, train_snet
from catenets.models.jax.tnet import predict_t_net, train_tnet
from catenets.models.jax.transformation_utils import (
DR_TRANSFORMATION,
PW_TRANSFORMATION,
RA_TRANSFORMATION,
_get_transformation_function,
)
T_STRATEGY = "T"
S1_STRATEGY = "Tar"
S2_STRATEGY = "S2"
S3_STRATEGY = "S3"
S_STRATEGY = "S"
OFFSET_STRATEGY = "Offset"
FLEX_STRATEGY = "Flex"
ALL_STRATEGIES = [
T_STRATEGY,
S1_STRATEGY,
S2_STRATEGY,
S3_STRATEGY,
S_STRATEGY,
FLEX_STRATEGY,
OFFSET_STRATEGY,
]
class PseudoOutcomeNet(BaseCATENet):
"""
Class implements TwoStepLearners based on pseudo-outcome regression as discussed in
Curth &<NAME> (2021): RA-learner, PW-learner and DR-learner
Parameters
----------
first_stage_strategy: str, default 't'
which nuisance estimator to use in first stage
first_stage_args: dict
Any additional arguments to pass to first stage training function
data_split: bool, default False
Whether to split the data in two folds for estimation
cross_fit: bool, default False
Whether to perform cross fitting
n_cf_folds: int
Number of crossfitting folds to use
transformation: str, default 'AIPW'
pseudo-outcome to use ('AIPW' for DR-learner, 'HT' for PW learner, 'RA' for RA-learner)
binary_y: bool, default False
Whether the outcome is binary
n_layers_out: int
First stage Number of hypothesis layers (n_layers_out x n_units_out + 1 x Dense layer)
n_units_out: int
First stage Number of hidden units in each hypothesis layer
n_layers_r: int
First stage Number of representation layers before hypothesis layers (distinction between
hypothesis layers and representation layers is made to match TARNet & SNets)
n_units_r: int
First stage Number of hidden units in each representation layer
n_layers_out_t: int
Second stage Number of hypothesis layers (n_layers_out x n_units_out + 1 x Dense layer)
n_units_out_t: int
Second stage Number of hidden units in each hypothesis layer
n_layers_r_t: int
Second stage Number of representation layers before hypothesis layers (distinction between
hypothesis layers and representation layers is made to match TARNet & SNets)
n_units_r_t: int
Second stage Number of hidden units in each representation layer
penalty_l2: float
First stage l2 (ridge) penalty
penalty_l2_t: float
Second stage l2 (ridge) penalty
step_size: float
First stage learning rate for optimizer
step_size_t: float
Second stage learning rate for optimizer
n_iter: int
Maximum number of iterations
batch_size: int
Batch size
val_split_prop: float
Proportion of samples used for validation split (can be 0)
early_stopping: bool, default True
Whether to use early stopping
patience: int
Number of iterations to wait before early stopping after decrease in validation loss
n_iter_min: int
Minimum number of iterations to go through before starting early stopping
n_iter_print: int
Number of iterations after which to print updates
seed: int
Seed used
nonlin: string, default 'elu'
Nonlinearity to use in NN
"""
def __init__(
self,
first_stage_strategy: str = T_STRATEGY,
first_stage_args: Optional[dict] = None,
data_split: bool = False,
cross_fit: bool = False,
n_cf_folds: int = DEFAULT_CF_FOLDS,
transformation: str = DR_TRANSFORMATION,
binary_y: bool = False,
n_layers_out: int = DEFAULT_LAYERS_OUT,
n_layers_r: int = DEFAULT_LAYERS_R,
n_layers_out_t: int = DEFAULT_LAYERS_OUT_T,
n_layers_r_t: int = DEFAULT_LAYERS_R_T,
n_units_out: int = DEFAULT_UNITS_OUT,
n_units_r: int = DEFAULT_UNITS_R,
n_units_out_t: int = DEFAULT_UNITS_OUT_T,
n_units_r_t: int = DEFAULT_UNITS_R_T,
penalty_l2: float = DEFAULT_PENALTY_L2,
penalty_l2_t: float = DEFAULT_PENALTY_L2,
step_size: float = DEFAULT_STEP_SIZE,
step_size_t: float = DEFAULT_STEP_SIZE_T,
n_iter: int = DEFAULT_N_ITER,
batch_size: int = DEFAULT_BATCH_SIZE,
n_iter_min: int = DEFAULT_N_ITER_MIN,
val_split_prop: float = DEFAULT_VAL_SPLIT,
early_stopping: bool = True,
patience: int = DEFAULT_PATIENCE,
n_iter_print: int = DEFAULT_N_ITER_PRINT,
seed: int = DEFAULT_SEED,
rescale_transformation: bool = False,
nonlin: str = DEFAULT_NONLIN,
) -> None:
# settings
self.first_stage_strategy = first_stage_strategy
self.first_stage_args = first_stage_args
self.binary_y = binary_y
self.transformation = transformation
self.data_split = data_split
self.cross_fit = cross_fit
self.n_cf_folds = n_cf_folds
# model architecture hyperparams
self.n_layers_out = n_layers_out
self.n_layers_out_t = n_layers_out_t
self.n_layers_r = n_layers_r
self.n_layers_r_t = n_layers_r_t
self.n_units_out = n_units_out
self.n_units_out_t = n_units_out_t
self.n_units_r = n_units_r
self.n_units_r_t = n_units_r_t
self.nonlin = nonlin
# other hyperparameters
self.penalty_l2 = penalty_l2
self.penalty_l2_t = penalty_l2_t
self.step_size = step_size
self.step_size_t = step_size_t
self.n_iter = n_iter
self.batch_size = batch_size
self.n_iter_print = n_iter_print
self.seed = seed
self.val_split_prop = val_split_prop
self.early_stopping = early_stopping
self.patience = patience
self.n_iter_min = n_iter_min
self.rescale_transformation = rescale_transformation
def _get_train_function(self) -> Callable:
return train_pseudooutcome_net
def fit(
self,
X: jnp.ndarray,
y: jnp.ndarray,
w: jnp.ndarray,
p: Optional[jnp.ndarray] = None,
) -> "PseudoOutcomeNet":
# overwrite super so we can pass p as extra param
# some quick input checks
X = check_X_is_np(X)
self._check_inputs(w, p)
train_func = self._get_train_function()
train_params = self.get_params()
if "transformation" not in train_params.keys():
train_params.update({"transformation": self.transformation})
if self.rescale_transformation:
self._params, self._predict_funs, self._scale_factor = train_func(
X, y, w, p, **train_params
)
else:
self._params, self._predict_funs = train_func(X, y, w, p, **train_params)
return self
def _get_predict_function(self) -> Callable:
# Two step nets do not need this
pass
def predict(
self, X: jnp.ndarray, return_po: bool = False, return_prop: bool = False
) -> jnp.ndarray:
# check input
if return_po:
raise NotImplementedError(
"TwoStepNets have no Potential outcome predictors."
)
if return_prop:
raise NotImplementedError("TwoStepNets have no Propensity predictors.")
if isinstance(X, pd.DataFrame):
X = X.values
if self.rescale_transformation:
return 1 / self._scale_factor * self._predict_funs(self._params, X)
else:
return self._predict_funs(self._params, X)
class DRNet(PseudoOutcomeNet):
"""Wrapper for DR-learner using PseudoOutcomeNet"""
def __init__(
self,
first_stage_strategy: str = T_STRATEGY,
data_split: bool = False,
cross_fit: bool = False,
n_cf_folds: int = DEFAULT_CF_FOLDS,
binary_y: bool = False,
n_layers_out: int = DEFAULT_LAYERS_OUT,
n_layers_r: int = DEFAULT_LAYERS_R,
n_layers_out_t: int = DEFAULT_LAYERS_OUT_T,
n_layers_r_t: int = DEFAULT_LAYERS_R_T,
n_units_out: int = DEFAULT_UNITS_OUT,
n_units_r: int = DEFAULT_UNITS_R,
n_units_out_t: int = DEFAULT_UNITS_OUT_T,
n_units_r_t: int = DEFAULT_UNITS_R_T,
penalty_l2: float = DEFAULT_PENALTY_L2,
penalty_l2_t: float = DEFAULT_PENALTY_L2,
step_size: float = DEFAULT_STEP_SIZE,
step_size_t: float = DEFAULT_STEP_SIZE_T,
n_iter: int = DEFAULT_N_ITER,
batch_size: int = DEFAULT_BATCH_SIZE,
n_iter_min: int = DEFAULT_N_ITER_MIN,
val_split_prop: float = DEFAULT_VAL_SPLIT,
early_stopping: bool = True,
patience: int = DEFAULT_PATIENCE,
n_iter_print: int = DEFAULT_N_ITER_PRINT,
seed: int = DEFAULT_SEED,
rescale_transformation: bool = False,
nonlin: str = DEFAULT_NONLIN,
first_stage_args: Optional[dict] = None,
) -> None:
super().__init__(
first_stage_strategy=first_stage_strategy,
data_split=data_split,
cross_fit=cross_fit,
n_cf_folds=n_cf_folds,
transformation=DR_TRANSFORMATION,
binary_y=binary_y,
n_layers_out=n_layers_out,
n_layers_r=n_layers_r,
n_layers_out_t=n_layers_out_t,
n_layers_r_t=n_layers_r_t,
n_units_out=n_units_out,
n_units_r=n_units_r,
n_units_out_t=n_units_out_t,
n_units_r_t=n_units_r_t,
penalty_l2=penalty_l2,
penalty_l2_t=penalty_l2_t,
step_size=step_size,
step_size_t=step_size_t,
n_iter=n_iter,
batch_size=batch_size,
n_iter_min=n_iter_min,
val_split_prop=val_split_prop,
early_stopping=early_stopping,
patience=patience,
n_iter_print=n_iter_print,
seed=seed,
nonlin=nonlin,
rescale_transformation=rescale_transformation,
first_stage_args=first_stage_args,
)
class RANet(PseudoOutcomeNet):
"""Wrapper for RA-learner using PseudoOutcomeNet"""
def __init__(
self,
first_stage_strategy: str = T_STRATEGY,
data_split: bool = False,
cross_fit: bool = False,
n_cf_folds: int = DEFAULT_CF_FOLDS,
binary_y: bool = False,
n_layers_out: int = DEFAULT_LAYERS_OUT,
n_layers_r: int = DEFAULT_LAYERS_R,
n_layers_out_t: int = DEFAULT_LAYERS_OUT_T,
n_layers_r_t: int = DEFAULT_LAYERS_R_T,
n_units_out: int = DEFAULT_UNITS_OUT,
n_units_r: int = DEFAULT_UNITS_R,
n_units_out_t: int = DEFAULT_UNITS_OUT_T,
n_units_r_t: int = DEFAULT_UNITS_R_T,
penalty_l2: float = DEFAULT_PENALTY_L2,
penalty_l2_t: float = DEFAULT_PENALTY_L2,
step_size: float = DEFAULT_STEP_SIZE,
step_size_t: float = DEFAULT_STEP_SIZE_T,
n_iter: int = DEFAULT_N_ITER,
batch_size: int = DEFAULT_BATCH_SIZE,
n_iter_min: int = DEFAULT_N_ITER_MIN,
val_split_prop: float = DEFAULT_VAL_SPLIT,
early_stopping: bool = True,
patience: int = DEFAULT_PATIENCE,
n_iter_print: int = DEFAULT_N_ITER_PRINT,
seed: int = DEFAULT_SEED,
rescale_transformation: bool = False,
nonlin: str = DEFAULT_NONLIN,
first_stage_args: Optional[dict] = None,
) -> None:
super().__init__(
first_stage_strategy=first_stage_strategy,
data_split=data_split,
cross_fit=cross_fit,
n_cf_folds=n_cf_folds,
transformation=RA_TRANSFORMATION,
binary_y=binary_y,
n_layers_out=n_layers_out,
n_layers_r=n_layers_r,
n_layers_out_t=n_layers_out_t,
n_layers_r_t=n_layers_r_t,
n_units_out=n_units_out,
n_units_r=n_units_r,
n_units_out_t=n_units_out_t,
n_units_r_t=n_units_r_t,
penalty_l2=penalty_l2,
penalty_l2_t=penalty_l2_t,
step_size=step_size,
step_size_t=step_size_t,
n_iter=n_iter,
batch_size=batch_size,
n_iter_min=n_iter_min,
val_split_prop=val_split_prop,
early_stopping=early_stopping,
patience=patience,
n_iter_print=n_iter_print,
seed=seed,
nonlin=nonlin,
rescale_transformation=rescale_transformation,
first_stage_args=first_stage_args,
)
class PWNet(PseudoOutcomeNet):
"""Wrapper for PW-learner using PseudoOutcomeNet"""
def __init__(
self,
first_stage_strategy: str = T_STRATEGY,
data_split: bool = False,
cross_fit: bool = False,
n_cf_folds: int = DEFAULT_CF_FOLDS,
binary_y: bool = False,
n_layers_out: int = DEFAULT_LAYERS_OUT,
n_layers_r: int = DEFAULT_LAYERS_R,
n_layers_out_t: int = DEFAULT_LAYERS_OUT_T,
n_layers_r_t: int = DEFAULT_LAYERS_R_T,
n_units_out: int = DEFAULT_UNITS_OUT,
n_units_r: int = DEFAULT_UNITS_R,
n_units_out_t: int = DEFAULT_UNITS_OUT_T,
n_units_r_t: int = DEFAULT_UNITS_R_T,
penalty_l2: float = DEFAULT_PENALTY_L2,
penalty_l2_t: float = DEFAULT_PENALTY_L2,
step_size: float = DEFAULT_STEP_SIZE,
step_size_t: float = DEFAULT_STEP_SIZE_T,
n_iter: int = DEFAULT_N_ITER,
batch_size: int = DEFAULT_BATCH_SIZE,
n_iter_min: int = DEFAULT_N_ITER_MIN,
val_split_prop: float = DEFAULT_VAL_SPLIT,
early_stopping: bool = True,
patience: int = DEFAULT_PATIENCE,
n_iter_print: int = DEFAULT_N_ITER_PRINT,
seed: int = DEFAULT_SEED,
rescale_transformation: bool = False,
nonlin: str = DEFAULT_NONLIN,
first_stage_args: Optional[dict] = None,
) -> None:
super().__init__(
first_stage_strategy=first_stage_strategy,
data_split=data_split,
cross_fit=cross_fit,
n_cf_folds=n_cf_folds,
transformation=PW_TRANSFORMATION,
binary_y=binary_y,
n_layers_out=n_layers_out,
n_layers_r=n_layers_r,
n_layers_out_t=n_layers_out_t,
n_layers_r_t=n_layers_r_t,
n_units_out=n_units_out,
n_units_r=n_units_r,
n_units_out_t=n_units_out_t,
n_units_r_t=n_units_r_t,
penalty_l2=penalty_l2,
penalty_l2_t=penalty_l2_t,
step_size=step_size,
step_size_t=step_size_t,
n_iter=n_iter,
batch_size=batch_size,
n_iter_min=n_iter_min,
val_split_prop=val_split_prop,
early_stopping=early_stopping,
patience=patience,
n_iter_print=n_iter_print,
seed=seed,
nonlin=nonlin,
rescale_transformation=rescale_transformation,
first_stage_args=first_stage_args,
)
def train_pseudooutcome_net(
X: jnp.ndarray,
y: jnp.ndarray,
w: jnp.ndarray,
p: Optional[jnp.ndarray] = None,
first_stage_strategy: str = T_STRATEGY,
data_split: bool = False,
cross_fit: bool = False,
n_cf_folds: int = DEFAULT_CF_FOLDS,
transformation: str = DR_TRANSFORMATION,
binary_y: bool = False,
n_layers_out: int = DEFAULT_LAYERS_OUT,
n_layers_r: int = DEFAULT_LAYERS_R,
n_layers_r_t: int = DEFAULT_LAYERS_R_T,
n_layers_out_t: int = DEFAULT_LAYERS_OUT_T,
n_units_out: int = DEFAULT_UNITS_OUT,
n_units_r: int = DEFAULT_UNITS_R,
n_units_out_t: int = DEFAULT_UNITS_OUT_T,
n_units_r_t: int = DEFAULT_UNITS_R_T,
penalty_l2: float = DEFAULT_PENALTY_L2,
penalty_l2_t: float = DEFAULT_PENALTY_L2,
step_size: float = DEFAULT_STEP_SIZE,
step_size_t: float = DEFAULT_STEP_SIZE_T,
n_iter: int = DEFAULT_N_ITER,
batch_size: int = DEFAULT_BATCH_SIZE,
val_split_prop: float = DEFAULT_VAL_SPLIT,
early_stopping: bool = True,
patience: int = DEFAULT_PATIENCE,
n_iter_min: int = DEFAULT_N_ITER_MIN,
n_iter_print: int = DEFAULT_N_ITER_PRINT,
seed: int = DEFAULT_SEED,
rescale_transformation: bool = False,
return_val_loss: bool = False,
nonlin: str = DEFAULT_NONLIN,
avg_objective: bool = DEFAULT_AVG_OBJECTIVE,
first_stage_args: Optional[dict] = None,
) -> Tuple:
# get shape of data
n, d = X.shape
if p is not None:
p = check_shape_1d_data(p)
# get transformation function
transformation_function = _get_transformation_function(transformation)
# get strategy name
if first_stage_strategy not in ALL_STRATEGIES:
raise ValueError(
"Parameter first stage should be in "
"catenets.models.pseudo_outcome_nets.ALL_STRATEGIES. "
"You passed {}".format(first_stage_strategy)
)
# split data as wanted
if p is None or transformation is not PW_TRANSFORMATION:
if not cross_fit:
if not data_split:
log.debug("Training first stage with all data (no data splitting)")
# use all data for both
fit_mask = onp.ones(n, dtype=bool)
pred_mask = onp.ones(n, dtype=bool)
else:
log.debug("Training first stage with half of the data (data splitting)")
# split data in half
fit_idx = onp.random.choice(n, int(onp.round(n / 2)))
fit_mask = onp.zeros(n, dtype=bool)
fit_mask[fit_idx] = 1
pred_mask = ~fit_mask
mu_0, mu_1, pi_hat = _train_and_predict_first_stage(
X,
y,
w,
fit_mask,
pred_mask,
first_stage_strategy=first_stage_strategy,
binary_y=binary_y,
n_layers_out=n_layers_out,
n_layers_r=n_layers_r,
n_units_out=n_units_out,
n_units_r=n_units_r,
penalty_l2=penalty_l2,
step_size=step_size,
n_iter=n_iter,
batch_size=batch_size,
val_split_prop=val_split_prop,
early_stopping=early_stopping,
patience=patience,
n_iter_min=n_iter_min,
n_iter_print=n_iter_print,
seed=seed,
nonlin=nonlin,
avg_objective=avg_objective,
transformation=transformation,
first_stage_args=first_stage_args,
)
if data_split:
# keep only prediction data
X, y, w = X[pred_mask, :], y[pred_mask, :], w[pred_mask, :]
if p is not None:
p = p[pred_mask, :]
else:
log.debug(f"Training first stage in {n_cf_folds} folds (cross-fitting)")
# do cross fitting
mu_0, mu_1, pi_hat = onp.zeros((n, 1)), onp.zeros((n, 1)), onp.zeros((n, 1))
splitter = StratifiedKFold(
n_splits=n_cf_folds, shuffle=True, random_state=seed
)
fold_count = 1
for train_idx, test_idx in splitter.split(X, w):
log.debug(f"Training fold {fold_count}.")
fold_count = fold_count + 1
pred_mask = onp.zeros(n, dtype=bool)
pred_mask[test_idx] = 1
fit_mask = ~pred_mask
(
mu_0[pred_mask],
mu_1[pred_mask],
pi_hat[pred_mask],
) = _train_and_predict_first_stage(
X,
y,
w,
fit_mask,
pred_mask,
first_stage_strategy=first_stage_strategy,
binary_y=binary_y,
n_layers_out=n_layers_out,
n_layers_r=n_layers_r,
n_units_out=n_units_out,
n_units_r=n_units_r,
penalty_l2=penalty_l2,
step_size=step_size,
n_iter=n_iter,
batch_size=batch_size,
val_split_prop=val_split_prop,
early_stopping=early_stopping,
patience=patience,
n_iter_min=n_iter_min,
n_iter_print=n_iter_print,
seed=seed,
nonlin=nonlin,
avg_objective=avg_objective,
transformation=transformation,
first_stage_args=first_stage_args,
)
log.debug("Training second stage.")
if p is not None:
# use known propensity score
p = check_shape_1d_data(p)
pi_hat = p
# second stage
y, w = check_shape_1d_data(y), check_shape_1d_data(w)
# transform data and fit on transformed data
if transformation is PW_TRANSFORMATION:
mu_0 = None
mu_1 = None
pseudo_outcome = transformation_function(y=y, w=w, p=pi_hat, mu_0=mu_0, mu_1=mu_1)
if rescale_transformation:
scale_factor = onp.std(y) / onp.std(pseudo_outcome)
if scale_factor > 1:
scale_factor = 1
else:
pseudo_outcome = scale_factor * pseudo_outcome
params, predict_funs = train_output_net_only(
X,
pseudo_outcome,
binary_y=False,
n_layers_out=n_layers_out_t,
n_units_out=n_units_out_t,
n_layers_r=n_layers_r_t,
n_units_r=n_units_r_t,
penalty_l2=penalty_l2_t,
step_size=step_size_t,
n_iter=n_iter,
batch_size=batch_size,
val_split_prop=val_split_prop,
early_stopping=early_stopping,
patience=patience,
n_iter_min=n_iter_min,
n_iter_print=n_iter_print,
seed=seed,
return_val_loss=return_val_loss,
nonlin=nonlin,
avg_objective=avg_objective,
)
return params, predict_funs, scale_factor
else:
return train_output_net_only(
X,
pseudo_outcome,
binary_y=False,
n_layers_out=n_layers_out_t,
n_units_out=n_units_out_t,
n_layers_r=n_layers_r_t,
n_units_r=n_units_r_t,
penalty_l2=penalty_l2_t,
step_size=step_size_t,
n_iter=n_iter,
batch_size=batch_size,
val_split_prop=val_split_prop,
early_stopping=early_stopping,
patience=patience,
n_iter_min=n_iter_min,
n_iter_print=n_iter_print,
seed=seed,
return_val_loss=return_val_loss,
nonlin=nonlin,
avg_objective=avg_objective,
)
def _train_and_predict_first_stage(
X: jnp.ndarray,
y: jnp.ndarray,
w: jnp.ndarray,
fit_mask: jnp.ndarray,
pred_mask: jnp.ndarray,
first_stage_strategy: str,
binary_y: bool = False,
n_layers_out: int = DEFAULT_LAYERS_OUT,
n_layers_r: int = DEFAULT_LAYERS_R,
n_units_out: int = DEFAULT_UNITS_OUT,
n_units_r: int = DEFAULT_UNITS_R,
penalty_l2: float = DEFAULT_PENALTY_L2,
step_size: float = DEFAULT_STEP_SIZE,
n_iter: int = DEFAULT_N_ITER,
batch_size: int = DEFAULT_BATCH_SIZE,
val_split_prop: float = DEFAULT_VAL_SPLIT,
early_stopping: bool = True,
patience: int = DEFAULT_PATIENCE,
n_iter_min: int = DEFAULT_N_ITER_MIN,
n_iter_print: int = DEFAULT_N_ITER_PRINT,
seed: int = DEFAULT_SEED,
nonlin: str = DEFAULT_NONLIN,
avg_objective: bool = False,
transformation: str = DR_TRANSFORMATION,
first_stage_args: Optional[dict] = None,
) -> Tuple:
if len(w.shape) > 1:
w = w.reshape((len(w),))
if first_stage_args is None:
first_stage_args = {}
# split the data
X_fit, y_fit, w_fit = X[fit_mask, :], y[fit_mask], w[fit_mask]
X_pred = X[pred_mask, :]
train_fun: Callable
predict_fun: Callable
if first_stage_strategy == T_STRATEGY:
train_fun, predict_fun = train_tnet, predict_t_net
elif first_stage_strategy == S_STRATEGY:
train_fun, predict_fun = train_snet, predict_snet
elif first_stage_strategy == S1_STRATEGY:
train_fun, predict_fun = train_snet1, predict_snet1
elif first_stage_strategy == S2_STRATEGY:
train_fun, predict_fun = train_snet2, predict_snet2
elif first_stage_strategy == S3_STRATEGY:
train_fun, predict_fun = train_snet3, predict_snet3
elif first_stage_strategy == OFFSET_STRATEGY:
train_fun, predict_fun = train_offsetnet, predict_offsetnet
elif first_stage_strategy == FLEX_STRATEGY:
train_fun, predict_fun = train_flextenet, predict_flextenet
else:
raise ValueError(
"{} is not a valid first stage strategy for a PseudoOutcomeNet".format(
first_stage_strategy
)
)
log.debug("Training PO estimators")
trained_params, pred_fun = train_fun(
X_fit,
y_fit,
w_fit,
binary_y=binary_y,
n_layers_r=n_layers_r,
n_units_r=n_units_r,
n_layers_out=n_layers_out,
n_units_out=n_units_out,
penalty_l2=penalty_l2,
step_size=step_size,
n_iter=n_iter,
batch_size=batch_size,
val_split_prop=val_split_prop,
early_stopping=early_stopping,
patience=patience,
n_iter_min=n_iter_min,
n_iter_print=n_iter_print,
seed=seed,
nonlin=nonlin,
avg_objective=avg_objective,
**first_stage_args,
)
if first_stage_strategy in [S_STRATEGY, S2_STRATEGY, S3_STRATEGY]:
_, mu_0, mu_1, pi_hat = predict_fun(
X_pred, trained_params, pred_fun, return_po=True, return_prop=True
)
else:
if transformation is not PW_TRANSFORMATION:
_, mu_0, mu_1 = predict_fun(
X_pred, trained_params, pred_fun, return_po=True
)
else:
mu_0, mu_1 = onp.nan, onp.nan
if transformation is not RA_TRANSFORMATION:
log.debug("Training propensity net")
params_prop, predict_fun_prop = train_output_net_only(
X_fit,
w_fit,
binary_y=True,
n_layers_out=n_layers_out,
n_units_out=n_units_out,
n_layers_r=n_layers_r,
n_units_r=n_units_r,
penalty_l2=penalty_l2,
step_size=step_size,
n_iter=n_iter,
batch_size=batch_size,
val_split_prop=val_split_prop,
early_stopping=early_stopping,
patience=patience,
n_iter_min=n_iter_min,
n_iter_print=n_iter_print,
seed=seed,
nonlin=nonlin,
avg_objective=avg_objective,
)
pi_hat = predict_fun_prop(params_prop, X_pred)
else:
pi_hat = onp.nan
return mu_0, mu_1, pi_hat
|
[
"catenets.logger.debug",
"catenets.models.jax.model_utils.check_shape_1d_data",
"numpy.ones",
"catenets.models.jax.transformation_utils._get_transformation_function",
"sklearn.model_selection.StratifiedKFold",
"numpy.zeros",
"numpy.std",
"catenets.models.jax.base.train_output_net_only",
"numpy.round",
"catenets.models.jax.model_utils.check_X_is_np"
] |
[((18080, 18124), 'catenets.models.jax.transformation_utils._get_transformation_function', '_get_transformation_function', (['transformation'], {}), '(transformation)\n', (18108, 18124), False, 'from catenets.models.jax.transformation_utils import DR_TRANSFORMATION, PW_TRANSFORMATION, RA_TRANSFORMATION, _get_transformation_function\n'), ((22247, 22282), 'catenets.logger.debug', 'log.debug', (['"""Training second stage."""'], {}), "('Training second stage.')\n", (22256, 22282), True, 'import catenets.logger as log\n'), ((26636, 26671), 'catenets.logger.debug', 'log.debug', (['"""Training PO estimators"""'], {}), "('Training PO estimators')\n", (26645, 26671), True, 'import catenets.logger as log\n'), ((7687, 7703), 'catenets.models.jax.model_utils.check_X_is_np', 'check_X_is_np', (['X'], {}), '(X)\n', (7700, 7703), False, 'from catenets.models.jax.model_utils import check_shape_1d_data, check_X_is_np\n'), ((17992, 18014), 'catenets.models.jax.model_utils.check_shape_1d_data', 'check_shape_1d_data', (['p'], {}), '(p)\n', (18011, 18014), False, 'from catenets.models.jax.model_utils import check_shape_1d_data, check_X_is_np\n'), ((22355, 22377), 'catenets.models.jax.model_utils.check_shape_1d_data', 'check_shape_1d_data', (['p'], {}), '(p)\n', (22374, 22377), False, 'from catenets.models.jax.model_utils import check_shape_1d_data, check_X_is_np\n'), ((22428, 22450), 'catenets.models.jax.model_utils.check_shape_1d_data', 'check_shape_1d_data', (['y'], {}), '(y)\n', (22447, 22450), False, 'from catenets.models.jax.model_utils import check_shape_1d_data, check_X_is_np\n'), ((22452, 22474), 'catenets.models.jax.model_utils.check_shape_1d_data', 'check_shape_1d_data', (['w'], {}), '(w)\n', (22471, 22474), False, 'from catenets.models.jax.model_utils import check_shape_1d_data, check_X_is_np\n'), ((22949, 23439), 'catenets.models.jax.base.train_output_net_only', 'train_output_net_only', (['X', 'pseudo_outcome'], {'binary_y': '(False)', 'n_layers_out': 'n_layers_out_t', 'n_units_out': 'n_units_out_t', 'n_layers_r': 'n_layers_r_t', 'n_units_r': 'n_units_r_t', 'penalty_l2': 'penalty_l2_t', 'step_size': 'step_size_t', 'n_iter': 'n_iter', 'batch_size': 'batch_size', 'val_split_prop': 'val_split_prop', 'early_stopping': 'early_stopping', 'patience': 'patience', 'n_iter_min': 'n_iter_min', 'n_iter_print': 'n_iter_print', 'seed': 'seed', 'return_val_loss': 'return_val_loss', 'nonlin': 'nonlin', 'avg_objective': 'avg_objective'}), '(X, pseudo_outcome, binary_y=False, n_layers_out=\n n_layers_out_t, n_units_out=n_units_out_t, n_layers_r=n_layers_r_t,\n n_units_r=n_units_r_t, penalty_l2=penalty_l2_t, step_size=step_size_t,\n n_iter=n_iter, batch_size=batch_size, val_split_prop=val_split_prop,\n early_stopping=early_stopping, patience=patience, n_iter_min=n_iter_min,\n n_iter_print=n_iter_print, seed=seed, return_val_loss=return_val_loss,\n nonlin=nonlin, avg_objective=avg_objective)\n', (22970, 23439), False, 'from catenets.models.jax.base import BaseCATENet, train_output_net_only\n'), ((23741, 24231), 'catenets.models.jax.base.train_output_net_only', 'train_output_net_only', (['X', 'pseudo_outcome'], {'binary_y': '(False)', 'n_layers_out': 'n_layers_out_t', 'n_units_out': 'n_units_out_t', 'n_layers_r': 'n_layers_r_t', 'n_units_r': 'n_units_r_t', 'penalty_l2': 'penalty_l2_t', 'step_size': 'step_size_t', 'n_iter': 'n_iter', 'batch_size': 'batch_size', 'val_split_prop': 'val_split_prop', 'early_stopping': 'early_stopping', 'patience': 'patience', 'n_iter_min': 'n_iter_min', 'n_iter_print': 'n_iter_print', 'seed': 'seed', 'return_val_loss': 'return_val_loss', 'nonlin': 'nonlin', 'avg_objective': 'avg_objective'}), '(X, pseudo_outcome, binary_y=False, n_layers_out=\n n_layers_out_t, n_units_out=n_units_out_t, n_layers_r=n_layers_r_t,\n n_units_r=n_units_r_t, penalty_l2=penalty_l2_t, step_size=step_size_t,\n n_iter=n_iter, batch_size=batch_size, val_split_prop=val_split_prop,\n early_stopping=early_stopping, patience=patience, n_iter_min=n_iter_min,\n n_iter_print=n_iter_print, seed=seed, return_val_loss=return_val_loss,\n nonlin=nonlin, avg_objective=avg_objective)\n', (23762, 24231), False, 'from catenets.models.jax.base import BaseCATENet, train_output_net_only\n'), ((20378, 20450), 'catenets.logger.debug', 'log.debug', (['f"""Training first stage in {n_cf_folds} folds (cross-fitting)"""'], {}), "(f'Training first stage in {n_cf_folds} folds (cross-fitting)')\n", (20387, 20450), True, 'import catenets.logger as log\n'), ((20594, 20663), 'sklearn.model_selection.StratifiedKFold', 'StratifiedKFold', ([], {'n_splits': 'n_cf_folds', 'shuffle': '(True)', 'random_state': 'seed'}), '(n_splits=n_cf_folds, shuffle=True, random_state=seed)\n', (20609, 20663), False, 'from sklearn.model_selection import StratifiedKFold\n'), ((22750, 22760), 'numpy.std', 'onp.std', (['y'], {}), '(y)\n', (22757, 22760), True, 'import numpy as onp\n'), ((22763, 22786), 'numpy.std', 'onp.std', (['pseudo_outcome'], {}), '(pseudo_outcome)\n', (22770, 22786), True, 'import numpy as onp\n'), ((27821, 27857), 'catenets.logger.debug', 'log.debug', (['"""Training propensity net"""'], {}), "('Training propensity net')\n", (27830, 27857), True, 'import catenets.logger as log\n'), ((27902, 28340), 'catenets.models.jax.base.train_output_net_only', 'train_output_net_only', (['X_fit', 'w_fit'], {'binary_y': '(True)', 'n_layers_out': 'n_layers_out', 'n_units_out': 'n_units_out', 'n_layers_r': 'n_layers_r', 'n_units_r': 'n_units_r', 'penalty_l2': 'penalty_l2', 'step_size': 'step_size', 'n_iter': 'n_iter', 'batch_size': 'batch_size', 'val_split_prop': 'val_split_prop', 'early_stopping': 'early_stopping', 'patience': 'patience', 'n_iter_min': 'n_iter_min', 'n_iter_print': 'n_iter_print', 'seed': 'seed', 'nonlin': 'nonlin', 'avg_objective': 'avg_objective'}), '(X_fit, w_fit, binary_y=True, n_layers_out=\n n_layers_out, n_units_out=n_units_out, n_layers_r=n_layers_r, n_units_r\n =n_units_r, penalty_l2=penalty_l2, step_size=step_size, n_iter=n_iter,\n batch_size=batch_size, val_split_prop=val_split_prop, early_stopping=\n early_stopping, patience=patience, n_iter_min=n_iter_min, n_iter_print=\n n_iter_print, seed=seed, nonlin=nonlin, avg_objective=avg_objective)\n', (27923, 28340), False, 'from catenets.models.jax.base import BaseCATENet, train_output_net_only\n'), ((18573, 18640), 'catenets.logger.debug', 'log.debug', (['"""Training first stage with all data (no data splitting)"""'], {}), "('Training first stage with all data (no data splitting)')\n", (18582, 18640), True, 'import catenets.logger as log\n'), ((18708, 18731), 'numpy.ones', 'onp.ones', (['n'], {'dtype': 'bool'}), '(n, dtype=bool)\n', (18716, 18731), True, 'import numpy as onp\n'), ((18760, 18783), 'numpy.ones', 'onp.ones', (['n'], {'dtype': 'bool'}), '(n, dtype=bool)\n', (18768, 18783), True, 'import numpy as onp\n'), ((18818, 18890), 'catenets.logger.debug', 'log.debug', (['"""Training first stage with half of the data (data splitting)"""'], {}), "('Training first stage with half of the data (data splitting)')\n", (18827, 18890), True, 'import catenets.logger as log\n'), ((19025, 19049), 'numpy.zeros', 'onp.zeros', (['n'], {'dtype': 'bool'}), '(n, dtype=bool)\n', (19034, 19049), True, 'import numpy as onp\n'), ((20515, 20532), 'numpy.zeros', 'onp.zeros', (['(n, 1)'], {}), '((n, 1))\n', (20524, 20532), True, 'import numpy as onp\n'), ((20534, 20551), 'numpy.zeros', 'onp.zeros', (['(n, 1)'], {}), '((n, 1))\n', (20543, 20551), True, 'import numpy as onp\n'), ((20553, 20570), 'numpy.zeros', 'onp.zeros', (['(n, 1)'], {}), '((n, 1))\n', (20562, 20570), True, 'import numpy as onp\n'), ((20800, 20841), 'catenets.logger.debug', 'log.debug', (['f"""Training fold {fold_count}."""'], {}), "(f'Training fold {fold_count}.')\n", (20809, 20841), True, 'import catenets.logger as log\n'), ((20915, 20939), 'numpy.zeros', 'onp.zeros', (['n'], {'dtype': 'bool'}), '(n, dtype=bool)\n', (20924, 20939), True, 'import numpy as onp\n'), ((18979, 18995), 'numpy.round', 'onp.round', (['(n / 2)'], {}), '(n / 2)\n', (18988, 18995), True, 'import numpy as onp\n')]
|
from io import StringIO
import itertools
import numpy as np
import numpy.ma as ma
inputfile = './input/day9.txt'
# inputfile = StringIO('''2199943210
# 3987894921
# 9856789892
# 8767896789
# 9899965678''')
def neighbors(ar, i, j):
return {ar[i-1,j],
ar[i+1,j],
ar[i,j-1],
ar[i,j+1]}
a = np.genfromtxt(inputfile, dtype='i', delimiter=1)
nRows, nCols = a.shape
b = np.pad(a, ((1, 1), (1, 1)), constant_values=10)
lowPoints = []
for i, j in itertools.product(range(1, nRows+1), range(1, nCols+1)):
if all(b[i,j] < foo for foo in neighbors(b,i,j)):
lowPoints.append(b[i,j])
print(sum(1+n for n in lowPoints))
|
[
"numpy.pad",
"numpy.genfromtxt"
] |
[((333, 381), 'numpy.genfromtxt', 'np.genfromtxt', (['inputfile'], {'dtype': '"""i"""', 'delimiter': '(1)'}), "(inputfile, dtype='i', delimiter=1)\n", (346, 381), True, 'import numpy as np\n'), ((409, 456), 'numpy.pad', 'np.pad', (['a', '((1, 1), (1, 1))'], {'constant_values': '(10)'}), '(a, ((1, 1), (1, 1)), constant_values=10)\n', (415, 456), True, 'import numpy as np\n')]
|
"""Check the feasibility of a bipartite graph by using SSLAP's feasibility module"""
import numpy as np
from sslap import hopcroft_solve
# All 3 methods will use the same input bipartite graph:
# i = 0 connects to j = 0, 1
# i = 1 connects to j = 1, 2
# i = 2 connects to j = 1, 4
# i = 3 connects to j = 2
# i = 4 connects to j = 3
# which has a maximum matching of 5
# eg i:j of 0:0, 1:1, 2:4, 3:2, 4:3
def dict_usage():
lookup = {0: [0, 1], 1: [1, 2], 2: [1, 4], 3: [2], 4: [3]}
res = hopcroft_solve(lookup=lookup)
print(res)
def mat_usage():
mat = - np.ones((5, 5)) # all invalid, except
mat[[0, 0, 1, 1, 2, 2, 3, 4], [0, 1, 1, 2, 1, 4, 2, 3]] = 1 # for valid edges
res = hopcroft_solve(mat=mat)
print(res)
def loc_usage():
loc = np.array([[0, 0], [0, 1], [1, 1], [1, 2], [2, 1], [2, 4], [3, 2], [4, 3]]) # (i, j) for each edge
res = hopcroft_solve(loc=loc)
print(res)
if __name__ == "__main__":
dict_usage()
mat_usage()
loc_usage()
|
[
"numpy.array",
"numpy.ones",
"sslap.hopcroft_solve"
] |
[((494, 523), 'sslap.hopcroft_solve', 'hopcroft_solve', ([], {'lookup': 'lookup'}), '(lookup=lookup)\n', (508, 523), False, 'from sslap import hopcroft_solve\n'), ((690, 713), 'sslap.hopcroft_solve', 'hopcroft_solve', ([], {'mat': 'mat'}), '(mat=mat)\n', (704, 713), False, 'from sslap import hopcroft_solve\n'), ((752, 826), 'numpy.array', 'np.array', (['[[0, 0], [0, 1], [1, 1], [1, 2], [2, 1], [2, 4], [3, 2], [4, 3]]'], {}), '([[0, 0], [0, 1], [1, 1], [1, 2], [2, 1], [2, 4], [3, 2], [4, 3]])\n', (760, 826), True, 'import numpy as np\n'), ((858, 881), 'sslap.hopcroft_solve', 'hopcroft_solve', ([], {'loc': 'loc'}), '(loc=loc)\n', (872, 881), False, 'from sslap import hopcroft_solve\n'), ((564, 579), 'numpy.ones', 'np.ones', (['(5, 5)'], {}), '((5, 5))\n', (571, 579), True, 'import numpy as np\n')]
|
import caffe
import torch
import numpy as np
import argparse
from collections import OrderedDict
from torch.autograd import Variable
import torch.nn as nn
def arg_parse():
parser = argparse.ArgumentParser()
parser.add_argument('--model', '-m', default='alexnet')
parser.add_argument('--decimal', '-d', default=2)
parser.add_argument('--gpu', '-gpu', action='store_true')
args = parser.parse_args()
return args
def generate_random(shape, gpu=False):
data_np = np.random.rand(np.prod(shape)).reshape(shape)
data_torch = Variable(torch.Tensor(data_np))
if gpu:
data_torch = data_torch.cuda()
return [data_np], [data_torch]
def get_input_size(caffe_net):
input_name = caffe_net.inputs[0]
return caffe_net.blobs[input_name].data.shape
def forward_torch(net, data):
blobs = OrderedDict()
module2name = {}
for layer_name, m in net.named_modules():
layer_name = layer_name.replace('.', '_')
module2name[m] = layer_name
# turn off all the inplace operation
if hasattr(m, 'inplace'):
m.inplace = False
def forward_hook(m, i, o):
o_np = o.data.cpu().numpy()
blobs[module2name[m]] = o_np
for m in net.modules():
m.register_forward_hook(forward_hook)
output = net.forward(*data)
if isinstance(output, tuple):
outputs = []
for o in output:
outputs.append(o.data.cpu().numpy())
else:
outputs = [output.data.cpu().numpy()]
return blobs, outputs
def forward_caffe(net, data):
for input_name, d in zip(net.inputs, data):
net.blobs[input_name].data[...] = d
rst = net.forward()
blobs = OrderedDict()
blob2layer = {}
for layer_name, tops in net.top_names.items():
for top in tops:
blob2layer[top] = layer_name
for name, value in net.blobs.items():
layer_name = blob2layer[name]
value = value.data
if layer_name in blobs:
blobs[layer_name].append(value)
else:
blobs[layer_name] = [value]
outputs = []
for output_name in net.outputs:
outputs.append(rst[output_name])
return blobs, outputs
def test(net_caffe, net_torch, data_np, data_torch, args):
blobs_caffe, rsts_caffe = forward_caffe(net_caffe, data_np)
blobs_torch, rsts_torchs = forward_torch(net_torch, data_torch)
# test the output of every layer
for layer, value in blobs_caffe.items():
if layer in blobs_torch:
value_torch = blobs_torch[layer]
value = value[0]
if value.size != value_torch.size: continue
if 'relu' in layer: continue
try:
np.testing.assert_almost_equal(value, value_torch, decimal=args.decimal)
print("TEST layer {}: PASS".format(layer))
except:
print("TEST layer {}: FAIL".format(layer))
# np.testing.assert_almost_equal(np.clip(value, min=0), np.clip(value_torch, min=0))
# test the output
print("TEST output")
for rst_caffe, rst_torch in zip(rsts_caffe, rsts_torchs):
np.testing.assert_almost_equal(rst_caffe, rst_torch, decimal=args.decimal)
print("TEST output: PASS")
if __name__ == '__main__':
args = arg_parse()
if args.model == 'alexnet':
# Alexnet example
from torchvision.models.alexnet import alexnet
net_torch = alexnet(True).eval()
if args.gpu:
net_torch.cuda()
try:
net_caffe = caffe.Net('alexnet.prototxt', 'alexnet.caffemodel', caffe.TEST)
except:
raise ("Please run alexnet_pytorch_to_caffe.py first")
shape = get_input_size(net_caffe)
data_np, data_torch = generate_random(shape, args.gpu)
test(net_caffe, net_torch, data_np, data_torch, args)
elif args.model == 'resnet18':
# ResNet example
from torchvision.models.resnet import resnet18
net_torch = resnet18(True).eval()
if args.gpu:
net_torch.cuda()
net_caffe = caffe.Net('resnet18.prototxt', 'resnet18.caffemodel', caffe.TEST)
shape = get_input_size(net_caffe)
data_np, data_torch = generate_random(shape, args.gpu)
test(net_caffe, net_torch, data_np, data_torch, args)
elif args.model == 'inception_v3':
# Inception_v3 example
from torchvision.models.inception import inception_v3
net_torch = inception_v3(True, transform_input=False).eval()
if args.gpu:
net_torch.cuda()
net_caffe = caffe.Net('inception_v3.prototxt', 'inception_v3.caffemodel', caffe.TEST)
shape = get_input_size(net_caffe)
data_np, data_torch = generate_random(shape, args.gpu)
test(net_caffe, net_torch, data_np, data_torch, args)
else:
raise NotImplementedError()
|
[
"numpy.prod",
"collections.OrderedDict",
"torchvision.models.inception.inception_v3",
"argparse.ArgumentParser",
"torchvision.models.resnet.resnet18",
"torch.Tensor",
"numpy.testing.assert_almost_equal",
"caffe.Net",
"torchvision.models.alexnet.alexnet"
] |
[((187, 212), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (210, 212), False, 'import argparse\n'), ((836, 849), 'collections.OrderedDict', 'OrderedDict', ([], {}), '()\n', (847, 849), False, 'from collections import OrderedDict\n'), ((1695, 1708), 'collections.OrderedDict', 'OrderedDict', ([], {}), '()\n', (1706, 1708), False, 'from collections import OrderedDict\n'), ((563, 584), 'torch.Tensor', 'torch.Tensor', (['data_np'], {}), '(data_np)\n', (575, 584), False, 'import torch\n'), ((3144, 3218), 'numpy.testing.assert_almost_equal', 'np.testing.assert_almost_equal', (['rst_caffe', 'rst_torch'], {'decimal': 'args.decimal'}), '(rst_caffe, rst_torch, decimal=args.decimal)\n', (3174, 3218), True, 'import numpy as np\n'), ((3545, 3608), 'caffe.Net', 'caffe.Net', (['"""alexnet.prototxt"""', '"""alexnet.caffemodel"""', 'caffe.TEST'], {}), "('alexnet.prototxt', 'alexnet.caffemodel', caffe.TEST)\n", (3554, 3608), False, 'import caffe\n'), ((4088, 4153), 'caffe.Net', 'caffe.Net', (['"""resnet18.prototxt"""', '"""resnet18.caffemodel"""', 'caffe.TEST'], {}), "('resnet18.prototxt', 'resnet18.caffemodel', caffe.TEST)\n", (4097, 4153), False, 'import caffe\n'), ((506, 520), 'numpy.prod', 'np.prod', (['shape'], {}), '(shape)\n', (513, 520), True, 'import numpy as np\n'), ((2715, 2787), 'numpy.testing.assert_almost_equal', 'np.testing.assert_almost_equal', (['value', 'value_torch'], {'decimal': 'args.decimal'}), '(value, value_torch, decimal=args.decimal)\n', (2745, 2787), True, 'import numpy as np\n'), ((3437, 3450), 'torchvision.models.alexnet.alexnet', 'alexnet', (['(True)'], {}), '(True)\n', (3444, 3450), False, 'from torchvision.models.alexnet import alexnet\n'), ((4593, 4666), 'caffe.Net', 'caffe.Net', (['"""inception_v3.prototxt"""', '"""inception_v3.caffemodel"""', 'caffe.TEST'], {}), "('inception_v3.prototxt', 'inception_v3.caffemodel', caffe.TEST)\n", (4602, 4666), False, 'import caffe\n'), ((3996, 4010), 'torchvision.models.resnet.resnet18', 'resnet18', (['(True)'], {}), '(True)\n', (4004, 4010), False, 'from torchvision.models.resnet import resnet18\n'), ((4474, 4515), 'torchvision.models.inception.inception_v3', 'inception_v3', (['(True)'], {'transform_input': '(False)'}), '(True, transform_input=False)\n', (4486, 4515), False, 'from torchvision.models.inception import inception_v3\n')]
|
# coding=utf-8
import logging
import numpy as np
import pandas as pd
from sklearn import metrics
from sklearn.linear_model import LogisticRegression
from sklearn.multiclass import OneVsRestClassifier
from sklearn.preprocessing import LabelBinarizer
from sklearn.utils import shuffle
logging.basicConfig(format='%(levelname)s:%(message)s', level=logging.ERROR)
def classification(embedding, lbl_path, split_ratio=0.7, loop=100):
eval_dict = {
'acc': 0.0,
'f1-micro': 0.0,
'f1-macro': 0.0,
}
label = pd.read_csv(lbl_path, header=None, sep=' ').values
for _ in range(loop):
labels_np = shuffle(label)
nodes = labels_np[:, 0]
labels = labels_np[:, 1]
lb = LabelBinarizer()
labels = lb.fit_transform(labels)
train_size = int(labels_np.shape[0] * split_ratio)
features = embedding[nodes]
train_x = features[:train_size, :]
train_y = labels[:train_size, :]
test_x = features[train_size:, :]
test_y = labels[train_size:, :]
clf = OneVsRestClassifier(
LogisticRegression(class_weight='balanced', solver='liblinear', n_jobs=-1))
clf.fit(train_x, train_y)
y_pred = clf.predict_proba(test_x)
y_pred = lb.transform(np.argmax(y_pred, 1))
acc = np.sum(np.argmax(y_pred, 1) == np.argmax(test_y, 1)) / len(y_pred)
eval_dict['acc'] += acc
eval_dict['f1-micro'] += metrics.f1_score(np.argmax(test_y, 1), np.argmax(y_pred, 1),
average='micro')
eval_dict['f1-macro'] += metrics.f1_score(np.argmax(test_y, 1), np.argmax(y_pred, 1),
average='macro')
for key in eval_dict.keys():
eval_dict[key] = round(1.0 * eval_dict[key] / loop, 4)
print('split_ratio: {}'.format(split_ratio))
print(eval_dict)
return eval_dict
def _k_precision(embedding, lbl_path, k, lbl):
label = pd.read_csv(lbl_path, header=None, sep=' ').values
nodes = label[np.where(label[:, 1] == lbl)][:, 0]
acc = 0.0
for node in nodes:
distance = {}
for i in range(embedding.shape[0]):
if i == node:
continue
distance[i] = np.linalg.norm(embedding[i] - embedding[node])
distance = sorted(distance.items(), key=lambda x: x[1])
distance = np.array(distance)[:k]
acc += distance[np.isin(distance[:, 0], nodes)].shape[0] / k
acc /= len(nodes)
return acc
def k_precision(embedding, lbl_path, k=50):
eval_dict = {
'precision': k,
'bots_acc': _k_precision(embedding, lbl_path, k, 1),
'admins_acc': _k_precision(embedding, lbl_path, k, 2)
}
print(eval_dict)
|
[
"logging.basicConfig",
"sklearn.preprocessing.LabelBinarizer",
"pandas.read_csv",
"numpy.where",
"sklearn.utils.shuffle",
"numpy.argmax",
"numpy.isin",
"sklearn.linear_model.LogisticRegression",
"numpy.array",
"numpy.linalg.norm"
] |
[((285, 361), 'logging.basicConfig', 'logging.basicConfig', ([], {'format': '"""%(levelname)s:%(message)s"""', 'level': 'logging.ERROR'}), "(format='%(levelname)s:%(message)s', level=logging.ERROR)\n", (304, 361), False, 'import logging\n'), ((538, 581), 'pandas.read_csv', 'pd.read_csv', (['lbl_path'], {'header': 'None', 'sep': '""" """'}), "(lbl_path, header=None, sep=' ')\n", (549, 581), True, 'import pandas as pd\n'), ((635, 649), 'sklearn.utils.shuffle', 'shuffle', (['label'], {}), '(label)\n', (642, 649), False, 'from sklearn.utils import shuffle\n'), ((729, 745), 'sklearn.preprocessing.LabelBinarizer', 'LabelBinarizer', ([], {}), '()\n', (743, 745), False, 'from sklearn.preprocessing import LabelBinarizer\n'), ((1984, 2027), 'pandas.read_csv', 'pd.read_csv', (['lbl_path'], {'header': 'None', 'sep': '""" """'}), "(lbl_path, header=None, sep=' ')\n", (1995, 2027), True, 'import pandas as pd\n'), ((1096, 1170), 'sklearn.linear_model.LogisticRegression', 'LogisticRegression', ([], {'class_weight': '"""balanced"""', 'solver': '"""liblinear"""', 'n_jobs': '(-1)'}), "(class_weight='balanced', solver='liblinear', n_jobs=-1)\n", (1114, 1170), False, 'from sklearn.linear_model import LogisticRegression\n'), ((1279, 1299), 'numpy.argmax', 'np.argmax', (['y_pred', '(1)'], {}), '(y_pred, 1)\n', (1288, 1299), True, 'import numpy as np\n'), ((1464, 1484), 'numpy.argmax', 'np.argmax', (['test_y', '(1)'], {}), '(test_y, 1)\n', (1473, 1484), True, 'import numpy as np\n'), ((1486, 1506), 'numpy.argmax', 'np.argmax', (['y_pred', '(1)'], {}), '(y_pred, 1)\n', (1495, 1506), True, 'import numpy as np\n'), ((1625, 1645), 'numpy.argmax', 'np.argmax', (['test_y', '(1)'], {}), '(test_y, 1)\n', (1634, 1645), True, 'import numpy as np\n'), ((1647, 1667), 'numpy.argmax', 'np.argmax', (['y_pred', '(1)'], {}), '(y_pred, 1)\n', (1656, 1667), True, 'import numpy as np\n'), ((2053, 2081), 'numpy.where', 'np.where', (['(label[:, 1] == lbl)'], {}), '(label[:, 1] == lbl)\n', (2061, 2081), True, 'import numpy as np\n'), ((2269, 2315), 'numpy.linalg.norm', 'np.linalg.norm', (['(embedding[i] - embedding[node])'], {}), '(embedding[i] - embedding[node])\n', (2283, 2315), True, 'import numpy as np\n'), ((2399, 2417), 'numpy.array', 'np.array', (['distance'], {}), '(distance)\n', (2407, 2417), True, 'import numpy as np\n'), ((1322, 1342), 'numpy.argmax', 'np.argmax', (['y_pred', '(1)'], {}), '(y_pred, 1)\n', (1331, 1342), True, 'import numpy as np\n'), ((1346, 1366), 'numpy.argmax', 'np.argmax', (['test_y', '(1)'], {}), '(test_y, 1)\n', (1355, 1366), True, 'import numpy as np\n'), ((2446, 2476), 'numpy.isin', 'np.isin', (['distance[:, 0]', 'nodes'], {}), '(distance[:, 0], nodes)\n', (2453, 2476), True, 'import numpy as np\n')]
|
import csv
import cv2
import numpy as np
import pandas as pd
import sys
from datetime import datetime
from numpy.random import RandomState
import keras
import tensorflow as tf
from keras.models import Sequential
from keras.callbacks import ModelCheckpoint
from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D
def DrivingNetV1():
model = Sequential()
model.add( Cropping2D( cropping=( (90,20), (0,0) ), input_shape=( 160, 320, 3 ) ) )
model.add( Lambda( lambda x: (x/255.0) - 0.5 ) )
model.add( Flatten( ) )
model.add( Dense(1) )
return model
def NVIDIANetV0( lr=1e-3):
model = Sequential( name="NVIDIANetV0" )
model.add( Lambda( lambda x: (x/255.0) - 0.5, input_shape=( 160, 320, 3 ) ) )
model.add( Cropping2D( cropping=( (70,25), (0,0) ) ) )
model.add( Conv2D( 24, 5, 2, activation='relu', padding='valid' ) )
model.add( Conv2D( 36, 5, 2, activation='relu', padding='valid' ) )
model.add( Conv2D( 48, 5, 2, activation='relu', padding='valid' ) )
model.add( Conv2D( 64, 3, activation='relu', padding='valid' ) )
model.add( Conv2D( 64, 3, activation='relu', padding='valid' ) )
model.add( Flatten( ) )
#model.add( Dense(1164, activation='relu' ) )
#model.add( Dropout(0.2))
model.add( Dense(100, activation='linear' ) )
model.add( Dense(50, activation='linear' ) )
model.add( Dense(10, activation='linear' ) )
model.add( Dense(1, activation='linear') )
opt = keras.optimizers.Adam(learning_rate=lr )
model.compile( loss='mse', optimizer=opt )
return model
def NVIDIANetV1( lr=1e-3):
model = Sequential( name="NVIDIANetV1" )
model.add( Lambda( lambda x: (x/255.0) - 0.5, input_shape=( 160, 320, 3 ) ) )
model.add( Cropping2D( cropping=( (70,25), (0,0) ) ) )
model.add( Conv2D( 24, 5, 2, activation='relu', padding='valid' ) )
model.add( Conv2D( 36, 5, 2, activation='relu', padding='valid' ) )
model.add( Conv2D( 48, 5, 2, activation='relu', padding='valid' ) )
model.add( Conv2D( 64, 3, activation='relu', padding='valid' ) )
model.add( Conv2D( 64, 3, activation='relu', padding='valid' ) )
model.add( Flatten( ) )
#model.add( Dense(1164, activation='relu' ) )
#model.add( Dropout(0.2))
model.add( Dense(100, activation='tanh' ) )
model.add( Dense(50, activation='tanh' ) )
model.add( Dense(10, activation='tanh' ) )
model.add( Dense(1, activation='linear') )
#Converting curvature to angle, assuming wheelbase of 2 meters, then going from rad to deg
#The network output was supposed to be 1/R (r), the function then convert it to steering angle (alpha) [deg]
# alpha = atan(l*r)*57.3. l = wheelbase, supossed to be 2 meters
model.add( Lambda( lambda x: tf.multiply( tf.atan( tf.multiply( x, 2 ) ), 57.3 ) ) )
opt = keras.optimizers.Adam(learning_rate=lr )
model.compile( loss='mse', optimizer=opt )
return model
def NVIDIANetV2( lr=1e-3):
model = Sequential( name="NVIDIANetV2" )
model.add( Lambda( lambda x: (x/255.0) - 0.5, input_shape=( 160, 320, 3 ) ) )
model.add( Cropping2D( cropping=( (70,25), (0,0) ) ) )
model.add( Conv2D( 24, 5, 2, activation='relu', padding='valid' ) )
model.add( Conv2D( 36, 5, 2, activation='relu', padding='valid' ) )
model.add( Conv2D( 48, 5, 2, activation='relu', padding='valid' ) )
model.add( Conv2D( 64, 3, activation='relu', padding='valid' ) )
model.add( Conv2D( 64, 3, activation='relu', padding='valid' ) )
model.add( Flatten( ) )
model.add( Dense(100, activation='linear' ) )
model.add( Dense(50, activation='linear' ) )
model.add( Dense(10, activation='linear' ) )
model.add( Dense(1, activation='linear') )
#Converting curvature to angle, assuming wheelbase of 2 meters, then going from rad to deg
#The network output was supposed to be 1/R (r), the function then convert it to steering angle (alpha) [deg]
# alpha = atan(l*r)*57.3. l = wheelbase, supossed to be 2 meters
model.add( Lambda( lambda x: tf.multiply( tf.atan( tf.multiply( x, 2 ) ), 57.3 ) ) )
opt = keras.optimizers.Adam(learning_rate=lr )
model.compile( loss='mse', optimizer=opt )
return model
def NVIDIANetV3( lr=1e-3):
model = Sequential( name="NVIDIANetV3" )
model.add( Lambda( lambda x: (x/255.0) - 0.5, input_shape=( 160, 320, 3 ) ) )
model.add( Cropping2D( cropping=( (70,25), (0,0) ) ) )
model.add( Conv2D( 24, 5, 2, activation='relu', padding='valid' ) )
model.add( Conv2D( 36, 5, 2, activation='relu', padding='valid' ) )
model.add( Conv2D( 48, 5, 2, activation='relu', padding='valid' ) )
model.add( Conv2D( 64, 3, activation='relu', padding='valid' ) )
model.add( Conv2D( 64, 3, activation='relu', padding='valid' ) )
model.add( Flatten( ) )
model.add( Dense(100, activation='tanh' ) )
model.add( Dropout(0.5) )
model.add( Dense(50, activation='tanh' ) )
model.add( Dropout(0.5) )
model.add( Dense(10, activation='tanh' ) )
model.add( Dropout(0.5) )
model.add( Dense(1, activation='linear') )
#Converting curvature to angle, assuming wheelbase of 2 meters, then going from rad to deg
#The network output was supposed to be 1/R (r), the function then convert it to steering angle (alpha) [deg]
# alpha = atan(l*r)*57.3. l = wheelbase, supossed to be 2 meters
model.add( Lambda( lambda x: tf.multiply( tf.atan( tf.multiply( x, 2 ) ), 57.3 ) ) )
opt = keras.optimizers.Adam(learning_rate=lr )
model.compile( loss='mse', optimizer=opt )
return model
def NVIDIANetV4( lr=1e-3):
model = Sequential( name="NVIDIANetV4" )
model.add( Lambda( lambda x: (x/255.0) - 0.5, input_shape=( 160, 320, 3 ) ) )
model.add( Cropping2D( cropping=( (70,25), (0,0) ) ) )
model.add( Conv2D( 24, 5, 2, activation='relu', padding='valid' ) )
model.add( Conv2D( 36, 5, 2, activation='relu', padding='valid' ) )
model.add( Conv2D( 48, 5, 2, activation='relu', padding='valid' ) )
model.add( Conv2D( 64, 3, activation='relu', padding='valid' ) )
model.add( Conv2D( 64, 3, activation='relu', padding='valid' ) )
model.add( Flatten( ) )
#model.add( Dense(1164, activation='relu' ) )
#model.add( Dropout(0.2))
model.add( Dense(100, activation='tanh' ) )
model.add( Dropout(0.5) )
model.add( Dense(50, activation='tanh' ) )
model.add( Dropout(0.25) )
model.add( Dense(10, activation='tanh' ) )
model.add( Dropout(0.125) )
model.add( Dense(1, activation='linear') )
#Converting curvature to angle, assuming wheelbase of 2 meters, then going from rad to deg
#The network output was supposed to be 1/R (r), the function then convert it to steering angle (alpha) [deg]
# alpha = atan(l*r)*57.3. l = wheelbase, supossed to be 2 meters
model.add( Lambda( lambda x: tf.multiply( tf.atan( tf.multiply( x, 2 ) ), 57.3 ) ) )
opt = keras.optimizers.Adam(learning_rate=lr )
model.compile( loss='mse', optimizer=opt )
return model
def NVIDIANetV5( lr=1e-3):
model = Sequential( name="NVIDIANetV5" )
model.add( Lambda( lambda x: (x/255.0) - 0.5, input_shape=( 160, 320, 3 ) ) )
model.add( Cropping2D( cropping=( (70,25), (0,0) ) ) )
model.add( Conv2D( 24, 5, 2, activation='relu', padding='valid' ) )
model.add( Conv2D( 36, 5, 2, activation='relu', padding='valid' ) )
model.add( Conv2D( 48, 5, 2, activation='relu', padding='valid' ) )
model.add( Conv2D( 64, 3, activation='relu', padding='valid' ) )
model.add( Conv2D( 64, 3, activation='relu', padding='valid' ) )
model.add( Flatten( ) )
model.add( Dense(100, activation='tanh' ) )
model.add( Dropout(0.5) )
model.add( Dense(50, activation='tanh' ) )
model.add( Dropout(0.25) )
model.add( Dense(10, activation='tanh' ) )
model.add( Dense(1, activation='linear') )
#Converting curvature to angle, assuming wheelbase of 2 meters, then going from rad to deg
#The network output was supposed to be 1/R (r), the function then convert it to steering angle (alpha) [deg]
# alpha = atan(l*r)*57.3. l = wheelbase, supossed to be 2 meters
model.add( Lambda( lambda x: tf.multiply( tf.atan( tf.multiply( x, 2 ) ), 57.3 ) ) )
opt = keras.optimizers.Adam(learning_rate=lr )
model.compile( loss='mse', optimizer=opt )
return model
def NVIDIANetV6( lr=1e-3):
model = Sequential( name="NVIDIANetV6" )
model.add( Lambda( lambda x: (x/255.0) - 0.5, input_shape=( 160, 320, 3 ) ) )
model.add( Cropping2D( cropping=( (70,25), (0,0) ) ) )
model.add( Conv2D( 24, 5, 2, activation='relu', padding='valid' ) )
model.add( Conv2D( 36, 5, 2, activation='relu', padding='valid' ) )
model.add( Conv2D( 48, 5, 2, activation='relu', padding='valid' ) )
model.add( Conv2D( 64, 3, activation='relu', padding='valid' ) )
model.add( Conv2D( 64, 3, activation='relu', padding='valid' ) )
model.add( Flatten( ) )
model.add( Dropout(0.5) )
model.add( Dense(100, activation='tanh' ) )
model.add( Dropout(0.5) )
model.add( Dense(50, activation='tanh' ) )
model.add( Dropout(0.25) )
model.add( Dense(10, activation='tanh' ) )
model.add( Dense(1, activation='linear') )
#Converting curvature to angle, assuming wheelbase of 2 meters, then going from rad to deg
#The network output was supposed to be 1/R (r), the function then convert it to steering angle (alpha) [deg]
# alpha = atan(l*r)*57.3. l = wheelbase, supossed to be 2 meters
model.add( Lambda( lambda x: tf.multiply( tf.atan( tf.multiply( x, 2 ) ), 57.3 ) ) )
opt = keras.optimizers.Adam(learning_rate=lr )
model.compile( loss='mse', optimizer=opt )
return model
def ModNVIDIANetV1( lr=1e-3):
model = Sequential( name = "ModNVIDIANetV1" )
model.add( Lambda( lambda x: (x/255.0) - 0.5, input_shape=( 160, 320, 3 ) ) )
model.add( Cropping2D( cropping=( (70,25), (0,0) ) ) )
#Keeping padding as "same" and applygin a max
model.add( Conv2D( 24, 5, 1, activation='relu', padding='same' ) )
model.add( MaxPool2D( ) )
model.add( Conv2D( 36, 5, 1, activation='relu', padding='same' ) )
model.add( MaxPool2D( ) )
model.add( Conv2D( 48, 5, 1, activation='relu', padding='same' ) )
model.add( MaxPool2D( ) )
model.add( Conv2D( 64, 3, 1, activation='relu', padding='same' ) )
model.add( MaxPool2D( ) )
model.add( Conv2D( 64, 3, 1, activation='relu', padding='same' ) )
model.add( MaxPool2D( pool_size=(4, 2) ) ) #forcing to this output to become an "flat"
model.add( Flatten( ) )
#model.add( Dense(1164, activation='relu' ) )
#model.add( Dropout(0.2))
model.add( Dense(300, activation='tanh' ) )
model.add( Dense(100, activation='tanh' ) )
model.add( Dense(50, activation='tanh' ) )
model.add( Dense(10, activation='tanh' ) )
model.add( Dense(1, activation='linear' ) )
#Converting curvature to angle, assuming wheelbase of 2 meters, then going from rad to deg
#The network output was supposed to be 1/R (r), the function then convert it to steering angle (alpha) [deg]
# alpha = atan(l*r)*57.3. l = wheelbase, supossed to be 2 meters
model.add( Lambda( lambda x: tf.multiply( tf.atan( tf.multiply( x, 2 ) ), 57.3 ) ) )
opt = keras.optimizers.Adam(learning_rate=lr )
model.compile( loss='mse', optimizer=opt )
return model
def ModNVIDIANetV2( lr=1e-3):
model = Sequential( name = "ModNVIDIANetV2" )
model.add( Lambda( lambda x: (x/255.0) - 0.5, input_shape=( 160, 320, 3 ) ) )
model.add( Cropping2D( cropping=( (70,25), (0,0) ) ) )
#Keeping padding as "same" and applygin a max
model.add( Conv2D( 24, 5, 1, activation='relu', padding='same' ) )
model.add( MaxPool2D( ) )
model.add( Conv2D( 36, 5, 1, activation='relu', padding='same' ) )
model.add( MaxPool2D( ) )
model.add( Conv2D( 48, 5, 1, activation='relu', padding='same' ) )
model.add( MaxPool2D( ) )
model.add( Conv2D( 64, 3, 1, activation='relu', padding='same' ) )
model.add( MaxPool2D( ) )
model.add( Conv2D( 64, 3, 1, activation='relu', padding='same' ) )
model.add( MaxPool2D( pool_size=(4, 2) ) ) #forcing to this output to become an "flat"
model.add( Flatten( ) )
model.add( Dense(300, activation='linear' ) )
model.add( Dense(100, activation='linear' ) )
model.add( Dense(50, activation='linear' ) )
model.add( Dense(10, activation='linear' ) )
model.add( Dense(1, activation='linear' ) )
#Converting curvature to angle, assuming wheelbase of 2 meters, then going from rad to deg
#The network output was supposed to be 1/R (r), the function then convert it to steering angle (alpha) [deg]
# alpha = atan(l*r)*57.3. l = wheelbase, supossed to be 2 meters
model.add( Lambda( lambda x: tf.multiply( tf.atan( tf.multiply( x, 2 ) ), 57.3 ) ) )
opt = keras.optimizers.Adam(learning_rate=lr )
model.compile( loss='mse', optimizer=opt )
return model
def ModNVIDIANetV3( lr=1e-3):
model = Sequential( name = "ModNVIDIANetV3" )
model.add( Lambda( lambda x: (x/255.0) - 0.5, input_shape=( 160, 320, 3 ) ) )
model.add( Cropping2D( cropping=( (70,25), (0,0) ) ) )
#Keeping padding as "same" and applygin a max
model.add( Conv2D( 24, 5, 1, activation='relu', padding='same' ) )
model.add( MaxPool2D( ) )
model.add( Conv2D( 36, 5, 1, activation='relu', padding='same' ) )
model.add( MaxPool2D( ) )
model.add( Conv2D( 48, 5, 1, activation='relu', padding='same' ) )
model.add( MaxPool2D( ) )
model.add( Conv2D( 64, 3, 1, activation='relu', padding='same' ) )
model.add( MaxPool2D( ) )
model.add( Conv2D( 64, 3, 1, activation='relu', padding='same' ) )
model.add( MaxPool2D( pool_size=(4, 2) ) ) #forcing to this output to become an "flat"
model.add( Flatten( ) )
model.add( Dense(100, activation='tanh' ) )
model.add( Dropout(0.5) )
model.add( Dense(50, activation='tanh' ) )
model.add( Dropout(0.25) )
model.add( Dense(10, activation='tanh' ) )
model.add( Dense(1, activation='linear') )
#Converting curvature to angle, assuming wheelbase of 2 meters, then going from rad to deg
#The network output was supposed to be 1/R (r), the function then convert it to steering angle (alpha) [deg]
# alpha = atan(l*r)*57.3. l = wheelbase, supossed to be 2 meters
model.add( Lambda( lambda x: tf.multiply( tf.atan( tf.multiply( x, 2 ) ), 57.3 ) ) )
opt = keras.optimizers.Adam(learning_rate=lr )
model.compile( loss='mse', optimizer=opt )
return model
#Hyper parameters
BATCH_SIZE=64
LEARNING_RATE=1e-4
EPOCHS=5
model_name = sys.argv[1]
model = Sequential()
if( model_name == 'NVIDIANetV0'):
model = NVIDIANetV0( LEARNING_RATE )
elif( model_name == 'NVIDIANetV1'):
model = NVIDIANetV1( LEARNING_RATE )
elif( model_name == 'NVIDIANetV2' ):
model = NVIDIANetV2( LEARNING_RATE )
elif( model_name == 'NVIDIANetV3' ):
model = NVIDIANetV3( LEARNING_RATE )
elif( model_name == 'NVIDIANetV4' ):
model = NVIDIANetV4( LEARNING_RATE )
elif( model_name == 'NVIDIANetV5' ):
model = NVIDIANetV5( LEARNING_RATE )
elif( model_name == 'NVIDIANetV6' ):
model = NVIDIANetV6( LEARNING_RATE )
elif( model_name == 'ModNVIDIANetV1' ):
model = ModNVIDIANetV1( LEARNING_RATE )
elif( model_name == 'ModNVIDIANetV2' ):
model = ModNVIDIANetV2( LEARNING_RATE )
elif( model_name == 'ModNVIDIANetV3' ):
model = ModNVIDIANetV3( LEARNING_RATE )
else:
raise Exception('Invalid model name')
#Load data. Split data into train and validation
df = pd.read_csv('data/driving_log.csv', names=['center', 'left', 'right', 'measurement', '1', '2', '3'])
rng = RandomState()
train = df.sample( frac=0.7, random_state=rng )
valid = df.loc[~df.index.isin(train.index) ]
NUM_TRAIN_IMAGES = train.shape[0]
NUM_TEST_IMAGES = valid.shape[0]
#Deffining the generator
def load_data( df, batch_size, augument=False ):
i = 0
while True:
images = []
measurements = []
while len(images) < batch_size:
image_path = df.iloc[i,:]['center'].split('/')[-1]
current_path = './data/IMG/' + image_path
measurement = float( df.iloc[i,:]['measurement'] )
image = cv2.imread( current_path )
measurements.append( measurement )
images.append( image )
if( augument ):
flipped_image = cv2.flip( image, 1 )
images.append( flipped_image )
measurements.append( -1.0*measurement )
# image_path = df.iloc[i,:]['left'].split('/')[-1]
# current_path = './data/IMG/' + image_path
# measurement = float( +0.9 )
# image = cv2.imread( current_path )
# measurements.append( measurement )
# images.append( image )
# image_path = df.iloc[i,:]['right'].split('/')[-1]
# current_path = './data/IMG/' + image_path
# measurement = float( -0.9 )
# image = cv2.imread( current_path )
# measurements.append( measurement )
# images.append( image )
i += 1
if( i == df.shape[0] ):
i =0
yield ( np.array( images ), np.array( measurements ) )
#Define the generators
trainGen = load_data( train, BATCH_SIZE, True)
validGen = load_data( valid, BATCH_SIZE )
NUM_TRAIN_IMAGES = 2*NUM_TRAIN_IMAGES
NUM_TEST_IMAGES = NUM_TEST_IMAGES
print(model.summary())
#Using tensorboard
logdir = "logs/scalars/" + model.name
#defiining tensorboard callback
tensorboard_callback = keras.callbacks.TensorBoard(log_dir=logdir)
model.fit(
x=trainGen,
steps_per_epoch=NUM_TRAIN_IMAGES//BATCH_SIZE,
verbose=1,
validation_data=validGen,
validation_steps=NUM_TEST_IMAGES//BATCH_SIZE, epochs=EPOCHS,
callbacks=[tensorboard_callback] )
model.save( model.name + '.h5')
|
[
"keras.optimizers.Adam",
"keras.layers.Conv2D",
"keras.layers.Flatten",
"pandas.read_csv",
"cv2.flip",
"keras.layers.Lambda",
"tensorflow.multiply",
"keras.callbacks.TensorBoard",
"keras.models.Sequential",
"numpy.array",
"keras.layers.Dropout",
"keras.layers.Dense",
"keras.layers.MaxPool2D",
"keras.layers.Cropping2D",
"numpy.random.RandomState",
"cv2.imread"
] |
[((14357, 14369), 'keras.models.Sequential', 'Sequential', ([], {}), '()\n', (14367, 14369), False, 'from keras.models import Sequential\n'), ((15282, 15386), 'pandas.read_csv', 'pd.read_csv', (['"""data/driving_log.csv"""'], {'names': "['center', 'left', 'right', 'measurement', '1', '2', '3']"}), "('data/driving_log.csv', names=['center', 'left', 'right',\n 'measurement', '1', '2', '3'])\n", (15293, 15386), True, 'import pandas as pd\n'), ((15389, 15402), 'numpy.random.RandomState', 'RandomState', ([], {}), '()\n', (15400, 15402), False, 'from numpy.random import RandomState\n'), ((17059, 17102), 'keras.callbacks.TensorBoard', 'keras.callbacks.TensorBoard', ([], {'log_dir': 'logdir'}), '(log_dir=logdir)\n', (17086, 17102), False, 'import keras\n'), ((378, 390), 'keras.models.Sequential', 'Sequential', ([], {}), '()\n', (388, 390), False, 'from keras.models import Sequential\n'), ((627, 657), 'keras.models.Sequential', 'Sequential', ([], {'name': '"""NVIDIANetV0"""'}), "(name='NVIDIANetV0')\n", (637, 657), False, 'from keras.models import Sequential\n'), ((1448, 1487), 'keras.optimizers.Adam', 'keras.optimizers.Adam', ([], {'learning_rate': 'lr'}), '(learning_rate=lr)\n', (1469, 1487), False, 'import keras\n'), ((1585, 1615), 'keras.models.Sequential', 'Sequential', ([], {'name': '"""NVIDIANetV1"""'}), "(name='NVIDIANetV1')\n", (1595, 1615), False, 'from keras.models import Sequential\n'), ((2757, 2796), 'keras.optimizers.Adam', 'keras.optimizers.Adam', ([], {'learning_rate': 'lr'}), '(learning_rate=lr)\n', (2778, 2796), False, 'import keras\n'), ((2897, 2927), 'keras.models.Sequential', 'Sequential', ([], {'name': '"""NVIDIANetV2"""'}), "(name='NVIDIANetV2')\n", (2907, 2927), False, 'from keras.models import Sequential\n'), ((4080, 4119), 'keras.optimizers.Adam', 'keras.optimizers.Adam', ([], {'learning_rate': 'lr'}), '(learning_rate=lr)\n', (4101, 4119), False, 'import keras\n'), ((4223, 4253), 'keras.models.Sequential', 'Sequential', ([], {'name': '"""NVIDIANetV3"""'}), "(name='NVIDIANetV3')\n", (4233, 4253), False, 'from keras.models import Sequential\n'), ((5401, 5440), 'keras.optimizers.Adam', 'keras.optimizers.Adam', ([], {'learning_rate': 'lr'}), '(learning_rate=lr)\n', (5422, 5440), False, 'import keras\n'), ((5538, 5568), 'keras.models.Sequential', 'Sequential', ([], {'name': '"""NVIDIANetV4"""'}), "(name='NVIDIANetV4')\n", (5548, 5568), False, 'from keras.models import Sequential\n'), ((6794, 6833), 'keras.optimizers.Adam', 'keras.optimizers.Adam', ([], {'learning_rate': 'lr'}), '(learning_rate=lr)\n', (6815, 6833), False, 'import keras\n'), ((6931, 6961), 'keras.models.Sequential', 'Sequential', ([], {'name': '"""NVIDIANetV5"""'}), "(name='NVIDIANetV5')\n", (6941, 6961), False, 'from keras.models import Sequential\n'), ((8083, 8122), 'keras.optimizers.Adam', 'keras.optimizers.Adam', ([], {'learning_rate': 'lr'}), '(learning_rate=lr)\n', (8104, 8122), False, 'import keras\n'), ((8220, 8250), 'keras.models.Sequential', 'Sequential', ([], {'name': '"""NVIDIANetV6"""'}), "(name='NVIDIANetV6')\n", (8230, 8250), False, 'from keras.models import Sequential\n'), ((9399, 9438), 'keras.optimizers.Adam', 'keras.optimizers.Adam', ([], {'learning_rate': 'lr'}), '(learning_rate=lr)\n', (9420, 9438), False, 'import keras\n'), ((9539, 9572), 'keras.models.Sequential', 'Sequential', ([], {'name': '"""ModNVIDIANetV1"""'}), "(name='ModNVIDIANetV1')\n", (9549, 9572), False, 'from keras.models import Sequential\n'), ((10996, 11035), 'keras.optimizers.Adam', 'keras.optimizers.Adam', ([], {'learning_rate': 'lr'}), '(learning_rate=lr)\n', (11017, 11035), False, 'import keras\n'), ((11139, 11172), 'keras.models.Sequential', 'Sequential', ([], {'name': '"""ModNVIDIANetV2"""'}), "(name='ModNVIDIANetV2')\n", (11149, 11172), False, 'from keras.models import Sequential\n'), ((12625, 12664), 'keras.optimizers.Adam', 'keras.optimizers.Adam', ([], {'learning_rate': 'lr'}), '(learning_rate=lr)\n', (12646, 12664), False, 'import keras\n'), ((12771, 12804), 'keras.models.Sequential', 'Sequential', ([], {'name': '"""ModNVIDIANetV3"""'}), "(name='ModNVIDIANetV3')\n", (12781, 12804), False, 'from keras.models import Sequential\n'), ((14161, 14200), 'keras.optimizers.Adam', 'keras.optimizers.Adam', ([], {'learning_rate': 'lr'}), '(learning_rate=lr)\n', (14182, 14200), False, 'import keras\n'), ((403, 469), 'keras.layers.Cropping2D', 'Cropping2D', ([], {'cropping': '((90, 20), (0, 0))', 'input_shape': '(160, 320, 3)'}), '(cropping=((90, 20), (0, 0)), input_shape=(160, 320, 3))\n', (413, 469), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((489, 522), 'keras.layers.Lambda', 'Lambda', (['(lambda x: x / 255.0 - 0.5)'], {}), '(lambda x: x / 255.0 - 0.5)\n', (495, 522), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((539, 548), 'keras.layers.Flatten', 'Flatten', ([], {}), '()\n', (546, 548), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((564, 572), 'keras.layers.Dense', 'Dense', (['(1)'], {}), '(1)\n', (569, 572), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((674, 734), 'keras.layers.Lambda', 'Lambda', (['(lambda x: x / 255.0 - 0.5)'], {'input_shape': '(160, 320, 3)'}), '(lambda x: x / 255.0 - 0.5, input_shape=(160, 320, 3))\n', (680, 734), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((753, 792), 'keras.layers.Cropping2D', 'Cropping2D', ([], {'cropping': '((70, 25), (0, 0))'}), '(cropping=((70, 25), (0, 0)))\n', (763, 792), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((811, 863), 'keras.layers.Conv2D', 'Conv2D', (['(24)', '(5)', '(2)'], {'activation': '"""relu"""', 'padding': '"""valid"""'}), "(24, 5, 2, activation='relu', padding='valid')\n", (817, 863), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((882, 934), 'keras.layers.Conv2D', 'Conv2D', (['(36)', '(5)', '(2)'], {'activation': '"""relu"""', 'padding': '"""valid"""'}), "(36, 5, 2, activation='relu', padding='valid')\n", (888, 934), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((953, 1005), 'keras.layers.Conv2D', 'Conv2D', (['(48)', '(5)', '(2)'], {'activation': '"""relu"""', 'padding': '"""valid"""'}), "(48, 5, 2, activation='relu', padding='valid')\n", (959, 1005), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((1024, 1073), 'keras.layers.Conv2D', 'Conv2D', (['(64)', '(3)'], {'activation': '"""relu"""', 'padding': '"""valid"""'}), "(64, 3, activation='relu', padding='valid')\n", (1030, 1073), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((1093, 1142), 'keras.layers.Conv2D', 'Conv2D', (['(64)', '(3)'], {'activation': '"""relu"""', 'padding': '"""valid"""'}), "(64, 3, activation='relu', padding='valid')\n", (1099, 1142), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((1163, 1172), 'keras.layers.Flatten', 'Flatten', ([], {}), '()\n', (1170, 1172), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((1263, 1294), 'keras.layers.Dense', 'Dense', (['(100)'], {'activation': '"""linear"""'}), "(100, activation='linear')\n", (1268, 1294), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((1311, 1341), 'keras.layers.Dense', 'Dense', (['(50)'], {'activation': '"""linear"""'}), "(50, activation='linear')\n", (1316, 1341), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((1358, 1388), 'keras.layers.Dense', 'Dense', (['(10)'], {'activation': '"""linear"""'}), "(10, activation='linear')\n", (1363, 1388), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((1406, 1435), 'keras.layers.Dense', 'Dense', (['(1)'], {'activation': '"""linear"""'}), "(1, activation='linear')\n", (1411, 1435), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((1632, 1692), 'keras.layers.Lambda', 'Lambda', (['(lambda x: x / 255.0 - 0.5)'], {'input_shape': '(160, 320, 3)'}), '(lambda x: x / 255.0 - 0.5, input_shape=(160, 320, 3))\n', (1638, 1692), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((1711, 1750), 'keras.layers.Cropping2D', 'Cropping2D', ([], {'cropping': '((70, 25), (0, 0))'}), '(cropping=((70, 25), (0, 0)))\n', (1721, 1750), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((1769, 1821), 'keras.layers.Conv2D', 'Conv2D', (['(24)', '(5)', '(2)'], {'activation': '"""relu"""', 'padding': '"""valid"""'}), "(24, 5, 2, activation='relu', padding='valid')\n", (1775, 1821), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((1840, 1892), 'keras.layers.Conv2D', 'Conv2D', (['(36)', '(5)', '(2)'], {'activation': '"""relu"""', 'padding': '"""valid"""'}), "(36, 5, 2, activation='relu', padding='valid')\n", (1846, 1892), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((1911, 1963), 'keras.layers.Conv2D', 'Conv2D', (['(48)', '(5)', '(2)'], {'activation': '"""relu"""', 'padding': '"""valid"""'}), "(48, 5, 2, activation='relu', padding='valid')\n", (1917, 1963), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((1982, 2031), 'keras.layers.Conv2D', 'Conv2D', (['(64)', '(3)'], {'activation': '"""relu"""', 'padding': '"""valid"""'}), "(64, 3, activation='relu', padding='valid')\n", (1988, 2031), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((2051, 2100), 'keras.layers.Conv2D', 'Conv2D', (['(64)', '(3)'], {'activation': '"""relu"""', 'padding': '"""valid"""'}), "(64, 3, activation='relu', padding='valid')\n", (2057, 2100), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((2121, 2130), 'keras.layers.Flatten', 'Flatten', ([], {}), '()\n', (2128, 2130), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((2221, 2250), 'keras.layers.Dense', 'Dense', (['(100)'], {'activation': '"""tanh"""'}), "(100, activation='tanh')\n", (2226, 2250), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((2267, 2295), 'keras.layers.Dense', 'Dense', (['(50)'], {'activation': '"""tanh"""'}), "(50, activation='tanh')\n", (2272, 2295), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((2312, 2340), 'keras.layers.Dense', 'Dense', (['(10)'], {'activation': '"""tanh"""'}), "(10, activation='tanh')\n", (2317, 2340), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((2358, 2387), 'keras.layers.Dense', 'Dense', (['(1)'], {'activation': '"""linear"""'}), "(1, activation='linear')\n", (2363, 2387), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((2950, 3010), 'keras.layers.Lambda', 'Lambda', (['(lambda x: x / 255.0 - 0.5)'], {'input_shape': '(160, 320, 3)'}), '(lambda x: x / 255.0 - 0.5, input_shape=(160, 320, 3))\n', (2956, 3010), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((3032, 3071), 'keras.layers.Cropping2D', 'Cropping2D', ([], {'cropping': '((70, 25), (0, 0))'}), '(cropping=((70, 25), (0, 0)))\n', (3042, 3071), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((3096, 3148), 'keras.layers.Conv2D', 'Conv2D', (['(24)', '(5)', '(2)'], {'activation': '"""relu"""', 'padding': '"""valid"""'}), "(24, 5, 2, activation='relu', padding='valid')\n", (3102, 3148), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((3171, 3223), 'keras.layers.Conv2D', 'Conv2D', (['(36)', '(5)', '(2)'], {'activation': '"""relu"""', 'padding': '"""valid"""'}), "(36, 5, 2, activation='relu', padding='valid')\n", (3177, 3223), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((3246, 3298), 'keras.layers.Conv2D', 'Conv2D', (['(48)', '(5)', '(2)'], {'activation': '"""relu"""', 'padding': '"""valid"""'}), "(48, 5, 2, activation='relu', padding='valid')\n", (3252, 3298), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((3321, 3370), 'keras.layers.Conv2D', 'Conv2D', (['(64)', '(3)'], {'activation': '"""relu"""', 'padding': '"""valid"""'}), "(64, 3, activation='relu', padding='valid')\n", (3327, 3370), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((3396, 3445), 'keras.layers.Conv2D', 'Conv2D', (['(64)', '(3)'], {'activation': '"""relu"""', 'padding': '"""valid"""'}), "(64, 3, activation='relu', padding='valid')\n", (3402, 3445), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((3472, 3481), 'keras.layers.Flatten', 'Flatten', ([], {}), '()\n', (3479, 3481), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((3500, 3531), 'keras.layers.Dense', 'Dense', (['(100)'], {'activation': '"""linear"""'}), "(100, activation='linear')\n", (3505, 3531), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((3556, 3586), 'keras.layers.Dense', 'Dense', (['(50)'], {'activation': '"""linear"""'}), "(50, activation='linear')\n", (3561, 3586), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((3608, 3638), 'keras.layers.Dense', 'Dense', (['(10)'], {'activation': '"""linear"""'}), "(10, activation='linear')\n", (3613, 3638), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((3660, 3689), 'keras.layers.Dense', 'Dense', (['(1)'], {'activation': '"""linear"""'}), "(1, activation='linear')\n", (3665, 3689), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((4270, 4330), 'keras.layers.Lambda', 'Lambda', (['(lambda x: x / 255.0 - 0.5)'], {'input_shape': '(160, 320, 3)'}), '(lambda x: x / 255.0 - 0.5, input_shape=(160, 320, 3))\n', (4276, 4330), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((4349, 4388), 'keras.layers.Cropping2D', 'Cropping2D', ([], {'cropping': '((70, 25), (0, 0))'}), '(cropping=((70, 25), (0, 0)))\n', (4359, 4388), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((4407, 4459), 'keras.layers.Conv2D', 'Conv2D', (['(24)', '(5)', '(2)'], {'activation': '"""relu"""', 'padding': '"""valid"""'}), "(24, 5, 2, activation='relu', padding='valid')\n", (4413, 4459), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((4478, 4530), 'keras.layers.Conv2D', 'Conv2D', (['(36)', '(5)', '(2)'], {'activation': '"""relu"""', 'padding': '"""valid"""'}), "(36, 5, 2, activation='relu', padding='valid')\n", (4484, 4530), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((4549, 4601), 'keras.layers.Conv2D', 'Conv2D', (['(48)', '(5)', '(2)'], {'activation': '"""relu"""', 'padding': '"""valid"""'}), "(48, 5, 2, activation='relu', padding='valid')\n", (4555, 4601), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((4620, 4669), 'keras.layers.Conv2D', 'Conv2D', (['(64)', '(3)'], {'activation': '"""relu"""', 'padding': '"""valid"""'}), "(64, 3, activation='relu', padding='valid')\n", (4626, 4669), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((4689, 4738), 'keras.layers.Conv2D', 'Conv2D', (['(64)', '(3)'], {'activation': '"""relu"""', 'padding': '"""valid"""'}), "(64, 3, activation='relu', padding='valid')\n", (4695, 4738), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((4759, 4768), 'keras.layers.Flatten', 'Flatten', ([], {}), '()\n', (4766, 4768), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((4784, 4813), 'keras.layers.Dense', 'Dense', (['(100)'], {'activation': '"""tanh"""'}), "(100, activation='tanh')\n", (4789, 4813), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((4830, 4842), 'keras.layers.Dropout', 'Dropout', (['(0.5)'], {}), '(0.5)\n', (4837, 4842), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((4857, 4885), 'keras.layers.Dense', 'Dense', (['(50)'], {'activation': '"""tanh"""'}), "(50, activation='tanh')\n", (4862, 4885), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((4902, 4914), 'keras.layers.Dropout', 'Dropout', (['(0.5)'], {}), '(0.5)\n', (4909, 4914), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((4929, 4957), 'keras.layers.Dense', 'Dense', (['(10)'], {'activation': '"""tanh"""'}), "(10, activation='tanh')\n", (4934, 4957), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((4975, 4987), 'keras.layers.Dropout', 'Dropout', (['(0.5)'], {}), '(0.5)\n', (4982, 4987), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((5002, 5031), 'keras.layers.Dense', 'Dense', (['(1)'], {'activation': '"""linear"""'}), "(1, activation='linear')\n", (5007, 5031), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((5585, 5645), 'keras.layers.Lambda', 'Lambda', (['(lambda x: x / 255.0 - 0.5)'], {'input_shape': '(160, 320, 3)'}), '(lambda x: x / 255.0 - 0.5, input_shape=(160, 320, 3))\n', (5591, 5645), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((5664, 5703), 'keras.layers.Cropping2D', 'Cropping2D', ([], {'cropping': '((70, 25), (0, 0))'}), '(cropping=((70, 25), (0, 0)))\n', (5674, 5703), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((5722, 5774), 'keras.layers.Conv2D', 'Conv2D', (['(24)', '(5)', '(2)'], {'activation': '"""relu"""', 'padding': '"""valid"""'}), "(24, 5, 2, activation='relu', padding='valid')\n", (5728, 5774), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((5793, 5845), 'keras.layers.Conv2D', 'Conv2D', (['(36)', '(5)', '(2)'], {'activation': '"""relu"""', 'padding': '"""valid"""'}), "(36, 5, 2, activation='relu', padding='valid')\n", (5799, 5845), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((5864, 5916), 'keras.layers.Conv2D', 'Conv2D', (['(48)', '(5)', '(2)'], {'activation': '"""relu"""', 'padding': '"""valid"""'}), "(48, 5, 2, activation='relu', padding='valid')\n", (5870, 5916), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((5935, 5984), 'keras.layers.Conv2D', 'Conv2D', (['(64)', '(3)'], {'activation': '"""relu"""', 'padding': '"""valid"""'}), "(64, 3, activation='relu', padding='valid')\n", (5941, 5984), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((6004, 6053), 'keras.layers.Conv2D', 'Conv2D', (['(64)', '(3)'], {'activation': '"""relu"""', 'padding': '"""valid"""'}), "(64, 3, activation='relu', padding='valid')\n", (6010, 6053), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((6074, 6083), 'keras.layers.Flatten', 'Flatten', ([], {}), '()\n', (6081, 6083), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((6174, 6203), 'keras.layers.Dense', 'Dense', (['(100)'], {'activation': '"""tanh"""'}), "(100, activation='tanh')\n", (6179, 6203), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((6220, 6232), 'keras.layers.Dropout', 'Dropout', (['(0.5)'], {}), '(0.5)\n', (6227, 6232), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((6247, 6275), 'keras.layers.Dense', 'Dense', (['(50)'], {'activation': '"""tanh"""'}), "(50, activation='tanh')\n", (6252, 6275), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((6292, 6305), 'keras.layers.Dropout', 'Dropout', (['(0.25)'], {}), '(0.25)\n', (6299, 6305), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((6320, 6348), 'keras.layers.Dense', 'Dense', (['(10)'], {'activation': '"""tanh"""'}), "(10, activation='tanh')\n", (6325, 6348), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((6366, 6380), 'keras.layers.Dropout', 'Dropout', (['(0.125)'], {}), '(0.125)\n', (6373, 6380), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((6395, 6424), 'keras.layers.Dense', 'Dense', (['(1)'], {'activation': '"""linear"""'}), "(1, activation='linear')\n", (6400, 6424), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((6978, 7038), 'keras.layers.Lambda', 'Lambda', (['(lambda x: x / 255.0 - 0.5)'], {'input_shape': '(160, 320, 3)'}), '(lambda x: x / 255.0 - 0.5, input_shape=(160, 320, 3))\n', (6984, 7038), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((7057, 7096), 'keras.layers.Cropping2D', 'Cropping2D', ([], {'cropping': '((70, 25), (0, 0))'}), '(cropping=((70, 25), (0, 0)))\n', (7067, 7096), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((7115, 7167), 'keras.layers.Conv2D', 'Conv2D', (['(24)', '(5)', '(2)'], {'activation': '"""relu"""', 'padding': '"""valid"""'}), "(24, 5, 2, activation='relu', padding='valid')\n", (7121, 7167), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((7186, 7238), 'keras.layers.Conv2D', 'Conv2D', (['(36)', '(5)', '(2)'], {'activation': '"""relu"""', 'padding': '"""valid"""'}), "(36, 5, 2, activation='relu', padding='valid')\n", (7192, 7238), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((7257, 7309), 'keras.layers.Conv2D', 'Conv2D', (['(48)', '(5)', '(2)'], {'activation': '"""relu"""', 'padding': '"""valid"""'}), "(48, 5, 2, activation='relu', padding='valid')\n", (7263, 7309), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((7328, 7377), 'keras.layers.Conv2D', 'Conv2D', (['(64)', '(3)'], {'activation': '"""relu"""', 'padding': '"""valid"""'}), "(64, 3, activation='relu', padding='valid')\n", (7334, 7377), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((7397, 7446), 'keras.layers.Conv2D', 'Conv2D', (['(64)', '(3)'], {'activation': '"""relu"""', 'padding': '"""valid"""'}), "(64, 3, activation='relu', padding='valid')\n", (7403, 7446), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((7467, 7476), 'keras.layers.Flatten', 'Flatten', ([], {}), '()\n', (7474, 7476), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((7492, 7521), 'keras.layers.Dense', 'Dense', (['(100)'], {'activation': '"""tanh"""'}), "(100, activation='tanh')\n", (7497, 7521), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((7538, 7550), 'keras.layers.Dropout', 'Dropout', (['(0.5)'], {}), '(0.5)\n', (7545, 7550), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((7565, 7593), 'keras.layers.Dense', 'Dense', (['(50)'], {'activation': '"""tanh"""'}), "(50, activation='tanh')\n", (7570, 7593), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((7610, 7623), 'keras.layers.Dropout', 'Dropout', (['(0.25)'], {}), '(0.25)\n', (7617, 7623), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((7638, 7666), 'keras.layers.Dense', 'Dense', (['(10)'], {'activation': '"""tanh"""'}), "(10, activation='tanh')\n", (7643, 7666), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((7684, 7713), 'keras.layers.Dense', 'Dense', (['(1)'], {'activation': '"""linear"""'}), "(1, activation='linear')\n", (7689, 7713), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((8267, 8327), 'keras.layers.Lambda', 'Lambda', (['(lambda x: x / 255.0 - 0.5)'], {'input_shape': '(160, 320, 3)'}), '(lambda x: x / 255.0 - 0.5, input_shape=(160, 320, 3))\n', (8273, 8327), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((8346, 8385), 'keras.layers.Cropping2D', 'Cropping2D', ([], {'cropping': '((70, 25), (0, 0))'}), '(cropping=((70, 25), (0, 0)))\n', (8356, 8385), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((8404, 8456), 'keras.layers.Conv2D', 'Conv2D', (['(24)', '(5)', '(2)'], {'activation': '"""relu"""', 'padding': '"""valid"""'}), "(24, 5, 2, activation='relu', padding='valid')\n", (8410, 8456), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((8475, 8527), 'keras.layers.Conv2D', 'Conv2D', (['(36)', '(5)', '(2)'], {'activation': '"""relu"""', 'padding': '"""valid"""'}), "(36, 5, 2, activation='relu', padding='valid')\n", (8481, 8527), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((8546, 8598), 'keras.layers.Conv2D', 'Conv2D', (['(48)', '(5)', '(2)'], {'activation': '"""relu"""', 'padding': '"""valid"""'}), "(48, 5, 2, activation='relu', padding='valid')\n", (8552, 8598), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((8617, 8666), 'keras.layers.Conv2D', 'Conv2D', (['(64)', '(3)'], {'activation': '"""relu"""', 'padding': '"""valid"""'}), "(64, 3, activation='relu', padding='valid')\n", (8623, 8666), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((8686, 8735), 'keras.layers.Conv2D', 'Conv2D', (['(64)', '(3)'], {'activation': '"""relu"""', 'padding': '"""valid"""'}), "(64, 3, activation='relu', padding='valid')\n", (8692, 8735), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((8756, 8765), 'keras.layers.Flatten', 'Flatten', ([], {}), '()\n', (8763, 8765), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((8781, 8793), 'keras.layers.Dropout', 'Dropout', (['(0.5)'], {}), '(0.5)\n', (8788, 8793), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((8808, 8837), 'keras.layers.Dense', 'Dense', (['(100)'], {'activation': '"""tanh"""'}), "(100, activation='tanh')\n", (8813, 8837), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((8854, 8866), 'keras.layers.Dropout', 'Dropout', (['(0.5)'], {}), '(0.5)\n', (8861, 8866), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((8881, 8909), 'keras.layers.Dense', 'Dense', (['(50)'], {'activation': '"""tanh"""'}), "(50, activation='tanh')\n", (8886, 8909), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((8926, 8939), 'keras.layers.Dropout', 'Dropout', (['(0.25)'], {}), '(0.25)\n', (8933, 8939), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((8954, 8982), 'keras.layers.Dense', 'Dense', (['(10)'], {'activation': '"""tanh"""'}), "(10, activation='tanh')\n", (8959, 8982), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((9000, 9029), 'keras.layers.Dense', 'Dense', (['(1)'], {'activation': '"""linear"""'}), "(1, activation='linear')\n", (9005, 9029), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((9591, 9651), 'keras.layers.Lambda', 'Lambda', (['(lambda x: x / 255.0 - 0.5)'], {'input_shape': '(160, 320, 3)'}), '(lambda x: x / 255.0 - 0.5, input_shape=(160, 320, 3))\n', (9597, 9651), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((9670, 9709), 'keras.layers.Cropping2D', 'Cropping2D', ([], {'cropping': '((70, 25), (0, 0))'}), '(cropping=((70, 25), (0, 0)))\n', (9680, 9709), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((9775, 9826), 'keras.layers.Conv2D', 'Conv2D', (['(24)', '(5)', '(1)'], {'activation': '"""relu"""', 'padding': '"""same"""'}), "(24, 5, 1, activation='relu', padding='same')\n", (9781, 9826), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((9844, 9855), 'keras.layers.MaxPool2D', 'MaxPool2D', ([], {}), '()\n', (9853, 9855), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((9871, 9922), 'keras.layers.Conv2D', 'Conv2D', (['(36)', '(5)', '(1)'], {'activation': '"""relu"""', 'padding': '"""same"""'}), "(36, 5, 1, activation='relu', padding='same')\n", (9877, 9922), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((9940, 9951), 'keras.layers.MaxPool2D', 'MaxPool2D', ([], {}), '()\n', (9949, 9951), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((9967, 10018), 'keras.layers.Conv2D', 'Conv2D', (['(48)', '(5)', '(1)'], {'activation': '"""relu"""', 'padding': '"""same"""'}), "(48, 5, 1, activation='relu', padding='same')\n", (9973, 10018), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((10036, 10047), 'keras.layers.MaxPool2D', 'MaxPool2D', ([], {}), '()\n', (10045, 10047), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((10063, 10114), 'keras.layers.Conv2D', 'Conv2D', (['(64)', '(3)', '(1)'], {'activation': '"""relu"""', 'padding': '"""same"""'}), "(64, 3, 1, activation='relu', padding='same')\n", (10069, 10114), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((10132, 10143), 'keras.layers.MaxPool2D', 'MaxPool2D', ([], {}), '()\n', (10141, 10143), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((10159, 10210), 'keras.layers.Conv2D', 'Conv2D', (['(64)', '(3)', '(1)'], {'activation': '"""relu"""', 'padding': '"""same"""'}), "(64, 3, 1, activation='relu', padding='same')\n", (10165, 10210), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((10228, 10255), 'keras.layers.MaxPool2D', 'MaxPool2D', ([], {'pool_size': '(4, 2)'}), '(pool_size=(4, 2))\n', (10237, 10255), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((10317, 10326), 'keras.layers.Flatten', 'Flatten', ([], {}), '()\n', (10324, 10326), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((10416, 10445), 'keras.layers.Dense', 'Dense', (['(300)'], {'activation': '"""tanh"""'}), "(300, activation='tanh')\n", (10421, 10445), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((10462, 10491), 'keras.layers.Dense', 'Dense', (['(100)'], {'activation': '"""tanh"""'}), "(100, activation='tanh')\n", (10467, 10491), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((10508, 10536), 'keras.layers.Dense', 'Dense', (['(50)'], {'activation': '"""tanh"""'}), "(50, activation='tanh')\n", (10513, 10536), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((10553, 10581), 'keras.layers.Dense', 'Dense', (['(10)'], {'activation': '"""tanh"""'}), "(10, activation='tanh')\n", (10558, 10581), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((10598, 10627), 'keras.layers.Dense', 'Dense', (['(1)'], {'activation': '"""linear"""'}), "(1, activation='linear')\n", (10603, 10627), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((11197, 11257), 'keras.layers.Lambda', 'Lambda', (['(lambda x: x / 255.0 - 0.5)'], {'input_shape': '(160, 320, 3)'}), '(lambda x: x / 255.0 - 0.5, input_shape=(160, 320, 3))\n', (11203, 11257), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((11279, 11318), 'keras.layers.Cropping2D', 'Cropping2D', ([], {'cropping': '((70, 25), (0, 0))'}), '(cropping=((70, 25), (0, 0)))\n', (11289, 11318), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((11393, 11444), 'keras.layers.Conv2D', 'Conv2D', (['(24)', '(5)', '(1)'], {'activation': '"""relu"""', 'padding': '"""same"""'}), "(24, 5, 1, activation='relu', padding='same')\n", (11399, 11444), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((11465, 11476), 'keras.layers.MaxPool2D', 'MaxPool2D', ([], {}), '()\n', (11474, 11476), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((11495, 11546), 'keras.layers.Conv2D', 'Conv2D', (['(36)', '(5)', '(1)'], {'activation': '"""relu"""', 'padding': '"""same"""'}), "(36, 5, 1, activation='relu', padding='same')\n", (11501, 11546), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((11567, 11578), 'keras.layers.MaxPool2D', 'MaxPool2D', ([], {}), '()\n', (11576, 11578), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((11597, 11648), 'keras.layers.Conv2D', 'Conv2D', (['(48)', '(5)', '(1)'], {'activation': '"""relu"""', 'padding': '"""same"""'}), "(48, 5, 1, activation='relu', padding='same')\n", (11603, 11648), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((11669, 11680), 'keras.layers.MaxPool2D', 'MaxPool2D', ([], {}), '()\n', (11678, 11680), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((11699, 11750), 'keras.layers.Conv2D', 'Conv2D', (['(64)', '(3)', '(1)'], {'activation': '"""relu"""', 'padding': '"""same"""'}), "(64, 3, 1, activation='relu', padding='same')\n", (11705, 11750), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((11771, 11782), 'keras.layers.MaxPool2D', 'MaxPool2D', ([], {}), '()\n', (11780, 11782), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((11801, 11852), 'keras.layers.Conv2D', 'Conv2D', (['(64)', '(3)', '(1)'], {'activation': '"""relu"""', 'padding': '"""same"""'}), "(64, 3, 1, activation='relu', padding='same')\n", (11807, 11852), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((11873, 11900), 'keras.layers.MaxPool2D', 'MaxPool2D', ([], {'pool_size': '(4, 2)'}), '(pool_size=(4, 2))\n', (11882, 11900), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((11966, 11975), 'keras.layers.Flatten', 'Flatten', ([], {}), '()\n', (11973, 11975), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((11994, 12025), 'keras.layers.Dense', 'Dense', (['(300)'], {'activation': '"""linear"""'}), "(300, activation='linear')\n", (11999, 12025), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((12046, 12077), 'keras.layers.Dense', 'Dense', (['(100)'], {'activation': '"""linear"""'}), "(100, activation='linear')\n", (12051, 12077), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((12098, 12128), 'keras.layers.Dense', 'Dense', (['(50)'], {'activation': '"""linear"""'}), "(50, activation='linear')\n", (12103, 12128), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((12150, 12180), 'keras.layers.Dense', 'Dense', (['(10)'], {'activation': '"""linear"""'}), "(10, activation='linear')\n", (12155, 12180), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((12206, 12235), 'keras.layers.Dense', 'Dense', (['(1)'], {'activation': '"""linear"""'}), "(1, activation='linear')\n", (12211, 12235), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((12822, 12882), 'keras.layers.Lambda', 'Lambda', (['(lambda x: x / 255.0 - 0.5)'], {'input_shape': '(160, 320, 3)'}), '(lambda x: x / 255.0 - 0.5, input_shape=(160, 320, 3))\n', (12828, 12882), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((12901, 12940), 'keras.layers.Cropping2D', 'Cropping2D', ([], {'cropping': '((70, 25), (0, 0))'}), '(cropping=((70, 25), (0, 0)))\n', (12911, 12940), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((13005, 13056), 'keras.layers.Conv2D', 'Conv2D', (['(24)', '(5)', '(1)'], {'activation': '"""relu"""', 'padding': '"""same"""'}), "(24, 5, 1, activation='relu', padding='same')\n", (13011, 13056), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((13074, 13085), 'keras.layers.MaxPool2D', 'MaxPool2D', ([], {}), '()\n', (13083, 13085), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((13101, 13152), 'keras.layers.Conv2D', 'Conv2D', (['(36)', '(5)', '(1)'], {'activation': '"""relu"""', 'padding': '"""same"""'}), "(36, 5, 1, activation='relu', padding='same')\n", (13107, 13152), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((13170, 13181), 'keras.layers.MaxPool2D', 'MaxPool2D', ([], {}), '()\n', (13179, 13181), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((13197, 13248), 'keras.layers.Conv2D', 'Conv2D', (['(48)', '(5)', '(1)'], {'activation': '"""relu"""', 'padding': '"""same"""'}), "(48, 5, 1, activation='relu', padding='same')\n", (13203, 13248), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((13266, 13277), 'keras.layers.MaxPool2D', 'MaxPool2D', ([], {}), '()\n', (13275, 13277), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((13293, 13344), 'keras.layers.Conv2D', 'Conv2D', (['(64)', '(3)', '(1)'], {'activation': '"""relu"""', 'padding': '"""same"""'}), "(64, 3, 1, activation='relu', padding='same')\n", (13299, 13344), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((13362, 13373), 'keras.layers.MaxPool2D', 'MaxPool2D', ([], {}), '()\n', (13371, 13373), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((13389, 13440), 'keras.layers.Conv2D', 'Conv2D', (['(64)', '(3)', '(1)'], {'activation': '"""relu"""', 'padding': '"""same"""'}), "(64, 3, 1, activation='relu', padding='same')\n", (13395, 13440), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((13458, 13485), 'keras.layers.MaxPool2D', 'MaxPool2D', ([], {'pool_size': '(4, 2)'}), '(pool_size=(4, 2))\n', (13467, 13485), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((13548, 13557), 'keras.layers.Flatten', 'Flatten', ([], {}), '()\n', (13555, 13557), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((13573, 13602), 'keras.layers.Dense', 'Dense', (['(100)'], {'activation': '"""tanh"""'}), "(100, activation='tanh')\n", (13578, 13602), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((13619, 13631), 'keras.layers.Dropout', 'Dropout', (['(0.5)'], {}), '(0.5)\n', (13626, 13631), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((13646, 13674), 'keras.layers.Dense', 'Dense', (['(50)'], {'activation': '"""tanh"""'}), "(50, activation='tanh')\n", (13651, 13674), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((13691, 13704), 'keras.layers.Dropout', 'Dropout', (['(0.25)'], {}), '(0.25)\n', (13698, 13704), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((13719, 13747), 'keras.layers.Dense', 'Dense', (['(10)'], {'activation': '"""tanh"""'}), "(10, activation='tanh')\n", (13724, 13747), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((13765, 13794), 'keras.layers.Dense', 'Dense', (['(1)'], {'activation': '"""linear"""'}), "(1, activation='linear')\n", (13770, 13794), False, 'from keras.layers import Flatten, Dense, Lambda, Cropping2D, Conv2D, Dropout, MaxPool2D\n'), ((15903, 15927), 'cv2.imread', 'cv2.imread', (['current_path'], {}), '(current_path)\n', (15913, 15927), False, 'import cv2\n'), ((16035, 16053), 'cv2.flip', 'cv2.flip', (['image', '(1)'], {}), '(image, 1)\n', (16043, 16053), False, 'import cv2\n'), ((16686, 16702), 'numpy.array', 'np.array', (['images'], {}), '(images)\n', (16694, 16702), True, 'import numpy as np\n'), ((16706, 16728), 'numpy.array', 'np.array', (['measurements'], {}), '(measurements)\n', (16714, 16728), True, 'import numpy as np\n'), ((2712, 2729), 'tensorflow.multiply', 'tf.multiply', (['x', '(2)'], {}), '(x, 2)\n', (2723, 2729), True, 'import tensorflow as tf\n'), ((4029, 4046), 'tensorflow.multiply', 'tf.multiply', (['x', '(2)'], {}), '(x, 2)\n', (4040, 4046), True, 'import tensorflow as tf\n'), ((5356, 5373), 'tensorflow.multiply', 'tf.multiply', (['x', '(2)'], {}), '(x, 2)\n', (5367, 5373), True, 'import tensorflow as tf\n'), ((6749, 6766), 'tensorflow.multiply', 'tf.multiply', (['x', '(2)'], {}), '(x, 2)\n', (6760, 6766), True, 'import tensorflow as tf\n'), ((8038, 8055), 'tensorflow.multiply', 'tf.multiply', (['x', '(2)'], {}), '(x, 2)\n', (8049, 8055), True, 'import tensorflow as tf\n'), ((9354, 9371), 'tensorflow.multiply', 'tf.multiply', (['x', '(2)'], {}), '(x, 2)\n', (9365, 9371), True, 'import tensorflow as tf\n'), ((10953, 10970), 'tensorflow.multiply', 'tf.multiply', (['x', '(2)'], {}), '(x, 2)\n', (10964, 10970), True, 'import tensorflow as tf\n'), ((12576, 12593), 'tensorflow.multiply', 'tf.multiply', (['x', '(2)'], {}), '(x, 2)\n', (12587, 12593), True, 'import tensorflow as tf\n'), ((14119, 14136), 'tensorflow.multiply', 'tf.multiply', (['x', '(2)'], {}), '(x, 2)\n', (14130, 14136), True, 'import tensorflow as tf\n')]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.