def translate_values_frame_sorted(
x_frame_sorted: np.array,
frame_sorted: np.array,
bruker_translator_foo: Callable,
x_dtype,
result_dtype,
) -> np.array:
assert x_dtype in (
np.double, np.uint32
), f"Wrong x_dtype: Bruker code only uses np.double and np.uint32, not {x_dtype}."
assert result_dtype in (
np.double, np.uint32
), f"Wrong result_dtype: Bruker code only uses np.double and np.uint32, not {x_dtype}."
if x_frame_sorted.dtype != x_dtype:
x_frame_sorted = x_frame_sorted.astype(x_dtype)
if frame_sorted.dtype != np.uint32:
frame_sorted = frame_sorted.astype(np.uint32)
result = np.empty(x_frame_sorted.shape, dtype=result_dtype)
i_prev = 0
frame_id_prev = frame_sorted[0]
for i, frame_id in enumerate(frame_sorted):
if frame_id != frame_id_prev:
result[i_prev:i] = bruker_translator_foo(
frame_id_prev,
x_frame_sorted[i_prev:i],
)
i_prev = i
frame_id_prev = frame_id
result[i_prev:len(result)] = bruker_translator_foo(
frame_id_prev,
x_frame_sorted[i_prev:len(result)],
)
return result
def _coordinate(self,
img: np.array,
color_space="rgb",
imagenet_mean=False) -> np.array:
if color_space == "yuv":
img = img.astype(np.uint8)
img = cv.cvtColor(img, cv.COLOR_BGR2YCrCb)
img = img.transpose(2, 0, 1).astype(np.float32)
elif color_space == "gray":
img = img.astype(np.uint8)
img = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
img = np.expand_dims(img, axis=0).astype(np.float32)
else:
img = img[:, :, ::-1].astype(np.float32)
img = img = img.transpose(2, 0, 1)
if imagenet_mean:
height, width = img.shape[1], img.shape[2]
mean = np.tile(self.mean.reshape(3, 1, 1), (1, height, width))
std = np.tile(self.std.reshape(3, 1, 1), (1, height, width))
img = (img - mean) / std
else:
img = (img - 127.5) / 127.5
img = np.expand_dims(img, axis=0)
img = torch.cuda.FloatTensor(img)
return img
def sample_fs(a: np.array, grid_sz: np.array = None, rescale=True):
"""Samples the Fourier series."""
# Size of the fourier series
sz = np.array([a.shape[2], 2 * a.shape[3] - 1], 'float32')
# Default grid
if grid_sz is None or sz[0] == grid_sz[0] and sz[1] == grid_sz[1]:
if rescale:
return np.prod(sz) * cifft2(a)
return cifft2(a)
if sz[0] > grid_sz[0] or sz[1] > grid_sz[1]:
raise ValueError(
"Only grid sizes that are smaller than the Fourier series size are supported."
)
tot_pad = (grid_sz - sz).tolist()
is_even = [s % 2 == 0 for s in sz]
# Compute paddings
pad_top = int((tot_pad[0] + 1) / 2) if is_even[0] else int(tot_pad[0] / 2)
pad_bottom = int(tot_pad[0] - pad_top)
pad_right = int((tot_pad[1] + 1) / 2)
if rescale:
return np.prod(grid_sz) * cifft2(
_padding(a, (0, 0, 0, pad_right, pad_top, pad_bottom)),
signal_sizes=grid_sz.astype('long').tolist())
else:
return cifft2(_padding(a, (0, 0, 0, pad_right, pad_top, pad_bottom)),
signal_sizes=grid_sz.astype('long').tolist())
def bgr2ycbcr(img: np.array, only_y: bool = True):
""" bgr image to ycbcr image,
inspired by https://github.com/xinntao/BasicSR/blob/master/metrics/calculate_PSNR_SSIM.py
:param img: np.array. expected types, uint8 & float
uint8 : [0, 255]
float : [0, 1]
:param only_y: bool. return only y channel
:return: np.array.
"""
_dtype = img.dtype
if not _dtype == np.uint8:
img *= 255.
img.astype(np.float32)
if only_y:
rlt = np.dot(img,
[24.966, 128.553, 65.481]) / 255. + 16.
else:
rlt = np.matmul(img, [
[24.966, 112., -18.214],
[128.553, -74.203, -93.786],
[65.481, -37.797, 112.]
]) / 255. + [16, 128, 128]
if _dtype == np.uint8:
rlt = rlt.round()
else:
rlt /= 255.
return rlt.astype(_dtype)
def siddon_fp_arbitrary(projector: ct_projector, img: np.array,
det_center: np.array, det_u: np.array, det_v: np.array,
src: np.array) -> np.array:
'''
Conebeam forward projection with arbitrary geometry and flat panel. Using Siddon ray tracing.
The size of the img will override that of projector.nx, projector.ny, projector.nz. The projection size
will be [batch, nview, projector.nv, projector.nu].
Parameters
-------------------------
img: np.array(float32) of size [batch, nz, ny, nx].
The image to be projected, nz, ny, nx can be different than projector.nz, projector.ny, projector.nx.
The projector will always use the size of the image.
det_center: np.array(float32) of size [nview, 3].
The center of the detector in mm. Each row records the center of detector as (z, y, x).
det_u: np.array(float32) of size [nview, 3].
The u axis of the detector. Each row is a normalized vector in (z, y, x).
det_v: np.array(float32) of size [nview ,3].
The v axis of the detector. Each row is a normalized vector in (z, y, x).
src: np.array(float32) of size [nview, 3].
The src positions in mm. Each row records in the source position as (z, y, x).
Returns
-------------------------
prj: np.array(float32) of size [batch, projector.nview, projector.nv, projector.nu].
The forward projection.
'''
# make sure they are float32
img = img.astype(np.float32)
det_center = det_center.astype(np.float32)
det_u = det_u.astype(np.float32)
det_v = det_v.astype(np.float32)
src = src.astype(np.float32)
# projection of size
prj = np.zeros(
[img.shape[0], det_center.shape[0], projector.nv, projector.nu],
np.float32)
module.cSiddonConeProjectionArbitrary.restype = c_int
err = module.cSiddonConeProjectionArbitrary(
prj.ctypes.data_as(POINTER(c_float)),
img.ctypes.data_as(POINTER(c_float)),
det_center.ctypes.data_as(POINTER(c_float)),
det_u.ctypes.data_as(POINTER(c_float)),
det_v.ctypes.data_as(POINTER(c_float)),
src.ctypes.data_as(POINTER(c_float)), c_ulong(img.shape[0]),
c_ulong(img.shape[3]), c_ulong(img.shape[2]), c_ulong(img.shape[1]),
c_float(projector.dx), c_float(projector.dy), c_float(projector.dz),
c_float(projector.cx), c_float(projector.cy), c_float(projector.cz),
c_ulong(prj.shape[3]), c_ulong(prj.shape[2]), c_ulong(prj.shape[1]),
c_float(projector.du), c_float(projector.dv), c_float(projector.off_u),
c_float(projector.off_v))
if err != 0:
print(err)
return prj
def nlm(img: np.array,
guide: np.array,
d: float,
search_size: Tuple[int, int, int],
kernel_size: Tuple[int, int, int],
kernel_std: float,
eps: float = 1e-6) -> np.array:
'''
Non local mean denoising with guide.
Parameters
-----------------
img: np.array(float32) of shape [batch, nz, ny, nx].
The image to be denoised.
guide: np.array(float32) of shape [batch, nz, ny, nx].
The guide image for NLM.
d: float.
The larger the d, the weaker the guide. d should be estimated based on the noise level of guide.
search_size: tuple of length 3.
The search window size for averaging.
kernel_size: tuple of length 3.
the gaussian kernel size to calculate distance between two points.
kernel_std: float.
Std of the gaussian kernel
eps: float.
Regularization factor.
Returns
-------------------
res: np.array(float) of shape [batch, nz, ny, nx].
The denoised image.
'''
kernel = np.zeros(kernel_size, np.float32)
kernel[int(kernel_size[0] / 2),
int(kernel_size[1] / 2),
int(kernel_size[2] / 2)] = 1
kernel = gaussian_filter(kernel, kernel_std)
res = np.zeros(img.shape, np.float32)
img = img.astype(np.float32)
guide = guide.astype(np.float32)
kernel = kernel.astype(np.float32)
module.cNlm.restype = c_int
err = module.cNlm(res.ctypes.data_as(POINTER(c_float)),
img.ctypes.data_as(POINTER(c_float)),
guide.ctypes.data_as(POINTER(c_float)),
kernel.ctypes.data_as(POINTER(c_float)), c_float(d * d),
c_float(eps), c_int(search_size[2]),
c_int(search_size[1]), c_int(search_size[0]),
c_ulong(img.shape[0]), c_ulong(img.shape[3]),
c_ulong(img.shape[2]), c_ulong(img.shape[1]),
c_int(kernel_size[2]), c_int(kernel_size[1]),
c_int(kernel_size[0]))
if not err == 0:
print(err)
return res
def distance_driven_bp(projector: ct_projector,
prj: np.array,
det_center: np.array,
src: np.array,
branchless: bool = False) -> np.array:
'''
Distance driven backprojection for tomosynthesis. It assumes that the detector has
u=(1,0,0) and v = (0,1,0).
The backprojection should be along the z-axis (main axis for distance driven projection).
The size of the img will override that of projector.nx, projector.ny, projector.nz. The projection size
will be [batch, nview, projector.nv, projector.nu].
Parameters
-------------------------
prj: np.array(float32) of size [batch, nview, nv, nu].
The projection to be backprojected. It will override the default shape predefined,
i.e. projector.nview, projector.nv, projector.nu.
det_center: np.array(float32) of size [nview, 3].
The center of the detector in mm. Each row records the center of detector as (z, y, x).
src: np.array(float32) of size [nview, 3].
The src positions in mm. Each row records in the source position as (z, y, x).
branchless: bool
If True, use the branchless mode (double precision required).
Returns
-------------------------
img: np.array(float32) of size [batch, projector.nz, projector.ny, projector.nx].
The backprojected image.
'''
prj = prj.astype(np.float32)
det_center = det_center.astype(np.float32)
src = src.astype(np.float32)
img = np.zeros([prj.shape[0], projector.nz, projector.ny, projector.nx],
np.float32)
if branchless:
type_projector = 1
else:
type_projector = 0
module.cDistanceDrivenTomoBackprojection.restype = c_int
err = module.cDistanceDrivenTomoBackprojection(
img.ctypes.data_as(POINTER(c_float)),
prj.ctypes.data_as(POINTER(c_float)),
det_center.ctypes.data_as(POINTER(c_float)),
src.ctypes.data_as(POINTER(c_float)), c_ulong(img.shape[0]),
c_ulong(img.shape[3]), c_ulong(img.shape[2]), c_ulong(img.shape[1]),
c_float(projector.dx), c_float(projector.dy), c_float(projector.dz),
c_float(projector.cx), c_float(projector.cy), c_float(projector.cz),
c_ulong(prj.shape[3]), c_ulong(prj.shape[2]), c_ulong(prj.shape[1]),
c_float(projector.du), c_float(projector.dv), c_float(projector.off_u),
c_float(projector.off_v), c_int(type_projector))
if err != 0:
print(err)
return img
def render(self, camera: np.array, light1: np.array):
self.ctx.clear()
self.prog['u_light1'].write(light1.astype('f4'))
self.prog['u_ambient'].write(np.array(0.01).astype('f4'))
self.prog['u_projection'].write(self.projection.astype('f4'))
self.prog['u_modelView'].write(camera.astype('f4'))
self.vao.render()
def __init__(self, bottom_left: Coord, top_right: Coord,
orig_dim: np.array, state_dim: np.array):
self.dx = np.abs(top_right.x - bottom_left.x) / float(orig_dim[0])
self.dy = np.abs(top_right.y - bottom_left.y) / float(orig_dim[1])
self.bottom_left = bottom_left
self.top_right = top_right
self.dim_rescale = np.divide(orig_dim, state_dim.astype(np.float))
self.dim_rescale_inv = np.divide(state_dim, orig_dim.astype(np.float))
self.state_dim = state_dim
def _numpy_downcast(array: np.array) -> np.array:
dtype = array.dtype
if dtype in [np.int32, np.float32]:
return array
elif dtype == np.int64:
return array.astype(np.int32)
elif dtype == np.float64:
return array.astype(np.float32)
else:
raise ValueError(f"Array type {dtype} is not supported!")
def create_percent_diff(area_high: np.array, area_low: np.array) -> np.array:
"""Mask with expected loss of quality.
[-100%..1%] - [0..99]
[1%..100%] - [101..200]
0% - 100
"""
diff = np.round(
(area_high.astype(float) - area_low.astype(float)) / 256 * 100) + 100
assert (diff < 0).sum() + (diff > 200).sum() == 0
return diff.astype("uint8")
def get_transform(v1: np.array, v2: np.array) -> float:
norm_1 = np.linalg.norm(v1)
norm_2 = np.linalg.norm(v2)
ratio = min(1, max(-1, np.dot(v1, v2) / (norm_1 * norm_2)))
angle = math.acos(ratio)
scale = norm_2 / norm_1
if np.linalg.det([v1.astype(np.float32), v2.astype(np.float32)]) > 0:
angle = -angle
return angle, scale
def fbp_bp(projector: ct_projector, prj: np.array,
angles: np.array) -> np.array:
'''
Fanbeam backprojection with circular equiangular detector. Ray driven
and weighted for FBP.
Parameters
----------------
prj: np.array(float32) of size [batch, nview, nv, nu].
The projection to be backprojected. The size does not need to be the same
with projector.nview, projector.nv, projector.nu.
angles: np.array(float32) of size [nview].
The projection angles in radius.
Returns
--------------
img: np.array(float32) of size [batch, projector.nz, projector.ny, projector.nx]
The backprojected image.
'''
prj = prj.astype(np.float32)
angles = angles.astype(np.float32)
img = np.zeros([prj.shape[0], projector.nz, projector.ny, projector.nx],
np.float32)
module.cfbpFanBackprojection.restype = c_int
err = module.cfbpFanBackprojection(img.ctypes.data_as(POINTER(c_float)),
prj.ctypes.data_as(POINTER(c_float)),
angles.ctypes.data_as(POINTER(c_float)),
c_ulong(img.shape[0]),
c_ulong(img.shape[3]),
c_ulong(img.shape[2]),
c_ulong(img.shape[1]),
c_float(projector.dx),
c_float(projector.dy),
c_float(projector.dz),
c_float(projector.cx),
c_float(projector.cy),
c_float(projector.cz),
c_ulong(prj.shape[3]),
c_ulong(prj.shape[2]),
c_ulong(prj.shape[1]),
c_float(projector.du / projector.dsd),
c_float(projector.dv),
c_float(projector.off_u),
c_float(projector.off_v),
c_float(projector.dsd),
c_float(projector.dso))
if err != 0:
print(err)
return img
def normalize(im: np.array) -> np.array:
"""
Linear normalization
http://en.wikipedia.org/wiki/Normalization_%28image_processing%29
"""
im = im.astype(np.float)
minval = np.min(im)
maxval = np.max(im)
if minval != maxval:
im -= minval
im *= (255.0 / (maxval - minval))
return im.astype(np.uint8)
def siddon_fp(projector: ct_projector, img: np.array,
angles: np.array) -> np.array:
'''
Fanbeam forward projection with circular equiangular detector. Siddon ray driven.
Parameters
----------------
img: np.array(float32) of size [batch, nz, ny, nx]
The image to be projected.
angles: np.array(float32) of size [nview]
The projection angles in radius.
Returns
--------------
prj: np.array(float32) of size [batch, projector.nview, projector.nv, projector.nu]
The forward projection.
'''
img = img.astype(np.float32)
angles = angles.astype(np.float32)
prj = np.zeros(
[img.shape[0], len(angles), projector.nv, projector.nu], np.float32)
module.cSiddonFanProjection.restype = c_int
err = module.cSiddonFanProjection(prj.ctypes.data_as(POINTER(c_float)),
img.ctypes.data_as(POINTER(c_float)),
angles.ctypes.data_as(POINTER(c_float)),
c_ulong(img.shape[0]),
c_ulong(img.shape[3]),
c_ulong(img.shape[2]),
c_ulong(img.shape[1]),
c_float(projector.dx),
c_float(projector.dy),
c_float(projector.dz),
c_float(projector.cx),
c_float(projector.cy),
c_float(projector.cz),
c_ulong(prj.shape[3]),
c_ulong(prj.shape[2]),
c_ulong(prj.shape[1]),
c_float(projector.du / projector.dsd),
c_float(projector.dv),
c_float(projector.off_u),
c_float(projector.off_v),
c_float(projector.dsd),
c_float(projector.dso))
if err != 0:
print(err)
return prj
def preprocess_input(image: np.array) -> np.array:
"""preprocess image function
Args:
image (np.array): image as numpy array
Returns:
np.array: preprocesses image as numpy array
"""
image = image.astype(np.float32)
if image.shape[2] == 3:
channel_means = [123.68, 116.779, 103.939]
return (image - [[channel_means]]).astype(np.float32)
else:
return image.astype(np.float32)
def write_bin_grid(path: str, grid: np.array) -> None:
"""
Function for writing a NonLinLoc binary grid
Parameters
----------
path : str
Path for the binary file
grid : numpy array
Three-dimensional numpy array containing the values for the grid.
"""
grid = np.flip(grid, axis=2).reshape((1, grid.size))
grid.astype("float32").tofile(path)
def save_as_bin_file(self,
buffer: np.array,
pre_string: str,
dtype_save=np.uint16) -> None:
""" Saves selected volume in main directory with the established dimensions """
# TODO: Rethink how to handle loading/saving dimensions tuples!!!
vol_dims = self.create_vol_dims_suffix
print(vol_dims)
filename_saving = pre_string + f'_{self.oct_dims[0]}x{self.oct_dims[1]}_' + '.bin'
_path_saving = os.path.join(self.dir_main, filename_saving)
print(f"Saving selected volume to file {filename_saving}... ")
buffer.astype(dtype_save).tofile(_path_saving)
print("[DONE] Saving selected volume!")
def draw_masks(frame: np.array,
detections: Sequence["Detection"],
alpha: float = 0.4,
color=(255, 0, 0)):
if detections is None:
return
frame = frame.astype(np.float32)
for d in detections:
mask = d.mask
idx = np.nonzero(mask)
frame[idx[0], idx[1], :] *= 1.0 - alpha
frame[idx[0], idx[1], :] += alpha * np.array(color)
return frame.astype(np.uint8)
def __init__(self,
image_paths0: list,
image_paths1: list,
image_attrs0: np.array,
image_attrs1: np.array,
labels: np.array,
transform: transforms.Compose = None):
self.image_paths0 = image_paths0
self.image_paths1 = image_paths1
self.image_attrs0 = image_attrs0.astype(np.float32)
self.image_attrs1 = image_attrs1.astype(np.float32)
self.labels = labels
self.transform = transform
def modify_coord_dtype(coord: np.array, dtype: str):
if dtype == 'datetime':
return pd.to_datetime(coord)
if dtype == 'int':
return coord.astype(int)
if dtype == 'float':
return coord.astype(float)
if dtype == 'str':
return coord.astype(str)
return coord
def get_phenotype(icd10_codes: Union[str, List[str]] = "I84",
samples: np.array = None,
max_samples: int = None,
balance_pheno: str = None,
random_state=42):
"""
if samples argument is provided from genetic file, then find common set of samples and output ordered phenotype
if `max_samples` is provided, then over-sample the data so that we have `max_samples/2` for both cases and controls
"""
icd10_codes = [icd10_codes
] if not isinstance(icd10_codes, list) else icd10_codes
pheno_df_list = [
icd10_pheno_matrix[icd10_primary_cols].isin([icd10_code
]).any(axis=1).astype(int)
for icd10_code in icd10_codes
]
pheno_df = pd.concat(pheno_df_list, axis=1)
pheno_df.columns = icd10_codes
if samples is not None:
geno_pheno_sample_index_mask = np.isin(samples.astype(int),
pheno_df.index)
pheno_geno_samples_common_set = samples[
geno_pheno_sample_index_mask].astype(int)
pheno_df_ordered = pheno_df.loc[list(pheno_geno_samples_common_set), :]
pheno_df_ordered = pheno_df_ordered.loc[
~pheno_df_ordered.index.duplicated(keep="first"), :]
sample_index = np.argwhere(geno_pheno_sample_index_mask).reshape(-1)
if max_samples is not None:
if balance_pheno is None:
raise ValueError(
"Need to specify `balance_pheno` param: phenotype to balance during subsampling"
)
pheno_df_ordered = upsample_pheno(pheno_df_ordered, balance_pheno,
max_samples, random_state)
sorter = np.argsort(samples.astype(int))
sample_index = sorter[np.searchsorted(samples.astype(int),
pheno_df_ordered.index,
sorter=sorter)]
assert np.allclose(
samples[sample_index].astype(int), pheno_df_ordered.index
), "sample mismatch between genotype and phenotype, something wrong with the `get_phenotype` function!"
pheno_df_ordered.index = pheno_df_ordered.index.astype(str)
return pheno_df_ordered
return pheno_df
def plot_mask(self, img: np.array, mask: np.array):
if len(img.shape) == 2:
img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
img = img.astype(np.uint8)
mask = mask.astype(np.uint8)
for i, c in enumerate(mask):
contours, _ = cv2.findContours(c, cv2.RETR_LIST,
cv2.CHAIN_APPROX_NONE)
color = self.colors[i] if self.colors else (0, 255, 0)
for i in range(0, len(contours)):
cv2.polylines(img, contours[i], True, color, 2)
return img
def update(self, x_input: array, d_input: array) -> None:
"""Perform the update pass.
Args:
x_input: ``[N, in_size]`` matrix. If ``in_trans`` is set, transposed.
d_input: ``[N, out_size]`` matrix. If ``out_trans`` is set, transposed.
"""
if self.is_cuda:
x_tensor = from_numpy(x_input.astype('float32')).cuda()
d_tensor = from_numpy(d_input.astype('float32')).cuda()
return self.tile.update(x_tensor, d_tensor, self.bias,
self.in_trans, self.out_trans)
return self.tile.update_numpy(x_input, d_input, self.bias,
self.in_trans, self.out_trans)
def _filter_sobel(image: np.array, axis: str, krnsize: int):
""" The Sobel kernel filtering """
assert (axis == 'x' or axis == 'y')
if axis == 'x':
return cv.Sobel(image.astype(np.float32),
cv.CV_32F,
1,
0,
ksize=krnsize)
elif axis == 'y':
return cv.Sobel(image.astype(np.float32),
cv.CV_32F,
0,
1,
ksize=krnsize)
def preprocess(self, data: np.array) -> np.array:
"""Pre-process the data by reshaping and normalizing, if necessary.
Args:
data: Array of data.
Returns:
(np.array): Pre-processed data.
"""
data = data.astype("float32")
if self.input_shape:
data = data.reshape(self.input_shape)
if self.normalize:
# Gathers the lower and upper bounds of normalization
low, high = self.normalize[0], self.normalize[1]
# Gathers the minimum and maximum values of the data
_min, _max = tf.math.reduce_min(data), tf.math.reduce_max(data)
# Normalizes the data between `low` and `high`
data = (high - low) * ((data - _min) / (_max - _min)) + low
return data
def query_ids_by_embedding(
self,
query_emb: np.array,
filters: Optional[dict] = None,
top_k: int = 10,
index: Optional[str] = None,
return_embedding: Optional[bool] = None,
) -> List[Document]:
"""
Find the document that is most similar to the provided `query_emb` by using a vector similarity metric.
:param query_emb: Embedding of the query (e.g. gathered from DPR)
:param filters: Optional filters to narrow down the search space.
Example: {"name": ["some", "more"], "category": ["only_one"]}
:param top_k: How many documents to return
:param index: (SQL) index name for storing the docs and metadata
:param return_embedding: To return document embedding
:return:
"""
if filters:
raise Exception(
"Query filters are not implemented for the FAISSDocumentStore."
)
if not self.faiss_index:
raise Exception(
"No index exists. Use 'update_embeddings()` to create an index."
)
query_emb = query_emb.astype(np.float32)
return self.faiss_index.search(query_emb, top_k)
def process_stats(stats_np: np.array, api_mapping: pd.DataFrame):
if stats_np.shape[0] < 1:
return blank_stats()
stats_results = pd.DataFrame(
stats_np.astype(np.float64),
columns=[
'NNS', 'WBT', 'distance_segment', 'azimuth_delta', 'sidenns_heel',
'sidenns_toe', 'distance_2d_mean', 'distance_2d_std',
'distance_2d_min', 'distance_2d_25percentile',
'distance_2d_50percentile', 'distance_2d_75percentile',
'distance_2d_max', 'distance_3d_mean', 'distance_3d_std',
'distance_3d_min', 'distance_3d_25percentile',
'distance_3d_50percentile', 'distance_3d_75percentile',
'distance_3d_max', 'distance_vertical_mean',
'distance_vertical_std', 'distance_vertical_min',
'distance_vertical_25percentile', 'distance_vertical_50percentile',
'distance_vertical_75percentile', 'distance_vertical_max',
'theta_mean', 'theta_std', 'theta_min', 'theta_25percentile',
'theta_50percentile', 'theta_75percentile', 'theta_max'
],
).assign(
WBT=lambda idf: idf[['WBT']].astype(np.int64).merge(
api_mapping, how='left', left_on='WBT', right_on='API_ID')['API'],
NNS=lambda idf: idf[['NNS']].astype(np.int64).merge(
api_mapping, how='left', left_on='NNS', right_on='API_ID')['API'],
sidenns_heel=lambda idf: idf['sidenns_heel'].pipe(side_np_to_str),
sidenns_toe=lambda idf: idf['sidenns_toe'].pipe(side_np_to_str),
)
return stats_results
def write_array(self,
numpy_array: NumpyArray,
name: str,
attrs: Dict[str, str] = None):
"""Write array with name and optional attrs to OMX file.
Args:
numpy_array:: Numpy array
name: name to use for the OMX key
attrs: additional attribute key value pairs to write to OMX file
"""
if self._mode not in ["a", "w"]:
raise Exception(f"{self._file_path}: open in read-only mode")
shape = numpy_array.shape
if len(shape) == 2:
chunkshape = (1, shape[0])
else:
chunkshape = None
if self._mask_max_value:
numpy_array[numpy_array > self._mask_max_value] = 0
numpy_array = numpy_array.astype(dtype="float64", copy=False)
self._omx_file.create_matrix(name,
obj=numpy_array,
chunkshape=chunkshape,
attrs=attrs)
def gms_preprocess(gms: np.array) -> np.array:
gms = gms.astype(float)
i1 = gms <= 1
i2 = gms > 1
gms[i1] = 1 + np.tanh(gms[i1])
gms[i2] = np.log2(gms[i2])
return gms
def __init__(self, n_input: int, n_output: int, W: nparray, b: nparray, activation: Elemwise = T.tanh):
"""
A layer of a neural network, computes s(Wx + b) where s is a nonlinearity and x is the input vector.
:parameters:
- rng: numpy random state
- n_in: input dimensionality
- n_out: output dimensionality
- W: np.array, shape=(n_in, n_out)
Optional weight matrix, if not given is initialised randomly.
- b: np.array, shape=(n_out,)
Optional bias vector, if not given is initialised randomly.
- activation : theano.tensor.elemwise.Elemwise
Activation function for layer output
"""
assert W.shape == (n_input, n_output), \
'W does not match the expected dimensionality (%d, %d) != %s' % (n_input, n_output, W.shape)
assert b.shape == (n_output,), 'b does not match the expected dimensionality (%d,) != %s' % (n_output, b.shape)
self.n_input = n_input
self.n_output = n_output
# All parameters should be shared variables.
# They're used in this class to compute the layer output,
# but are updated elsewhere when optimizing the network parameters.
# Note that we are explicitly requiring that W_init has the theano.config.floatX dtype
self.W = theano.shared(value=W.astype(theano.config.floatX),
# The name parameter is solely for printing purporses
name='W',
# Setting borrow=True allows Theano to use user memory for this object.
# It can make code slightly faster by avoiding a deep copy on construction.
# For more details, see
# http://deeplearning.net/software/theano/tutorial/aliasing.html
borrow=True)
# We can force our bias vector b to be a column vector using numpy's reshape method.
# When b is a column vector, we can pass a matrix-shaped input to the layer
# and get a matrix-shaped output, thanks to broadcasting (described below)
self.b = theano.shared(value=b.astype(theano.config.floatX),
name='b',
borrow=True)
self.activation = activation
# We'll compute the gradient of the cost of the network with respect to the parameters in this list.
self.params = [self.W, self.b]
