prompt
stringlengths 19
879k
| completion
stringlengths 3
53.8k
| api
stringlengths 8
59
|
|---|---|---|
from scipy.signal import convolve2d as conv2
import numpy as np
tf_loaded,pytorch_loaded = False,False
# try:
# import tensorflow as tf
# tf_loaded = True
# except:
# pass
try:
import torch
import torch.nn as nn
pytorch_loaded = True
except:
pass
import copy
from CEM.imresize_CEM import imresize,calc_strides
import collections
class CEMnet:
NFFT_add = 36
def __init__(self,conf,upscale_kernel=None):
self.conf = conf
self.ds_factor = np.array(conf.scale_factor,dtype=np.int32)
assert np.round(self.ds_factor)==self.ds_factor,'Currently only supporting integer scale factors'
assert upscale_kernel is None or isinstance(upscale_kernel,str) or isinstance(upscale_kernel,np.ndarray),'To support given kernels, change the Return_Invalid_Margin_Size_in_LR function and make sure everything else works'
# if isinstance(upscale_kernel, torch.Tensor):
# upscale_kernel = np.squeeze(upscale_kernel.data.cpu().numpy())
self.ds_kernel = Return_kernel(self.ds_factor,upscale_kernel=upscale_kernel)
self.ds_kernel_invalidity_half_size_LR = self.Return_Invalid_Margin_Size_in_LR('ds_kernel',self.conf.filter_pertubation_limit)
self.compute_inv_hTh()
self.invalidity_margins_LR = 2* self.ds_kernel_invalidity_half_size_LR + self.inv_hTh_invalidity_half_size
self.invalidity_margins_HR = self.ds_factor * self.invalidity_margins_LR
def Return_Invalid_Margin_Size_in_LR(self,filter,max_allowed_perturbation):
TEST_IM_SIZE = 100
assert filter in ['ds_kernel','inv_hTh']
if filter=='ds_kernel':
output_im = imresize(np.ones([self.ds_factor*TEST_IM_SIZE, self.ds_factor*TEST_IM_SIZE]),[1/self.ds_factor],use_zero_padding=True)
elif filter=='inv_hTh':
output_im = conv2(np.ones([TEST_IM_SIZE,TEST_IM_SIZE]), self.inv_hTh,mode='same')
output_im /= output_im[int(TEST_IM_SIZE/2),int(TEST_IM_SIZE/2)]
output_im[output_im<=0] = max_allowed_perturbation/2 # Negative output_im are hella invalid... (and would not be identified as such without this line since I'm taking their log).
invalidity_mask = np.exp(-np.abs(np.log(output_im)))<max_allowed_perturbation
# Finding invalid shoulder size, by searching for the index of the deepest invalid pixel, to accomodate cases of non-conitinous invalidity:
margin_sizes = [np.argwhere(invalidity_mask[:int(TEST_IM_SIZE/2),int(TEST_IM_SIZE/2)])[-1][0]+1,
np.argwhere(invalidity_mask[int(TEST_IM_SIZE / 2),:int(TEST_IM_SIZE / 2)])[-1][0]+1]
margin_sizes = np.max(margin_sizes)*np.ones([2]).astype(margin_sizes[0].dtype)
return np.max(margin_sizes)
def Pad_LR_Batch(self,batch,num_recursion=1):
for i in range(num_recursion):
batch = 1.0*np.pad(batch, pad_width=((0, 0), (self.invalidity_margins_LR, self.invalidity_margins_LR),(self.invalidity_margins_LR, self.invalidity_margins_LR), (0, 0)), mode='edge')
return batch
def Unpad_HR_Batch(self,batch,num_recursion=1):
margins_2_remove = (self.ds_factor**(num_recursion))*self.invalidity_margins_LR*num_recursion
return batch[:,margins_2_remove:-margins_2_remove,margins_2_remove:-margins_2_remove, :]
def DT_Satisfying_Upscale(self,LR_image):
margin_size = 2*self.inv_hTh_invalidity_half_size+self.ds_kernel_invalidity_half_size_LR
LR_image = Pad_Image(LR_image,margin_size)
HR_image = imresize(np.stack([conv2(LR_image[:,:,channel_num],self.inv_hTh,mode='same') for channel_num in range(LR_image.shape[-1])],-1),scale_factor=[self.ds_factor])
return Unpad_Image(HR_image,self.ds_factor*margin_size)
def WrapArchitecture_PyTorch(self,generated_image=None,training_patch_size=None,only_padders=False):
assert pytorch_loaded,'Failed to load PyTorch - Necessary for this function of CEM'
invalidity_margins_4_test_LR = self.invalidity_margins_LR
invalidity_margins_4_test_HR = self.ds_factor*invalidity_margins_4_test_LR
self.LR_padder = torch.nn.ReplicationPad2d((invalidity_margins_4_test_LR, invalidity_margins_4_test_LR,invalidity_margins_4_test_LR, invalidity_margins_4_test_LR))
self.HR_padder = torch.nn.ReplicationPad2d((invalidity_margins_4_test_HR, invalidity_margins_4_test_HR,invalidity_margins_4_test_HR, invalidity_margins_4_test_HR))
self.HR_unpadder = lambda x: x[:, :, invalidity_margins_4_test_HR:-invalidity_margins_4_test_HR,invalidity_margins_4_test_HR:-invalidity_margins_4_test_HR]
self.LR_unpadder = lambda x:x[:,:,invalidity_margins_4_test_LR:-invalidity_margins_4_test_LR,invalidity_margins_4_test_LR:-invalidity_margins_4_test_LR]#Debugging tool
self.loss_mask = None
if training_patch_size is not None:
self.loss_mask = np.zeros([1,1,training_patch_size,training_patch_size])
invalidity_margins = self.invalidity_margins_HR
self.loss_mask[:,:,invalidity_margins:-invalidity_margins,invalidity_margins:-invalidity_margins] = 1
assert np.mean(self.loss_mask) > 0, 'Loss mask completely nullifies image.'
print('Using only only %.3f of patch area for learning. The rest is considered to have boundary effects' % (np.mean(self.loss_mask)))
self.loss_mask = torch.from_numpy(self.loss_mask).type(torch.cuda.FloatTensor)
if only_padders:
return
else:
returnable = CEM_PyTorch(self,generated_image)
self.OP_names = [m[0] for m in returnable.named_modules() if 'Filter_OP' in m[0]]
return returnable
def Mask_Invalid_Regions_PyTorch(self,im1,im2):
assert self.loss_mask is not None,'Mask not defined, probably didn''t pass patch size'
return self.loss_mask*im1,self.loss_mask*im2
def WrapArchitecture(self,model,unpadded_input_t,generated_image_t=None):
assert tf_loaded,'Failed to load TensorFlow - Necessary for this function of CEM'
assert not self.conf.sigmoid_range_limit,'Unsupported yet'
PAD_GENRATED_TOO = True
self.model = model
with model.as_default():
self.compute_conv_with_inv_hTh_OP()
self.create_scaling_OPs()
# Padding image for inference time or leaving as-is for training (taking x2 the calculated margins for extra-safety):
LR_padding_size = 2*self.invalidity_margins_LR
HR_padding_size = 2*self.invalidity_margins_HR
self.pre_pad_input = tf.placeholder(dtype=tf.bool,name='pre_pad_input')
LR_padding_OP = Create_Tensor_Pad_OP(LR_padding_size)
HR_padding_OP = Create_Tensor_Pad_OP(HR_padding_size)
def Return_Padded_Input():
return LR_padding_OP(unpadded_input_t)
def Return_Unpadded_Input():
return unpadded_input_t
self.LR_input_t = tf.cond(self.pre_pad_input,true_fn=Return_Padded_Input,false_fn=Return_Unpadded_Input)
self.ortho_2_NS_HR_component = self.Upscale_OP(self.Conv_LR_with_Inv_hTh_OP((self.LR_input_t)))
if generated_image_t is None:
print('Creating an HR image generator network...')
self.create_im_generator()
else:
print('Using the given generated image as HR image...')
self.generated_im = generated_image_t
if PAD_GENRATED_TOO:
def Return_Padded_Generated_Im():
return HR_padding_OP(self.generated_im)
def Return_Unpadded_Generated_Im():
return self.generated_im
self.generated_im = tf.cond(self.pre_pad_input,true_fn=Return_Padded_Generated_Im,false_fn=Return_Unpadded_Generated_Im)
self.ortho_2_NS_generated_component = self.Upscale_OP(self.Conv_LR_with_Inv_hTh_OP(self.DownscaleOP(self.generated_im)))
self.NS_HR_component = self.generated_im-self.ortho_2_NS_generated_component
if PAD_GENRATED_TOO:
output = tf.add(self.ortho_2_NS_HR_component,self.NS_HR_component,name='CEM_add_subspaces')
else:
output = self.ortho_2_NS_HR_component
# Remove image padding for inference time or leaving as-is for training:
def Return_Output():
return output
def Return_Cropped_Output():
margins_2_crop = tf.cast((tf.shape(output)-self.ds_factor*tf.shape(unpadded_input_t))/2,dtype=tf.int32)
return tf.slice(output,begin=tf.stack([0,margins_2_crop[1],margins_2_crop[2],0]),
size=tf.stack([-1,self.ds_factor*tf.shape(unpadded_input_t)[1],self.ds_factor*tf.shape(unpadded_input_t)[2],-1]))
self.output_t = tf.cond(self.pre_pad_input,true_fn=Return_Cropped_Output,false_fn=Return_Output)
if PAD_GENRATED_TOO:
return self.output_t
else:
return tf.add(self.output_t,self.NS_HR_component,name='CEM_add_subspaces')
def Enforce_DT_on_Image_Pair(self,LR_source,HR_input):
same_scale_dimensions = [LR_source.shape[i]==HR_input.shape[i] for i in range(LR_source.ndim)]
LR_scale_dimensions = [self.ds_factor*LR_source.shape[i]==HR_input.shape[i] for i in range(LR_source.ndim)]
assert np.all(np.logical_or(same_scale_dimensions,LR_scale_dimensions))
LR_source = self.DT_Satisfying_Upscale(LR_source) if np.any(LR_scale_dimensions) else self.Project_2_ortho_2_NS(LR_source)
HR_projected_2_h_subspace = self.Project_2_ortho_2_NS(HR_input)
return HR_input-HR_projected_2_h_subspace+LR_source
def Project_2_ortho_2_NS(self,HR_input):
downscaled_input = imresize(HR_input,scale_factor=[1/self.ds_factor])
if downscaled_input.ndim<HR_input.ndim:#In case input was of size self.ds_factor in at least one of its axes:
downscaled_input = np.reshape(downscaled_input,list(HR_input.shape[:2]//self.ds_factor)+([HR_input.shape[2]] if HR_input.ndim>2 else []))
return self.DT_Satisfying_Upscale(downscaled_input)
def Supplement_Pseudo_CEM(self,input_t):
return self.Learnable_Upscale_OP(self.Conv_LR_with_Learnable_OP(self.Learnable_DownscaleOP(input_t)))
def create_im_generator(self):
with self.model.as_default():
with tf.variable_scope('CEM_generator'):
upscaling_filter_shape = self.conf.filter_shape[0][:-2]+[3,self.ds_factor**2]
self.conf.filter_shape[1] = copy.deepcopy(self.conf.filter_shape[1])
self.conf.filter_shape[1][2] = 3
self.upscaling_filter = tf.get_variable(shape=upscaling_filter_shape,name='upscaling_filter',
initializer=tf.random_normal_initializer(stddev=np.sqrt(self.conf.init_variance / np.prod(upscaling_filter_shape[0:3]))))
self.G_filters_t = [tf.get_variable(shape=self.conf.filter_shape[ind+1], name='filter_%d' % ind,
initializer=tf.random_normal_initializer(stddev=np.sqrt(self.conf.init_variance / np.prod(self.conf.filter_shape[ind+1][0:3]))))
for ind in range(self.conf.depth-1)]
input_shape = tf.shape(self.LR_input_t)
self.G_layers_t = [tf.reshape(tf.transpose(tf.reshape(tf.nn.depthwise_conv2d(self.LR_input_t,self.upscaling_filter,[1,1,1,1],padding='SAME'),
shape=tf.stack([input_shape[0],input_shape[1],input_shape[2],input_shape[3],self.ds_factor,self.ds_factor])),perm=[0,1,4,2,5,3]),
shape=tf.stack([input_shape[0],self.ds_factor*input_shape[1],self.ds_factor*input_shape[2],input_shape[3]]))]
self.G_layers_t = [tf.nn.leaky_relu(self.G_layers_t[0],name='layer_0')] + [None] * (self.conf.depth-1)
for l in range(self.conf.depth - 2):
self.G_layers_t[l + 1] = tf.nn.leaky_relu(tf.nn.conv2d(self.G_layers_t[l], self.G_filters_t[l],[1, 1, 1, 1], "SAME", name='layer_%d' % (l + 1)))
self.G_layers_t[l+2] = tf.nn.conv2d(self.G_layers_t[l+1], self.G_filters_t[l+1],[1, 1, 1, 1], "SAME", name='layer_%d' % (l + 2))
self.generated_im = self.G_layers_t[-1]
def compute_inv_hTh(self):
hTh = conv2(self.ds_kernel,np.rot90(self.ds_kernel,2))*self.ds_factor**2
hTh = Aliased_Down_Sampling(hTh,self.ds_factor)
pad_pre = pad_post = np.array(self.NFFT_add/2,dtype=np.int32)
hTh_fft = np.fft.fft2(np.pad(hTh,((pad_pre,pad_post),(pad_pre,pad_post)),mode='constant',constant_values=0))
# When ds_kernel is wide, some frequencies get completely wiped out, which causes instability when hTh is inverted. I therfore bound this filter's magnitude from below in the Fourier domain:
magnitude_increasing_map = np.maximum(1,self.conf.lower_magnitude_bound/np.abs(hTh_fft))
hTh_fft = hTh_fft*magnitude_increasing_map
# Now inverting the filter:
self.inv_hTh = np.real(np.fft.ifft2(1/hTh_fft))
# Making sure the filter's maximal value sits in its middle:
max_row = np.argmax(self.inv_hTh)//self.inv_hTh.shape[0]
max_col = np.mod(np.argmax(self.inv_hTh),self.inv_hTh.shape[0])
if not np.all(np.equal(np.ceil( | np.array(self.inv_hTh.shape) | numpy.array |
"""Generates finely spaced grid of SNII, AGB, and SNIa yields.
Generates a finely spaced grid of SN II isotopic yields from Woosley & Weaver
(1995), AGB isotopic yields from Renzini & Voli (1981), and SNIa yields from
Thielemann, Nomoto, & Yokoi (1986).
Woosley & Weaver (1995): M = 11--40 Msun; Z = 0--solar
Renzini & Voli (1981): M = 1--8 Msun; Z = 0--solar
Thielemann et al. (1986): W7 model from Nomoto et al. (1984)
Timmes already converted Ni56 to Fe56 in the maltov1.orig file (WW95 doesn't
account for its decay).
"""
from __future__ import print_function, division, absolute_import
import os
from os.path import join
import sys
import copy
import numpy as np
from scipy import interpolate
import pandas as pd
# ---- Set Paths -----
path_calc_yields = join(os.path.abspath(os.path.dirname(__file__)), '')
path_flexce = join('/'.join(path_calc_yields.split('/')[:-2]), '')
path_fileio = join(path_flexce, 'fileio')
path_data = join(path_flexce, 'data')
path_yields = join(path_data, 'yields')
path_yldgen = join(path_yields, 'general')
path_ww95 = join(path_yields, 'ww95')
path_ww95_orig = join(path_ww95, 'orig')
path_ww95_half_fe = join(path_ww95, 'half_fe')
# path_ww95_half_fe_only = join(path_ww95, 'half_fe_only')
# path_rv81 = join(path_yields, 'renzini81'
# path_tny86 = join(path_yields, 'thielemann86'
sys.path.append(path_fileio)
# -------------------
from pickle_io import pickle_read
from pickle_io import pickle_write
if not os.path.isdir(path_ww95_orig):
os.mkdir(path_ww95_orig)
if not os.path.isdir(path_ww95_half_fe):
os.mkdir(path_ww95_half_fe)
# ---- WW95 Yields -----
z = open(join(path_ww95, 'maltov1.orig'), 'r')
sym = [] # symbol names
sym_metallicity = [] # [symbol--metallicity pairs]
bbmf = [] # big bang mass fraction
sneIa_orig = []
# ww95_orig[80 symbols + 5 metallicities/sym = 400][[25 masses], [25 yields]]
ww95_orig = []
tmp_Ia = 0
tmp = 0
for row in z:
if 'symbol name' in row:
sym_tmp = row.split()[0]
sym.append(sym_tmp)
if 'big bang mass fraction' in row:
bbmf.append(float(row.split()[0]))
if 'w7 tny86' in row:
yields_Ia = []
tmp_Ia = 6
if tmp_Ia > 0:
yields_Ia.append(float(row.split()[0]))
tmp_Ia -= 1
if tmp_Ia == 0:
sneIa_orig.append(np.array(yields_Ia))
if '* metallicity' in row:
metal_tmp = float(row.split()[0])
sym_metallicity.append([sym_tmp, metal_tmp])
if 'rv81 stellar mass & yield' in row:
mass = []
yields = []
tmp = 25
if tmp > 0:
mass.append(float(row.split()[0]))
yields.append(float(row.split()[1]))
tmp -= 1
if tmp == 0:
ww95_orig.append([np.array(mass), np.array(yields)])
z.close()
sym = np.array(sym)
sym_mass = np.array([int(sym[i][-1]) if i < 7 else int(sym[i][-2:])
for i in range(len(sym) - 1)])
sym_metallicity = np.array(sym_metallicity)
bbmf = np.array(bbmf)[:-1]
sneIa_orig = np.array(sneIa_orig)
tnyIa = sneIa_orig[:, 0]
ww95_orig = np.array(ww95_orig)
# all symbols have 25 masses and yields and 5 metallicity values:
ww95_mass = ww95_orig[0][0]
ww95_mass2 = np.concatenate([ww95_mass for i in range(5)])
ww95_metal = np.array([0.00e+00, 1.90e-06, 1.90e-04, 1.90e-03, 1.90e-02])
ww95_metal2 = np.concatenate([np.ones(25) * ww95_metal[i] for i in range(5)])
n_sym = len(sym)
n_iso = len(sym) - 1
n_metal = len(sym) - 5
n_yield = len(ww95_orig)
# ----------------------
# ---- CL04 Data ----
species_in = pd.read_csv(join(path_yldgen, 'species.txt'),
delim_whitespace=True, skiprows=1, usecols=[1],
names=['name'])
species = np.array(species_in['name'])
n_species = len(species)
# match isotopes from WW95 yields to CL04 yields
sym2 = np.array([sym[i].title() for i in range(len(sym))])
ind_sp = []
for i in range(n_sym):
if sym2[i] in species:
tmp = np.where(sym2[i] == species)[0][0]
ind_sp.append(tmp)
else:
pass
# print 'sym[%i]' % (i), '(%s)' % (sym[i]), 'not in species array'
ind_sp = np.array(ind_sp)
# solar abundance of metals---needed to subtract the initial metal abundances
# of the stellar models (also assume Y = 0.285)---in relative amounts (not
# Msun), that is, sum(solar_ab) = 1.
solar_isotopes = pd.read_csv(join(path_yldgen, 'Solar_isotopes.txt'),
delim_whitespace=True, skiprows=1,
usecols=[0, 1], names=['name', 'ab'])
solar_iso = np.array(solar_isotopes['name'])
solar_ab = np.array(solar_isotopes['ab'])
# indices within "species" array of the elements for which CL04 give a solar
# abundance (Note: WW95 also used the Anders & Grevesse 1989 solar abundance)
ind_iso = []
for i in range(len(solar_iso)):
ind_iso.append(np.where(solar_iso[i] == species)[0][0])
ind_iso = np.array(ind_iso)
# -------------------
# --- Calculate Net Yields ---
# WW95 absolute yields (125 mass/metallicity pairs, 293 isotopes)
ww95_orig2 = ww95_orig.reshape(80, 5, 2, 25)
ww95_orig3 = ww95_orig2[:, :, 1]
ww95_orig4 = ww95_orig3.reshape(80, 125).T
ww95_abs = np.zeros((125, n_species))
for i in range(125):
for j in range(79):
ww95_abs[i, ind_sp[j]] = ww95_orig4[i, j]
# WW95 mass ejected
ww95_mej = np.sum(ww95_abs, axis=1)
# WW95 remnant mass
ww95_rem = ww95_mass2 - ww95_mej
# The remnant masses reported by WW95 but the sum(abs yields) + remnant mass !=
# mass of star, so for accouting purposes it will be best to calculate remnant
# mass = mass of star - sum(abs yields).
# WW95 reported remnant masses:
# ww95_rem = ww95_orig4[:, -1]
# WW95 initial composition
ww95_init_comp = np.zeros(ww95_abs.shape)
for i in range(5):
indt = np.arange(25*i, 25*i+25)
if i == 0:
ww95_init_comp[indt, 0] = (1. - 0.23) * ww95_mass # H
ww95_init_comp[indt, 4] = 0.23 * ww95_mass # He
else:
ztmp = ww95_metal2[indt][0]
ww95_init_comp[indt, 0] = (1. - 0.285 - ztmp) * ww95_mass # H
ww95_init_comp[indt, 4] = 0.285 * ww95_mass # He
for j in range(len(ind_iso)):
ww95_init_comp[indt, ind_iso[j]] = (ztmp * solar_ab[j] *
ww95_mass) # C->Mo
# WW95 net yields = absolute yields - initial composition of stellar model
ww95_net = ww95_abs - ww95_init_comp
# WW95 SNII (11--40 Msun) net yields, mass ejected, and remnant mass for Z > 0
ww95_sn_net = np.zeros((48, n_species))
ww95_sn_mej = np.zeros(48)
ww95_sn_rem = np.zeros(48)
for i in range(1, 5):
ind1 = np.arange(25*i+13, 25*i+25)
ind2 = np.arange(12*(i-1), 12*(i-1)+12)
ww95_sn_net[ind2] = ww95_net[ind1]
ww95_sn_mej[ind2] = ww95_mej[ind1]
ww95_sn_rem[ind2] = ww95_rem[ind1]
# Renzini & Voli (1981) AGB net yields (1--8 Msun) for Z > 0
rv81_net = np.zeros((44, n_species))
rv81_mej = np.zeros(44)
rv81_rem = np.zeros(44)
for i in range(1, 5):
ind1 = np.arange(25*i, 25*i+11)
ind2 = np.arange(11*(i-1), 11*(i-1)+11)
rv81_net[ind2] = ww95_net[ind1]
rv81_mej[ind2] = ww95_mej[ind1]
rv81_rem[ind2] = ww95_rem[ind1]
# ---------------------------
# ----
# chemical evolution model mass bins
# IMF
alpha = 2.35
Gamma = 1. - alpha
alpha2 = 2. - alpha
m_min = 0.1
m_max = 100.
a = alpha2 / (m_max**alpha2 - m_min**alpha2)
m_cutoff = 8.
# Bins of Stars
'''Bin lower bounds (bins, bins_low, bins_high). Bin width (dbin_low,
dbin_high). Number of bins (n_bins, n_bins_low, n_bins_high). Average mass
per bin (m_ave_high, m_ave_low, m_ave), fraction of total mass (f_mtot).
Fraction of total mass in a stellar generation going into each mass bin (f_m,
f_m_low, f_m_high). '''
dbin_low = 0.1
bins_low = np.arange(m_min, m_cutoff, dbin_low)
n_bins_low = len(bins_low)
m_ave_low = (Gamma / alpha2) * \
((bins_low + dbin_low)**alpha2 - bins_low**alpha2) / \
((bins_low + dbin_low)**Gamma - bins_low**Gamma)
dbin_high = 1.
bins_high = np.arange(m_cutoff, m_max, dbin_high)
n_bins_high = len(bins_high)
m_ave_high = (Gamma / alpha2) * \
((bins_high + dbin_high)**alpha2 - bins_high**alpha2) / \
((bins_high + dbin_high)**Gamma - bins_high**Gamma)
m_ave = np.append(m_ave_low, m_ave_high)
n_bins = n_bins_low + n_bins_high
# ----
# ---- Interpolated Yields -----
# ---- Minor grid points (mass bins spaced in ~1 Msun, but at the original 4
# ---- non-zero metallicity values [Z = 1.9e-6, 1.9e-4, 1.9e-3, 1.9e-2])
# Interpolate across mass to generate yields at each mass bin of m_ave_high for
# 4 metallicity values: Z = 1.9e-6, 1.9e-4, 1.9e-3, & 1.9e-2 (almost solar)
# Linearly extrapolate the mass ejected and the remnant mass at fixed
# metallicity
# Do NOT extrapolate (linearly or otherwise) net yields.
ww95_sn_m = np.array([11.065, 12.065, 13.071, 15.081, 18.098, 19., 20.109,
22.119, 25.136, 30.163, 35.19, 40.217])
rv81_m = np.array([1., 1.5, 1.75, 2., 2.5, 3., 4., 5., 6., 7., 8.])
ind_ww95_sn_net = [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
[12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23],
[24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35],
[36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47]]
ind_rv81_net = [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
[11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21],
[22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32],
[33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43]]
# WW95 yields
ww95_interp_mass = np.zeros((4, n_bins_high, n_species))
for i in range(4):
m_tmp = np.zeros((n_bins_high, n_species))
for k in range(n_species):
itmp = interpolate.InterpolatedUnivariateSpline(
ww95_sn_m, ww95_sn_net[ind_ww95_sn_net[i], k], k=1)
m_tmp[:, k] = itmp(m_ave_high)
m_tmp[np.where(m_ave_high < ww95_sn_m[0]), k] = itmp(ww95_sn_m[0])
m_tmp[np.where(m_ave_high > ww95_sn_m[-1]), k] = itmp(ww95_sn_m[-1])
ww95_interp_mass[i] = m_tmp
# WW95 mass ejected
ww95_interp_mej = np.zeros((4, n_bins_high))
for i in range(4):
itmp = interpolate.InterpolatedUnivariateSpline(
ww95_sn_m, ww95_sn_mej[ind_ww95_sn_net[i]], k=1)
ww95_interp_mej[i] = itmp(m_ave_high)
# WW95 remnant mass
ww95_interp_rem = np.zeros((4, n_bins_high))
for i in range(4):
ww95_interp_rem[i] = m_ave_high - ww95_interp_mej[i]
# rv81 yields
rv81_interp_mass = np.zeros((4, n_bins_low, n_species))
for i in range(4):
m_tmp = np.zeros((n_bins_low, n_species))
for k in range(n_species):
itmp = interpolate.InterpolatedUnivariateSpline(
rv81_m, rv81_net[ind_rv81_net[i], k], k=1)
m_tmp[:, k] = itmp(m_ave_low)
m_tmp[np.where(m_ave_low < rv81_m[0]), k] = itmp(rv81_m[0])
rv81_interp_mass[i] = m_tmp
# RV81 mass ejected
rv81_interp_mej = np.zeros((4, n_bins_low))
for i in range(4):
itmp = interpolate.InterpolatedUnivariateSpline(
rv81_m, rv81_mej[ind_rv81_net[i]], k=1)
rv81_interp_mej[i] = itmp(m_ave_low)
rv81_interp_mej[i][np.where(rv81_interp_mej[i] < 0.)] = 0.
# RV81 remnant mass
rv81_interp_rem = np.zeros((4, n_bins_low))
for i in range(4):
rv81_interp_rem[i] = m_ave_low - rv81_interp_mej[i]
# ---- Interpolate across metallicity to generate yields at each mass bin of
# ---- m_ave_high for N = n_metal_bin metallicity values
# Interpolate WW95 yields onto Limongi & Chieffi (2006) metallicity grid, which
# is evenly sampled in log(metallicity) between each metallicity grid point (
# 1e-6, 1e-4, 1e-3, 6e-3, 2e-2) for a total of 1001 values
z_final = pickle_read(join(path_yldgen, 'interp_metallicity.pck'))
n_metal_bin = len(z_final)
# interpolated WW95 SNII yields
ww95_final = np.zeros((n_metal_bin, n_bins_high, n_species))
# at each mass, interpolate each element for each metallicity
for i in range(n_bins_high):
for j in range(n_species):
itmp = interpolate.InterpolatedUnivariateSpline(
ww95_metal[1:], ww95_interp_mass[:, i, j], k=1)
ww95_final[:, i, j] = itmp(z_final)
# interpolated WW95 SNII mass ejected
ww95_final_mej = np.zeros((n_metal_bin, n_bins_high))
for i in range(n_bins_high):
itmp = interpolate.InterpolatedUnivariateSpline(ww95_metal[1:],
ww95_interp_mej[:, i], k=1)
ww95_final_mej[:, i] = itmp(z_final)
# interpolated WW95 SNII remnant mass
ww95_final_rem = np.zeros((n_metal_bin, n_bins_high))
for i in range(n_metal_bin):
ww95_final_rem[i] = m_ave_high - ww95_final_mej[i]
# interpolated RV81 AGB yields
rv81_final = np.zeros((n_metal_bin, n_bins_low, n_species))
# at each mass, interpolate each element for each metallicity
for i in range(n_bins_low):
for j in range(n_species):
itmp = interpolate.InterpolatedUnivariateSpline(
ww95_metal[1:], rv81_interp_mass[:, i, j], k=1)
rv81_final[:, i, j] = itmp(z_final)
# interpolated RV81 AGB mass ejected
rv81_final_mej = np.zeros((n_metal_bin, n_bins_low))
for i in range(n_bins_low):
itmp = interpolate.InterpolatedUnivariateSpline(ww95_metal[1:],
rv81_interp_mej[:, i], k=1)
rv81_final_mej[:, i] = itmp(z_final)
# interpolated RV81 SNII remnant mass
rv81_final_rem = np.zeros((n_metal_bin, n_bins_low))
for i in range(n_metal_bin):
rv81_final_rem[i] = m_ave_low - rv81_final_mej[i]
# ------------------------------------
# -- WW95 yields with 1/2 Fe and Fe-peak element
# -- (Cr, Mn, Fe, Co, Ni, Cu, Zn) yields
ww95_final_half_fe = copy.deepcopy(ww95_final)
ww95_final_half_fe[:, :, 119:185] = ww95_final_half_fe[:, :, 119:185] / 2.
ww95_final_mej_half_fe = (ww95_final_mej -
np.sum(ww95_final_half_fe[:, :, 119:185], axis=2))
ww95_final_rem_half_fe = (ww95_final_rem +
| np.sum(ww95_final_half_fe[:, :, 119:185], axis=2) | numpy.sum |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import division, print_function
__all__ = []
import fitsio
import numpy as np
import matplotlib.pyplot as pl
from kpsf._kpsf import (compute_model, run_photometry_all,
N_INT_TIME, N_PSF_COMP)
# data = fitsio.read("data/ktwo202065500-c00_lpd-targ.fits.gz")
data = fitsio.read("data/kplr060021426-2014044044430_lpd-targ.fits")
time = data["TIME"]
flux = np.array(data["RAW_CNTS"], dtype=np.float64)
ferr = np.sqrt(flux)
# flux = data["FLUX"]
# ferr = data["FLUX_ERR"]
x0, y0 = np.mean([np.unravel_index(np.argmax(f), f.shape) for f in flux],
axis=0)
x0, y0 = map(int, map(np.round, [x0, y0]))
print(x0, y0)
d = 5
flux = flux[:, x0-d:x0+d+1, y0-d:y0+d+1]
ferr = ferr[:, x0-d:x0+d+1, y0-d:y0+d+1]
# mu = np.median(flux)
# print(float(mu))
# flux = flux / mu
# ferr = ferr / mu
xpix, ypix = np.meshgrid(range(flux.shape[1]), range(flux.shape[2]),
indexing="ij")
xpix = np.ascontiguousarray(xpix.flatten(), dtype=np.float64)
ypix = np.ascontiguousarray(ypix.flatten(), dtype=np.float64)
shape = flux[0].shape
flux = flux.reshape((len(flux), -1))
ferr = ferr.reshape((len(ferr), -1))
m = (np.sum(flux, axis=1) > 0.0)
# m = (np.sum(flux, axis=1) > 0.0) * (np.arange(len(flux)) % 3 == 0)
# m = (np.sum(flux, axis=1) > 0.0) * (np.arange(len(flux)) < 100)
time = np.ascontiguousarray(time[m], dtype=np.float64)
flux = np.ascontiguousarray(flux[m], dtype=np.float64)
ferr = np.ascontiguousarray(ferr[m], dtype=np.float64)
max_fracs = np.array([1.0] * (N_PSF_COMP - 1))
def fit_one(flux, ferr, bg, model, coords, coeffs):
f2 = (flux - np.median(flux)) ** 2
x0 = np.sum(f2 * xpix) / np.sum(f2)
y0 = np.sum(f2 * ypix) / np.sum(f2)
# i = np.argmax(flux)
# x0, y0 = xpix[i], ypix[i]
# Initialize the parameters.
coords[:] = np.array([x0, y0] * N_INT_TIME)
coords[:] += 1e-8 * np.random.randn(len(coords))
coeffs[:] = ([1.0, 1.0, 0.0]
+ [v for j in range(N_PSF_COMP-1)
for v in [-100.0, 0.0, 0.0, 5.0+j, 5.0+j, 0.0]])
# Do the initial least squares fit.
m = compute_model(max_fracs, xpix, ypix, 1.0, coords, coeffs,
np.ones((len(xpix),), dtype=np.float64), 0.0)
A = np.vander(m, 2)
w = np.linalg.solve(np.dot(A.T, A), np.dot(A.T, flux))
model[0] = w[0]
bg[0] = w[1]
bg = np.zeros(len(flux), dtype=np.float64)
model = np.zeros(len(flux), dtype=np.float64)
coords = np.zeros((len(flux), 2 * N_INT_TIME), dtype=np.float64)
coeffs = np.zeros((len(flux), 6*N_PSF_COMP - 3), dtype=np.float64)
for i in range(len(flux)):
if not np.any( | np.isfinite(flux[i]) | numpy.isfinite |
import numpy as np
import pandas as pd
from sklearn import preprocessing
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, auc, roc_curve
from collections import defaultdict
class AdaBoost:
def __init__(self, col_names):
self.data, self.labels = AdaBoost.get_data(col_names)
self.data = AdaBoost.normalize(self.data.astype(np.float))
@staticmethod
def get_data(names):
data_frame = pd.read_csv('./data/spambase', sep=',')
data_frame.columns = names
labels = data_frame['spam_label'].values
# replace 0 labels with -1
labels[labels == 0] = -1
data_frame = data_frame.drop('spam_label', axis=1)
return data_frame, labels
@staticmethod
def normalize(dataset):
return preprocessing.minmax_scale(dataset, feature_range=(0, 1))
def fit(self, num_weak_learners=100):
train_data, test_data, train_label, test_label = train_test_split(self.data, self.labels, test_size=0.25)
# train for the training data
models, summary, features_dict = AdaBoost.train(train_data, train_label, test_data, test_label, num_weak_learners)
# get average margins of features
margins = AdaBoost.get_margins(models, features_dict, train_data.shape[1], test_data, test_label)
return margins
@staticmethod
def get_margins(models, feature_dict, num_features, test_data, test_label):
margins = {}
denom = 0
for model in models:
model_preds = WeakLearner.one_model_predict(model, test_data)
denom += np.sum(test_label * model.alpha * model_preds)
for f in range(num_features):
num = 0
# for each occurrence of that feature
for occ in feature_dict[f]:
model_occ_preds = WeakLearner.one_model_predict(models[occ], test_data)
num += np.sum(test_label * models[occ].alpha * model_occ_preds)
margins[f] = num / denom
return margins
@staticmethod
def train(train_data, train_label, test_data, test_label, num_weak_learners):
models = []
summary = np.empty(shape=(num_weak_learners, 4))
# initialize weights to 1/num_of_data_points (uniform distribution)
wts = np.full(train_data.shape[0], (1 / train_data.shape[0]))
# get all unique thresholds in sorted order
thresholds = WeakLearner.get_optimal_thresholds(train_data)
# pick midpoints from the thresholds
thresholds = WeakLearner.get_midpoints(thresholds)
# keep sum of features
feature_dict = defaultdict(list)
for ep in range(num_weak_learners):
# get predictor using different decision stump selection techniques
model = WeakLearner.get_tree_predictor(train_data, thresholds, train_label, wts)
# model prediction error
error = model.error
# calculate alpha for this model
model.alpha = 0.5 * np.log((1 - error) / (error + 1e-10))
preds = np.ones(np.shape(train_label))
preds[train_data[:, model.feature] <= model.threshold] = -1
# update wts to assign more importance to incorrect data points
wts *= np.exp(-model.alpha * train_label * preds)
wts /= np.sum(wts)
feature_dict[model.feature].append(ep)
models.append(model)
train_error, _ = AdaBoost.get_error(models, train_data, train_label)
test_error, auc_score = AdaBoost.get_error(models, test_data, test_label)
# add to summary all the values needed for plotting
summary[ep] = [model.error, train_error, test_error, auc_score]
print('Round: {} | Feature: {} | Threshold: {} | Round_error: {} | Train_error: {} | '
'Test_error: {} | AUC: {}'.format(ep+1, model.feature, model.threshold, model.error, train_error,
test_error, auc_score), file=f)
return models, summary, feature_dict
@staticmethod
def get_error(models, data, label):
preds = WeakLearner.get_prediction(models, data)
acc = accuracy_score(label, preds)
fpr, tpr, thresholds = roc_curve(label, preds)
auc_score = auc(fpr, tpr)
return 1 - acc, auc_score
class Node:
def __init__(self, feature, threshold):
self.feature = feature
self.threshold = threshold
self.alpha = None
self.error = None
self.max_diff = None
class WeakLearner:
@staticmethod
def get_optimal_thresholds(data):
thresholds = []
for i in range(data.shape[1]):
uniques = np.unique(data[:, i])
thresholds.append(uniques)
return np.array(thresholds)
@staticmethod
def get_midpoints(data):
thresholds = []
for i in range(len(data)):
thres = data[i]
thresholds.append((thres[1:] + thres[:-1]) / 2)
return np.array(thresholds)
@staticmethod
def get_tree_predictor(dataset, thresholds, labels, wts):
max_diff = -float('inf')
# check each threshold, feature pair to find the best one
for feature in range(dataset.shape[1]):
for threshold in thresholds[feature]:
# build the weak learner
tree = Node(feature, threshold)
# find error for this weak learner
error = WeakLearner.predict(tree, dataset, labels, wts)
diff = np.abs(0.5 - error)
if diff > max_diff:
max_diff = diff
tree.error = error
tree.max_diff = max_diff
best_tree = tree
return best_tree
@staticmethod
def predict(model, test_data, labels, wts):
feature = model.feature
threshold = model.threshold
# initialize with all 1s for predictions
prediction = np.ones(np.shape(labels))
# change all predictions less than threshold to -1
prediction[test_data[:, feature] <= threshold] = -1
return | np.sum(wts[prediction != labels]) | numpy.sum |
# -*- coding: utf-8 -*-
# -*- coding: utf-8 -*-
"""
Elman Network with Chaotic Inspiration
"""
from pybrain.structure import LinearLayer, SigmoidLayer, LSTMLayer
from pybrain.structure import RecurrentNetwork
from pybrain.structure import FullConnection, IdentityConnection
from pybrain.datasets.sequential import SequentialDataSet
from pybrain.supervised.trainers import BackpropTrainer
from pybrain.tools.shortcuts import buildNetwork
from scipy import dot
from scipy.integrate import odeint
import operator
import midi
import numpy as np
import time
import random
ShortestNoteDenominator = midi.timestepsPerBeat * 4
def durationLen():
return int(np.ceil(np.log2(ShortestNoteDenominator)))
def sampleSize():
return int(
7 + # Pitch
2 + # Octave
durationLen() + # Duration
7 + # Inspiration
3 # Bars
)
def outputSize():
return int(
7 + # Pitch
2 + # Octave
durationLen() # Duration
)
# Turns val into a string of length maxLen
def getBinaryString(maxLen, val):
string = bin(val)[2:]
assert len(string) <= maxLen, "Val must be at most 2^maxLen"
paddedString = '0'*(maxLen - len(string)) + string
return paddedString
# TODO: upgrade to use Gray Code
def getDurationValue(string):
val = 0
for c in string:
val *= 2
if c == '1':
val += 1
return val+1
def getCyclePitch(pitch):
out = [int(0)]*7
majorThirdPitch = pitch % 4
minorThirdPitch = pitch % 3
out[majorThirdPitch] = 1
out[4+minorThirdPitch] = 1
return out
def makeNoteSample(pitch, duration, inspirationPitch, bar):
sample = [int(0)] * sampleSize()
currentPos = 0
# Pitch
sample[currentPos:currentPos+7] = getCyclePitch(pitch)
currentPos += 7
# Octave
octave = np.floor(pitch / 12) - 1
octave = max(min(octave,6),4) # Clamp octave range
if octave == 4:
sample[currentPos+0] = 1
elif octave == 6:
sample[currentPos+1] = 1
currentPos += 2
# Duration
durationString = getBinaryString(durationLen(), duration-1)
for i in range(len(durationString)):
if durationString[i] == '1':
sample[currentPos+i] = 1
currentPos += (len(durationString))
# Inspiration
sample[currentPos:currentPos+7] = getCyclePitch(inspirationPitch)
currentPos += 7
# Bars
barString = getBinaryString(int(np.ceil(np.log2(8))), bar)
for i in range(len(barString)):
if barString[i] == '1':
sample[currentPos+i] = 1
currentPos += len(barString)
return sample
def makeNoteTarget(pitch, duration):
sample = [int(0)] * outputSize()
# Pitch
majorThirdPitch = pitch % 4
minorThirdPitch = pitch % 3
sample[majorThirdPitch] = 1
sample[4+minorThirdPitch] = 1
# Octave
octave = np.floor(pitch / 12) - 1
octave = max(min(octave,6),4) # Clamp octave range
if octave == 4:
sample[7] = 1
elif octave == 6:
sample[8] = 1
# Duration
durationString = getBinaryString(durationLen(), duration-1)
for i in range(len(durationString)):
if durationString[i] == '1':
sample[9+i] = 1
return sample
def getPitchDurationFromSample(sample):
majorThirdPitch = 0
minorThirdPitch = 0
for i in range(0,4):
if sample[i] == 1:
majorThirdPitch = i
for i in range(4,7):
if sample[i] == 1:
minorThirdPitch = i-4
inOctavePitch = 0
# Could use the chinese remainder theorem, might save valuable picoseconds
for i in range(12):
if i % 4 == majorThirdPitch and i % 3 == minorThirdPitch:
inOctavePitch = i
octave = 5
if sample[7] == 1:
octave = 4
elif sample[8] == 1:
octave = 6
pitch = ((octave+1)*12) + inOctavePitch
durationString = ''
for i in range(9,9+durationLen()):
durationString += str(sample[i])
duration = getDurationValue(durationString)
return (pitch,duration)
def normalizeOutputSample(sample, durationThreshold=0.5, octaveThreshold=0.5):
normalSample = [int(0)] * outputSize()
majorThirdPitch = max(enumerate(sample[0:4]),key=operator.itemgetter(1))[0]
minorThirdPitch = max(enumerate(sample[4:7]),key=operator.itemgetter(1))[0]
octave = 5
if sample[7] >= octaveThreshold or sample[8] >= octaveThreshold:
if sample[7] > sample[8]:
octave = 4
else:
octave = 6
normalSample[majorThirdPitch] = 1
normalSample[4+minorThirdPitch] = 1
if octave == 4:
normalSample[7] = 1
elif octave == 6:
normalSample[8] = 1
normalSample[9:] = [int(x >= durationThreshold) for x in sample[9:]]
return normalSample
class Melody():
def __init__(self):
self.pitches = []
self.durations = []
self.bars = []
def addNote(self, pitch, duration, bar):
self.pitches.append(pitch)
self.durations.append(duration)
self.bars.append(bar)
def length(self):
return len(self.pitches)
def makeMelodyFromTrack(track):
assert track.isMonophonic(), "Only monophonic tracks can be enscribed"
melody = Melody()
for n in track.notes:
bar = int( | np.floor(n.start / track.barLen) | numpy.floor |
import numpy as np
import openmdao.api as om
class SectionPropertiesWingbox(om.ExplicitComponent):
"""
Compute geometric cross-section properties for the wingbox elements.
See Chauhan et al. (https://doi.org/10.1007/978-3-319-97773-7_38) for more.
Parameters
----------
streamwise_chords[ny-1] : numpy array
Average streamwise chord lengths for each streamwise VLM panel.
fem_chords[ny-1] : numpy array
Effective chord lengths normal to the FEM elements.
fem_twists[ny-1] : numpy array
Twist angles in planes normal to the FEM elements.
spar_thickness[ny-1] : numpy array
Material thicknesses of the front and rear spars for each wingbox segment.
skin_thickness[ny-1] : numpy array
Material thicknesses of the top and bottom skins for each wingbox segment.
t_over_c[ny-1] : numpy array
Streamwise thickness-to-chord ratios for each wingbox segment.
Returns
-------
A[ny-1] : numpy array
Cross-sectional area of each wingbox segment.
A_enc[ny-1] : numpy array
Cross-sectional enclosed area (measured using the material midlines) of
each wingbox segment.
A_int[ny-1] : numpy array
Cross-sectional internal area of each wingbox segment (used for fuel
volume).
Iy[ny-1] : numpy array
Second moment of area about the neutral axis parallel to the local
y-axis (for each wingbox segment).
Qz[ny-1] : numpy array
First moment of area above the neutral axis parallel to the local
z-axis (for each wingbox segment).
Iz[ny-1] : numpy array
Second moment of area about the neutral axis parallel to the local
z-axis (for each wingbox segment).
J[ny-1] : numpy array
Torsion constants for each wingbox segment.
htop[ny-1] : numpy array
Distance to the point on the top skin that is the farthest away from
the local-z neutral axis (for each wingbox segment).
hbottom[ny-1] : numpy array
Distance to the point on the bottom skin that is the farthest away from
the local-z neutral axis (for each wingbox segment).
hfront[ny-1] : numpy array
Distance to the point on the front spar that is the farthest away from
the local-y neutral axis (for each wingbox segment).
hrear[ny-1] : numpy array
Distance to the point on the rear spar that is the farthest away
from the local-y neutral axis (for each wingbox segment).
"""
def initialize(self):
self.options.declare("surface", types=dict)
def setup(self):
self.surface = surface = self.options["surface"]
self.mesh = surface["mesh"]
self.ny = self.mesh.shape[1]
# original thickness-to-chord ratio of the airfoil provided by the user
self.orig_wb_af_t_over_c = surface["original_wingbox_airfoil_t_over_c"]
# airfoil coordinates provided by the user
self.data_x_upper = surface["data_x_upper"]
self.data_x_lower = surface["data_x_lower"]
self.data_y_upper = surface["data_y_upper"]
self.data_y_lower = surface["data_y_lower"]
self.add_input("streamwise_chords", val=np.ones((self.ny - 1)), units="m")
self.add_input("fem_chords", val=np.ones((self.ny - 1)), units="m")
self.add_input("fem_twists", val=np.ones((self.ny - 1)), units="deg")
self.add_input("spar_thickness", val=np.ones((self.ny - 1)), units="m")
self.add_input("skin_thickness", val=np.ones((self.ny - 1)), units="m")
self.add_input("t_over_c", val=np.ones((self.ny - 1)))
self.add_output("A", val=np.ones((self.ny - 1)), units="m**2")
self.add_output("A_enc", val=np.ones((self.ny - 1)), units="m**2")
self.add_output("A_int", val=np.ones((self.ny - 1)), units="m**2")
self.add_output("Iy", val=np.ones((self.ny - 1)), units="m**4")
self.add_output("Qz", val=np.ones((self.ny - 1)), units="m**3")
self.add_output("Iz", val=np.ones((self.ny - 1)), units="m**4")
self.add_output("J", val=np.ones((self.ny - 1)), units="m**4")
self.add_output("htop", val=np.ones((self.ny - 1)), units="m")
self.add_output("hbottom", val=np.ones((self.ny - 1)), units="m")
self.add_output("hfront", val=np.ones((self.ny - 1)), units="m")
self.add_output("hrear", val=np.ones((self.ny - 1)), units="m")
self.declare_partials("*", "*", method="cs")
def compute(self, inputs, outputs):
# NOTE: In the code below, the x- and y-axes correspond to the element
# local z- and y-axes, respectively.
chord = inputs["fem_chords"]
spar_thickness = inputs["spar_thickness"]
skin_thickness = inputs["skin_thickness"]
t_over_c_original = self.orig_wb_af_t_over_c
t_over_c = inputs["t_over_c"]
streamwise_chord = inputs["streamwise_chords"]
theta = inputs["fem_twists"]
# Scale data points with chord
data_x_upper = np.outer(self.data_x_upper, chord)
data_y_upper = np.outer(self.data_y_upper, chord)
data_x_lower = np.outer(self.data_x_lower, chord)
data_y_lower = np.outer(self.data_y_lower, chord)
# Scale y-coordinates by t/c design variable which is streamwise t/c
data_y_upper *= t_over_c / t_over_c_original * streamwise_chord / chord
data_y_lower *= t_over_c / t_over_c_original * streamwise_chord / chord
# Compute enclosed area for torsion constant
# This currently does not change with twist
# Also compute internal area for internal volume calculation for fuel
x_up_diff = data_x_upper[1:] - data_x_upper[:-1]
x_low_diff = data_x_lower[1:] - data_x_lower[:-1]
y_up_diff = data_y_upper[1:] - data_y_upper[:-1]
y_low_diff = data_y_lower[1:] - data_y_lower[:-1]
y_up_add = data_y_upper[1:] + data_y_upper[:-1]
y_low_add = data_y_lower[1:] + data_y_lower[:-1]
A_enc = (x_up_diff) * (y_up_add - skin_thickness) / 2 # area above 0 line
A_enc += (x_low_diff) * (-y_low_add - skin_thickness) / 2 # area below 0 line
A_int = (x_up_diff) * (y_up_add - 2 * skin_thickness) / 2 # area above 0 line
A_int += (x_low_diff) * (-y_low_add - 2 * skin_thickness) / 2 # area below 0 line
A_enc = np.sum(A_enc, axis=0)
A_int = np.sum(A_int, axis=0)
A_enc -= (data_y_upper[0] - data_y_lower[0]) * spar_thickness / 2 # area of spars
A_enc -= (data_y_upper[-1] - data_y_lower[-1]) * spar_thickness / 2 # area of spars
A_int -= (data_y_upper[0] - data_y_lower[0]) * spar_thickness # area of spars
A_int -= (data_y_upper[-1] - data_y_lower[-1]) * spar_thickness # area of spars
outputs["A_enc"] = A_enc
outputs["A_int"] = A_int
# Compute perimeter to thickness ratio for torsion constant
# This currently does not change with twist
p_by_t_1 = (x_up_diff**2 + y_up_diff**2) ** 0.5 / skin_thickness # length / thickness of caps
p_by_t_2 = (x_low_diff**2 + y_low_diff**2) ** 0.5 / skin_thickness # length / thickness of caps
p_by_t = np.sum(p_by_t_1 + p_by_t_2, axis=0)
p_by_t += (data_y_upper[0] - data_y_lower[0] - skin_thickness) / spar_thickness # length / thickness of spars
p_by_t += (data_y_upper[-1] - data_y_lower[-1] - skin_thickness) / spar_thickness # length / thickness of spars
# Torsion constant
J = 4 * A_enc**2 / p_by_t
outputs["J"] = J
# Rotate the wingbox
rot_mat = np.array([[np.cos(theta), np.sin(theta)], [-np.sin(theta), np.cos(theta)]])
data_x_upper_2 = rot_mat[0, 0] * data_x_upper + rot_mat[0, 1] * data_y_upper
data_y_upper_2 = rot_mat[1, 0] * data_x_upper + rot_mat[1, 1] * data_y_upper
data_x_lower_2 = rot_mat[0, 0] * data_x_lower + rot_mat[0, 1] * data_y_lower
data_y_lower_2 = rot_mat[1, 0] * data_x_lower + rot_mat[1, 1] * data_y_lower
data_x_upper = data_x_upper_2.copy()
data_y_upper = data_y_upper_2.copy()
data_x_lower = data_x_lower_2.copy()
data_y_lower = data_y_lower_2.copy()
x_up_diff = data_x_upper[1:] - data_x_upper[:-1]
x_low_diff = data_x_lower[1:] - data_x_lower[:-1]
y_up_diff = data_y_upper[1:] - data_y_upper[:-1]
y_low_diff = data_y_lower[1:] - data_y_lower[:-1]
y_up_add = data_y_upper[1:] + data_y_upper[:-1]
y_low_add = data_y_lower[1:] + data_y_lower[:-1]
# Compute area moment of inertia about x axis
# First compute centroid and area
first_moment_area_upper = (y_up_add / 2 - (skin_thickness / 2)) * skin_thickness * x_up_diff
upper_area = skin_thickness * x_up_diff
first_moment_area_lower = (y_low_add / 2 + (skin_thickness / 2)) * skin_thickness * x_low_diff
lower_area = skin_thickness * x_low_diff
first_moment_area_front_spar = (
(data_y_upper[0] - data_y_lower[0] - 2 * skin_thickness)
* spar_thickness
* (data_y_upper[0] + data_y_lower[0])
/ 2
)
first_moment_area_rear_spar = (
(data_y_upper[-1] - data_y_lower[-1] - 2 * skin_thickness)
* spar_thickness
* (data_y_upper[-1] + data_y_lower[-1])
/ 2
)
area_spars = (
(data_y_upper[0] - data_y_lower[0] - 2 * skin_thickness)
+ (data_y_upper[-1] - data_y_lower[-1] - 2 * skin_thickness)
) * spar_thickness
area = np.sum(upper_area, axis=0) + np.sum(lower_area, axis=0) + area_spars
outputs["A"] = area
centroid = (
| np.sum(first_moment_area_upper, axis=0) | numpy.sum |
import unittest
import numpy as np
from scipy import stats
from warnings import warn
from pyapprox.variables import get_distribution_info, \
define_iid_random_variables, IndependentMultivariateRandomVariable, \
float_rv_discrete, variables_equivalent, get_pdf
from pyapprox.utilities import lists_of_arrays_equal
class TestVariables(unittest.TestCase):
def test_get_distribution_params(self):
name, scales, shapes = get_distribution_info(
stats.beta(a=1, b=2, loc=0, scale=1))
assert name == 'beta'
assert shapes == {'a': 1, 'b': 2}
assert scales == {'loc': 0, 'scale': 1}
rv = stats.beta(a=1, b=2, loc=3, scale=4)
pdf = get_pdf(rv)
xx = rv.rvs(100)
assert np.allclose(pdf(xx), rv.pdf(xx))
name, scales, shapes = get_distribution_info(
stats.beta(1, 2, loc=0, scale=1))
assert name == 'beta'
assert shapes == {'a': 1, 'b': 2}
assert scales == {'loc': 0, 'scale': 1}
name, scales, shapes = get_distribution_info(
stats.beta(1, 2, 0, scale=1))
assert name == 'beta'
assert shapes == {'a': 1, 'b': 2}
assert scales == {'loc': 0, 'scale': 1}
name, scales, shapes = get_distribution_info(stats.beta(1, 2, 0, 1))
assert name == 'beta'
assert shapes == {'a': 1, 'b': 2}
assert scales == {'loc': 0, 'scale': 1}
name, scales, shapes = get_distribution_info(stats.norm(0, 1))
assert name == 'norm'
assert shapes == dict()
assert scales == {'loc': 0, 'scale': 1}
name, scales, shapes = get_distribution_info(stats.norm(0, scale=1))
assert name == 'norm'
assert shapes == dict()
assert scales == {'loc': 0, 'scale': 1}
name, scales, shapes = get_distribution_info(stats.norm(
loc=0, scale=1))
assert name == 'norm'
assert shapes == dict()
assert scales == {'loc': 0, 'scale': 1}
name, scales, shapes = get_distribution_info(
stats.gamma(a=1, loc=0, scale=1))
assert name == 'gamma'
assert shapes == {'a': 1}
assert scales == {'loc': 0, 'scale': 1}
name, scales, shapes = get_distribution_info(
stats.gamma(1, loc=0, scale=1))
assert name == 'gamma'
assert shapes == {'a': 1}
assert scales == {'loc': 0, 'scale': 1}
name, scales, shapes = get_distribution_info(
stats.gamma(1, 0, scale=1))
assert name == 'gamma'
assert shapes == {'a': 1}
assert scales == {'loc': 0, 'scale': 1}
name, scales, shapes = get_distribution_info(stats.gamma(1, 0, 1))
assert name == 'gamma'
assert shapes == {'a': 1}
assert scales == {'loc': 0, 'scale': 1}
name, scales, shapes = get_distribution_info(stats.gamma(1))
assert name == 'gamma'
assert shapes == {'a': 1}
assert scales == {'loc': 0, 'scale': 1}
name, scales, shapes = get_distribution_info(stats.gamma(1, loc=0))
assert name == 'gamma'
assert shapes == {'a': 1}
assert scales == {'loc': 0, 'scale': 1}
name, scales, shapes = get_distribution_info(stats.gamma(1, scale=1))
assert name == 'gamma'
assert shapes == {'a': 1}
assert scales == {'loc': 0, 'scale': 1}
name, scales, shapes = get_distribution_info(
stats.binom(n=1, p=1, loc=0))
assert name == 'binom'
assert shapes == {'n': 1, 'p': 1}
assert scales == {'loc': 0, 'scale': 1}
name, scales, shapes = get_distribution_info(
stats.binom(1, p=1, loc=0))
assert name == 'binom'
assert shapes == {'n': 1, 'p': 1}
assert scales == {'loc': 0, 'scale': 1}
name, scales, shapes = get_distribution_info(stats.binom(1, 1, loc=0))
assert name == 'binom'
assert shapes == {'n': 1, 'p': 1}
assert scales == {'loc': 0, 'scale': 1}
name, scales, shapes = get_distribution_info(stats.binom(1, 1, 0))
assert name == 'binom'
assert shapes == {'n': 1, 'p': 1}
assert scales == {'loc': 0, 'scale': 1}
def test_get_pdf(self):
rv = stats.beta(a=1, b=2, loc=3, scale=4)
pdf = get_pdf(rv)
xx = rv.rvs(100)
assert np.allclose(pdf(xx), rv.pdf(xx))
scipy_continuous_var_names = [
n for n in stats._continuous_distns._distn_names]
continuous_var_names = [
"ksone", "kstwobign", "norm", "alpha", "anglit", "arcsine", "beta",
"betaprime", "bradford", "burr", "burr12", "fisk", "cauchy", "chi",
"chi2", "cosine", "dgamma", "dweibull", "expon", "exponnorm",
"exponweib", "exponpow", "fatiguelife", "foldcauchy", "f",
"foldnorm", "weibull_min", "weibull_max", "frechet_r", "frechet_l",
"genlogistic", "genpareto", "genexpon", "genextreme", "gamma",
"erlang", "gengamma", "genhalflogistic", "gompertz", "gumbel_r",
"gumbel_l", "halfcauchy", "halflogistic", "halfnorm", "hypsecant",
"gausshyper", "invgamma", "invgauss", "norminvgauss", "invweibull",
"johnsonsb", "johnsonsu", "laplace", "levy", "levy_l",
"levy_stable", "logistic", "loggamma", "loglaplace", "lognorm",
"gilbrat", "maxwell", "mielke", "kappa4", "kappa3", "moyal",
"nakagami", "ncx2", "ncf", "t", "nct", "pareto", "lomax",
"pearson3", "powerlaw", "powerlognorm", "powernorm", "rdist",
"rayleigh", "reciprocal", "rice", "recipinvgauss", "semicircular",
"skewnorm", "trapz", "triang", "truncexpon", "truncnorm",
"tukeylambda", "uniform", "vonmises", "vonmises_line", "wald",
"wrapcauchy", "gennorm", "halfgennorm", "crystalball", "argus"]
continuous_var_shapes = [
{"n": int(1e3)}, {}, {}, {"a": 1}, {}, {}, {"a": 2, "b": 3},
{"a": 2, "b": 3}, {"c": 2}, {"c": 2, "d": 1},
{"c": 2, "d": 1}, {"c": 3}, {}, {"df": 10}, {"df": 10},
{}, {"a": 3}, {"c": 3}, {}, {"K": 2}, {"a": 2, "c": 3}, {"b": 3},
{"c": 3}, {"c": 3}, {"dfn": 1, "dfd": 1}, {"c": 1}, {"c": 1},
{"c": 1}, {"c": 1}, {"c": 1}, {"c": 1}, {"c": 1},
{"a": 2, "b": 3, "c": 1}, {"c": 1}, {"a": 2}, {"a": 2},
{"a": 2, "c": 1}, {"c": 1}, {"c": 1}, {}, {}, {}, {}, {}, {},
{"a": 2, "b": 3, "c": 1, "z": 1}, {"a": 1}, {"mu": 1},
{"a": 2, "b": 1}, {"c": 1}, {"a": 2, "b": 1}, {"a": 2, "b": 1},
{}, {}, {}, {"alpha": 1, "beta": 1}, {}, {"c": 1}, {"c": 1},
{"s": 1}, {}, {}, {"k": 1, "s": 1}, {"h": 1, "k": 1}, {"a": 1}, {},
{"nu": 1}, {"df": 10, "nc": 1}, {"dfn": 10, "dfd": 10, "nc": 1},
{"df": 10}, {"df": 10, "nc": 1}, {"b": 2}, {"c": 2}, {"skew": 2},
{"a": 1}, {"c": 2, "s": 1}, {"c": 2}, {"c": 2}, {},
{"a": 2, "b": 3}, {"b": 2}, {"mu": 2}, {}, {"a": 1},
{"c": 0, "d": 1}, {"c": 1}, {"b": 2}, {"a": 2, "b": 3}, {"lam": 2},
{}, {"kappa": 2}, {"kappa": 2}, {}, {"c": 0.5}, {"beta": 2},
{"beta": 2}, {"beta": 2, "m": 2}, {"chi": 1}]
for name in scipy_continuous_var_names:
if name not in continuous_var_names:
warn(f"variable {name} is not tested", UserWarning)
unsupported_continuous_var_names = ["ncf"]
for name in unsupported_continuous_var_names:
ii = continuous_var_names.index(name)
del continuous_var_names[ii]
del continuous_var_shapes[ii]
for name, shapes in zip(
continuous_var_names, continuous_var_shapes):
if name == "levy_l":
loc = -2
else:
loc = 2
print(name, shapes)
var = getattr(stats, name)(**shapes, loc=loc, scale=3)
pdf = get_pdf(var)
xx = var.rvs(100)
assert np.allclose(pdf(xx), var.pdf(xx))
def test_define_iid_random_variables(self):
"""
Construct a independent and identiically distributed (iid)
multivariate random variable from the tensor-product of
the same one-dimensional variable.
"""
var = stats.norm(loc=2, scale=3)
num_vars = 2
iid_variable = define_iid_random_variables(var, num_vars)
assert len(iid_variable.unique_variables) == 1
assert np.allclose(
iid_variable.unique_variable_indices, np.arange(num_vars))
def test_define_mixed_tensor_product_random_variable_I(self):
"""
Construct a multivariate random variable from the tensor-product of
different one-dimensional variables assuming that a given variable type
the distribution parameters ARE the same
"""
univariate_variables = [
stats.uniform(-1, 2), stats.beta(1, 1, -1, 2), stats.norm(0, 1), stats.uniform(-1, 2),
stats.uniform(-1, 2), stats.beta(1, 1, -1, 2)]
variable = IndependentMultivariateRandomVariable(univariate_variables)
assert len(variable.unique_variables) == 3
assert lists_of_arrays_equal(variable.unique_variable_indices,
[[0, 3, 4], [1, 5], [2]])
def test_define_mixed_tensor_product_random_variable_II(self):
"""
Construct a multivariate random variable from the tensor-product of
different one-dimensional variables assuming that a given variable
type the distribution parameters ARE NOT the same
"""
univariate_variables = [
stats.uniform(-1, 2), stats.beta(1, 1, -1, 2),
stats.norm(-1, 2), stats.uniform(), stats.uniform(-1, 2),
stats.beta(2, 1, -2, 3)]
variable = IndependentMultivariateRandomVariable(univariate_variables)
assert len(variable.unique_variables) == 5
assert lists_of_arrays_equal(variable.unique_variable_indices,
[[0, 4], [1], [2], [3], [5]])
def test_float_discrete_variable(self):
nmasses1 = 10
mass_locations1 = np.geomspace(1.0, 32.0, num=nmasses1)
masses1 = np.ones(nmasses1, dtype=float)/nmasses1
var1 = float_rv_discrete(
name='var1', values=(mass_locations1, masses1))()
for power in [1, 2, 3]:
assert np.allclose(
var1.moment(power), (mass_locations1**power).dot(masses1))
np.random.seed(1)
num_samples = int(1e6)
samples = var1.rvs(size=(1, num_samples))
assert np.allclose(samples.mean(), var1.moment(1), atol=1e-2)
# import matplotlib.pyplot as plt
# xx = np.linspace(0,33,301)
# plt.plot(mass_locations1,np.cumsum(masses1),'rss')
# plt.plot(xx,var1.cdf(xx),'-'); plt.show()
assert np.allclose(np.cumsum(masses1), var1.cdf(mass_locations1))
# import matplotlib.pyplot as plt
# yy = np.linspace(0,1,51)
# plt.plot(mass_locations1,np.cumsum(masses1),'rs')
# plt.plot(var1.ppf(yy),yy,'-o',ms=2); plt.show()
xx = mass_locations1
assert np.allclose(xx, var1.ppf(var1.cdf(xx)))
xx = mass_locations1
assert np.allclose(xx, var1.ppf(var1.cdf(xx+1e-1)))
def test_get_statistics(self):
univariate_variables = [
stats.uniform(2, 4), stats.beta(1, 1, -1, 2), stats.norm(0, 1)]
variable = IndependentMultivariateRandomVariable(univariate_variables)
mean = variable.get_statistics('mean')
assert np.allclose(mean.squeeze(), [4, 0, 0])
intervals = variable.get_statistics('interval', alpha=1)
assert np.allclose(intervals, np.array(
[[2, 6], [-1, 1], [-np.inf, np.inf]]))
def test_float_rv_discrete_pdf(self):
nmasses1 = 10
mass_locations1 = | np.geomspace(1.0, 32.0, num=nmasses1) | numpy.geomspace |
import copy
import time
from collections import OrderedDict
import torch
from data.dataloader import local_client_dataset, test_dataset
from models.utils import *
from utils.train_helper import validate_one_model
from utils.sampling import *
import numpy as np
from multiprocessing import Process
import time
def return_state_dict(network):
"""
save model to state_dict
"""
feat_model = {k: v.cpu() for k, v in network["feat_model"].state_dict().items()}
classifier = {k: v.cpu() for k, v in network["classifier"].state_dict().items()}
return {"feat_model": feat_model, "classifier": classifier}
def load_state_dict(network, state_dict):
"""
restore model from state_dict
"""
network["feat_model"].load_state_dict(state_dict["feat_model"])
network["classifier"].load_state_dict(state_dict["classifier"])
# for name, param in state_dict["feat_model"].items():
# print(name, "\t", param.size())
return network
def check_status(status_list, selected_idx, target_status):
"""
0. original status (1st FL round)
1. server finished sending: server_network --> mp_list
2. client received, and returned the model: mp_list --> networks[i] --> local_update --> mp_list
3. server received: mp_list --> networks[i]
--> 1. aggregation finished. networks[i] --> aggregate --> server_network --> mp_list, the status change to 1
---
Return True: when all clients meet conditions, else False
"""
tmp = np.array(status_list)
if (tmp[selected_idx] == target_status).all() == True:
return True
else:
return False
def set_status(status_list, selected_idx, target_status):
"""
see function: check_status
"""
if type(selected_idx) is int:
selected_idx = [selected_idx]
for i in selected_idx:
status_list[i] = target_status
# print(f"set_status {target_status}")
def difference_models_norm_2(model_1, model_2):
"""
Return the norm 2 difference between the two model parameters. Used in FedProx.
"""
tensor_1_backbone = list(model_1["feat_model"].parameters())
tensor_1_classifier = list(model_1["classifier"].parameters())
tensor_2_backbone = list(model_2["feat_model"].parameters())
tensor_2_classifier = list(model_2["classifier"].parameters())
diff_list = [torch.sum((tensor_1_backbone[i] - tensor_2_backbone[i])**2) for i in range(len(tensor_1_backbone))]
diff_list.extend([torch.sum((tensor_1_classifier[i] - tensor_2_classifier[i])**2) for i in range(len(tensor_1_classifier))])
norm = sum(diff_list)
return norm
class Fed_server(Process):
"""
Class for client updating and model aggregation
"""
def __init__(
self, init_network, criterion, config, per_client_data,
per_client_label, idx_per_client_train,
test_data, test_label, state_list=None, state_dict_list=None, idx=None
):
super(Fed_server, self).__init__()
self.local_bs = config["fl_opt"]["local_bs"]
self.local_ep = config["fl_opt"]["local_ep"]
self.num_clients = config["fl_opt"]["num_clients"]
self.criterion = criterion
self.networks, self.optimizers, self.optimizers_stage2, self.schedulers = [], [], [], []
self.train_loaders = [] # include dataloader or pre-loaded dataset
self.train_loader_balanced = [] # balanced-sampling dataloader
self.local_num_per_cls = [] # list to store local data number per class
self.test_loaders = []
self.status_list = state_list
self.state_dict_list = state_dict_list
self.client_idx = idx # physical idx of clients (hardcoded)
self.config = config
self.prefetch = False
self.feat_aug = config["fl_opt"]["feat_aug"]
self.crt = config["fl_opt"]["crt"]
self.client_weights = np.array([i for i in idx_per_client_train])
self.client_weights = self.client_weights/self.client_weights.sum()
self.device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
self.server_network = copy.deepcopy(init_network)
self.server_network["feat_model"].to(self.device)
self.server_network["classifier"].to(self.device)
# per-client accuracy and loss
self.acc = [0 for i in range(self.num_clients)]
self.losses_cls = [-1 for i in range(self.num_clients)]
self.losses_kd = [-1 for i in range(self.num_clients)]
print(f'=====> {config["metainfo"]["optimizer"]}, Server (fed.py)\n ')
######## init backbone, classifier, optimizer and dataloader ########
for client_i in range(self.num_clients):
backbone = copy.deepcopy(self.server_network["feat_model"])
classifier = copy.deepcopy(self.server_network["classifier"])
self.networks.append({"feat_model": backbone, "classifier": classifier})
""" Server does not need
# list of optimizer_dict. One optimizer for one network
self.optimizers.append(init_optimizers(self.networks[client_i], config))
optim_params_dict = {'params': self.networks[client_i]["classifier"].parameters(), 'lr': 0.001, 'momentum': 0.9, 'weight_decay': 0}
self.optimizers_stage2.append(torch.optim.SGD([optim_params_dict],))
# dataloader
num_workers = 0
local_dataset = \
local_client_dataset(per_client_data[client_i], per_client_label[client_i], config)
self.train_loaders.append(
torch.utils.data.DataLoader(
local_dataset, batch_size=self.local_bs, shuffle=True,
num_workers=num_workers, pin_memory=False)
)
self.train_loader_balanced.append(
torch.utils.data.DataLoader(
local_dataset, batch_size=self.local_bs, sampler=local_dataset.get_balanced_sampler(),
num_workers=num_workers, pin_memory=False)
)
self.local_num_per_cls.append(local_dataset.class_sample_count)
"""
# centralized train dataset
train_data_all, train_label_all = [], []
for client_i in range(len(per_client_label)):
train_data_all = train_data_all + per_client_data[client_i]
train_label_all = train_label_all + per_client_label[client_i]
self.train_dataset = local_client_dataset(train_data_all, train_label_all, config)
self.test_dataset = test_dataset(test_data, test_label, config)
def local_train(self, selected_idx):
"""
server-side code
"""
# self.server_network --> mp_list
for i in selected_idx:
self.state_dict_list[i] = return_state_dict(self.server_network) # model transfer
set_status(self.status_list, selected_idx, 1)
if self.local_ep > 10: # is local training
print("Waiting")
# wait until all clients returning the model
while check_status(self.status_list, selected_idx, 2) is False:
time.sleep(0.1)
# mp_list --> self.networks (copys of client models on the server). Prepare for aggregation.
for i in selected_idx:
load_state_dict(self.networks[i], self.state_dict_list[i]) # model transfer
print("===> Local training finished")
def aggregation(self, selected_idx, mode):
"""
server-side code: aggregation
"""
if mode in ["fedavg", "fedavgm", "fedbn", "fedprox"]:
self.aggregate_layers(selected_idx, mode, backbone_only=False)
elif mode == "fedavg_fs":
opt = self.config["fl_opt"]
backbone_only, imprint, spread_out = opt["backbone_only"], opt["imprint"], opt["spread_out"]
self.aggregate_layers(selected_idx, "fedavg", backbone_only=backbone_only)
if imprint:
self.imprint(selected_idx)
if spread_out:
self.spread_out()
# model: self.server_network --> mp_list
for i in selected_idx:
self.state_dict_list[i] = return_state_dict(self.server_network) # model transfer
set_status(self.status_list, selected_idx, 0) # back to original
print("===> Aggregation finished")
def aggregate_layers(self, selected_idx, mode, backbone_only):
"""
backbone_only: choose to only aggregate backbone
"""
weights_sum = self.client_weights[selected_idx].sum()
with torch.no_grad():
if mode in ["fedavg", "fedprox"]:
for net_name, net in self.server_network.items():
if net_name == "classifier" and backbone_only:
pass
else:
for key, layer in net.state_dict().items():
if 'num_batches_tracked' in key:
# num_batches_tracked is a non trainable LongTensor
# and num_batches_tracked are the same for
# all clients for the given datasets
layer.data.copy_(self.networks[0][net_name].state_dict()[key])
else:
temp = torch.zeros_like(layer)
# Fedavg
for idx in selected_idx:
weight = self.client_weights[idx]/weights_sum
temp += weight * self.networks[idx][net_name].state_dict()[key]
layer.data.copy_(temp)
# update client models
# for idx in selected_idx:
# self.networks[idx][net_name].state_dict()[key].data.copy_(layer)
elif mode == "fedbn": # https://openreview.net/pdf?id=6YEQUn0QICG
for net_name, net in self.server_network.items():
if net_name == "classifier" and backbone_only:
pass
else:
for key, layer in net.state_dict().items():
if 'bn' not in key:
temp = torch.zeros_like(layer)
# Fedavg
for idx in selected_idx:
weight = self.client_weights[idx]/weights_sum
temp += weight * self.networks[idx][net_name].state_dict()[key]
layer.data.copy_(temp)
# update client models
# for idx in selected_idx:
# self.networks[idx][net_name].state_dict()[key].data.copy_(layer)
elif mode == "fedavgm":
raise NotImplementedError
def evaluate_global(self, train_dataset=None, test_dataset=None):
"""
Accuracy of the global model and all classes
"""
# evaluate on training set
if train_dataset is None:
train_dataset = self.train_dataset
if test_dataset is None:
test_dataset = self.test_dataset
train_loss_per_cls, train_acc_per_cls = validate_one_model(
self.server_network, train_dataset, self.device, per_cls_acc=True)
# evaluate on test set: per-class loss/acc
test_loss_per_cls, test_acc_per_cls = validate_one_model(
self.server_network, test_dataset, self.device, per_cls_acc=True)
print("===> Evaluation finished\n")
return train_loss_per_cls, train_acc_per_cls, test_loss_per_cls, test_acc_per_cls
def evaluate_global_all(self, train_dataset=None, test_dataset=None):
"""
Accuracy of models of all nodes and all classes
Return: all_results
shape: (4, num_client, num_cls), 4 for (train_loss, train_acc, test_loss, test_acc)
"""
# evaluate on training set
if train_dataset is None:
train_dataset = self.train_dataset
if test_dataset is None:
test_dataset = self.test_dataset
all_results = [None for i in range(self.num_clients)]
for idx in range(self.num_clients):
# evaluate on test set: per-class loss/acc
train_loss_per_cls, train_acc_per_cls = validate_one_model(
self.networks[idx], train_dataset, self.device, per_cls_acc=True)
# evaluate on test set: per-class loss/acc
test_loss_per_cls, test_acc_per_cls = validate_one_model(
self.networks[idx], test_dataset, self.device, per_cls_acc=True)
all_results[idx] = train_loss_per_cls, train_acc_per_cls, test_loss_per_cls, test_acc_per_cls
print(f"===> Evaluation finished{idx}\n")
all_results = np.array(all_results).transpose(1,0,2)
return all_results
class Fed_client(Process):
"""
Class for client updating and model aggregation
"""
def __init__(
self, init_network, criterion, config, per_client_data,
per_client_label, idx_per_client_train,
test_data, test_label, state_list=None, state_dict_list=None, idx=None
):
super(Fed_client, self).__init__()
self.local_bs = config["fl_opt"]["local_bs"]
self.local_ep = config["fl_opt"]["local_ep"]
self.num_clients = config["fl_opt"]["num_clients"]
self.criterion = criterion
self.networks, self.optimizers, self.optimizers_stage2, self.schedulers = [], [], [], []
self.train_loaders = [] # include dataloader or pre-loaded dataset
self.train_loader_balanced = [] # balanced-sampling dataloader
self.local_num_per_cls = [] # list to store local data number per class
self.test_loaders = []
self.status_list = state_list
self.state_dict_list = state_dict_list
self.client_idx = idx # physical idx of clients (hardcoded)
self.config = config
self.device = config["device_client"][idx]
self.server_network = copy.deepcopy(init_network)
self.balanced_loader = config["fl_opt"]["balanced_loader"]
self.prefetch = False
self.feat_aug = config["fl_opt"]["feat_aug"]
self.crt = config["fl_opt"]["crt"]
if config["fl_opt"]["aggregation"] == "fedprox":
self.fedprox = True
else:
self.fedprox = False
self.mu = 0.05
self.client_weights = np.array([i for i in idx_per_client_train])
self.client_weights = self.client_weights/self.client_weights.sum()
# per-client accuracy and loss
self.acc = [0 for i in range(self.num_clients)]
self.losses_cls = [-1 for i in range(self.num_clients)]
self.losses_kd = [-1 for i in range(self.num_clients)]
print(f'=====> {config["metainfo"]["optimizer"]}, Client {idx} (fed.py)\n ')
######## init backbone, classifier, optimizer and dataloader ########
for client_i in range(self.num_clients):
# list of network and optimizer_dict. One optimizer for one network.
if client_i != self.client_idx:
self.networks.append(None)
self.optimizers.append(None)
self.optimizers_stage2.append(None)
else:
backbone = copy.deepcopy(self.server_network["feat_model"])
classifier = copy.deepcopy(self.server_network["classifier"])
self.networks.append({"feat_model": backbone, "classifier": classifier})
self.optimizers.append(init_optimizers(self.networks[client_i], config))
optim_params_dict = {'params': self.networks[client_i]["classifier"].parameters(), 'lr': 0.001, 'momentum': 0.9, 'weight_decay': 0}
self.optimizers_stage2.append(torch.optim.SGD([optim_params_dict],))
# dataloader
num_workers = 0
local_dataset = \
local_client_dataset(per_client_data[client_i], per_client_label[client_i], config)
self.train_loaders.append(
torch.utils.data.DataLoader(
local_dataset, batch_size=self.local_bs, shuffle=True,
num_workers=num_workers, pin_memory=False)
)
self.train_loader_balanced.append(
torch.utils.data.DataLoader(
local_dataset, batch_size=self.local_bs, sampler=local_dataset.get_balanced_sampler(),
num_workers=num_workers, pin_memory=False)
)
self.local_num_per_cls.append(local_dataset.class_sample_count)
""" clients do not need
# centralized train dataset
train_data_all, train_label_all = [], []
for client_i in range(len(per_client_label)):
train_data_all = train_data_all + per_client_data[client_i]
train_label_all = train_label_all + per_client_label[client_i]
self.train_dataset = local_client_dataset(train_data_all, train_label_all, config)
self.test_dataset = test_dataset(test_data, test_label, config)
"""
def run(self):
"""
client-side code
"""
self.server_network["feat_model"].to(self.device)
self.server_network["classifier"].to(self.device)
self.networks[self.client_idx]["feat_model"].to(self.device)
self.networks[self.client_idx]["classifier"].to(self.device)
while(1):
while check_status(self.status_list, self.client_idx, 1) is False:
time.sleep(0.1)
# model: mp_list --> server_network
load_state_dict(self.server_network, self.state_dict_list[self.client_idx]) # model transfer
self.train_lt(self.client_idx) # local model updating
# self.networks[i] --> mp_list
self.state_dict_list[self.client_idx] = return_state_dict(self.networks[self.client_idx]) # model transfer
set_status(self.status_list, self.client_idx, 2)
def train_lt(self, idx):
"""
client-side code
---
Argus:
- idx: the index in all clients (e.g., 50) or selected clients (e.g., 10).
If self.prefetch is true: the index in selected clients,
If self.prefetch is true: the index in all clients
"""
idx_in_all = idx
# server broadcast the model to clients
"""
# optimizer will not work if use this, because optimizer needs the params from the model
# self.networks[idx_in_all] = copy.deepcopy(self.server_network)
"""
for net_name, net in self.server_network.items(): # feat_model, classifier
state_dict = self.networks[idx_in_all][net_name].state_dict()
for key, layer in net.state_dict().items():
state_dict[key].data.copy_(layer.data)
for net in self.networks[idx_in_all].values():
net.train()
for net in self.server_network.values():
net.train()
teacher = self.server_network
# torch.cuda.empty_cache()
"""
(Per-cls) Covariance Calculation
"""
if self.feat_aug:
# probability for augmentation for every class
max_num = max(self.local_num_per_cls[idx])
prob = torch.tensor([1.0-i/max_num for i in self.local_num_per_cls[idx]])
# obtain features and labels under eval mode
feat_list, label_list = [], []
# self.networks[idx_in_all]['feat_model'].eval()
for (imgs, labels, indexs) in self.train_loaders[idx]:
with torch.no_grad():
imgs = imgs.to(self.device)
feat_list.append(teacher['feat_model'](imgs).cpu())
label_list.append(labels)
feat_list = torch.cat(feat_list, 0)
# self.networks[idx_in_all]['feat_model'].train()
label_list = torch.cat(label_list, 0)
unique_labels = list(np.unique(label_list)) # e.g., size (6, )
transformed_label_list = torch.tensor([unique_labels.index(i) for i in label_list]) # e.g., size (n, )
# per-cls features
feats_per_cls = [[] for i in range(len(unique_labels))]
for feats, label in zip(feat_list, transformed_label_list):
feats_per_cls[label].append(feats)
# calculate the variance
sampled_data, sample_label = [], []
per_cls_cov = []
for feats in feats_per_cls:
if len(feats) > 1:
per_cls_cov.append(np.cov(torch.stack(feats, 1).numpy()))
else:
per_cls_cov.append( | np.zeros((feats[0].shape[0], feats[0].shape[0])) | numpy.zeros |
import torch
import numpy as np
import pickle
def h36m_valid_angle_check(p3d):
"""
p3d: [bs,16,3] or [bs,48]
"""
if p3d.shape[-1] == 48:
p3d = p3d.reshape([p3d.shape[0], 16, 3])
cos_func = lambda p1, p2: np.sum(p1 * p2, axis=1) / | np.linalg.norm(p1, axis=1) | numpy.linalg.norm |
"""
Tests for module in package_name.
"""
import math
import numpy as np
# from package_name.module import cubic_rectification
from ..module import cubic_rectification
from .base_test import BaseTestCase, unittest
class NumbersTest(BaseTestCase):
def test_even(self):
"""
Test that numbers between 0 and 5 are all even.
"""
for i in range(0, 6, 2):
with self.subTest(i=i):
self.assertEqual(i % 2, 0)
class TestVerbose(BaseTestCase):
"""
Test that things are printed to stdout correctly.
"""
def test_hello_world(self):
"""Test printing to stdout."""
message = "Hello world!"
capture_pre = self.capsys.readouterr() # Clear stdout
print(message) # Execute method (verbose)
capture_post = self.recapsys(capture_pre) # Capture and then re-output
self.assert_string_equal(capture_post.out.strip(), message)
def test_shakespeare(self):
# Clear stdout (in this case, an empty capture)
capture_pre = self.capsys.readouterr()
# Execute method (verbose)
print("To be, or not to be, that is the question:")
# Capture the output to stdout, then re-output
capture_post = self.recapsys(capture_pre)
# Compare output to target
self.assert_starts_with(capture_post.out, "To be, or not")
# Clear stdout (in this case, capturing the re-output first print statement)
capture_pre = self.capsys.readouterr()
# Execute method (verbose)
print("Whether 'tis nobler in the mind to suffer")
# Capture the output to stdout, then re-output. This now prints both
# lines to stdout at once, which otherwise would not appear due to our
# captures.
capture_post = self.recapsys(capture_pre)
# Compare output to target
self.assert_starts_with(capture_post.out.lower(), "whether 'tis nobler")
class TestCubicRectification(BaseTestCase):
"""
Tests for the cubic_rectification function.
"""
def test_int(self):
"""Test with integer inputs."""
self.assertEqual(cubic_rectification(2), 8)
self.assertEqual(cubic_rectification(-2), 0)
self.assertEqual(cubic_rectification(3), 27)
def test_float(self):
"""Test with float inputs."""
# Need to use assert_allclose due to the real possibility of a
# floating point inaccuracy.
self.assert_allclose(cubic_rectification(1.2), 1.728)
self.assert_allclose(cubic_rectification(-1.2), 0)
def test_empty_array(self):
"""Test with empty array."""
self.assert_equal(cubic_rectification( | np.array([]) | numpy.array |
# -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'cellPoseUI.ui'
import numpy as np
import sys, os, pathlib, warnings, datetime, tempfile, glob, time, threading
from natsort import natsorted
from PyQt5 import QtCore, QtGui, QtWidgets, Qt
import pyqtgraph as pg
import cv2
from scellseg.guis import guiparts, iopart, menus, plot
from scellseg import models, utils, transforms, dynamics, dataset, io
from scellseg.dataset import DatasetShot, DatasetQuery
from scellseg.contrast_learning.dataset import DatasetPairEval
from skimage.measure import regionprops
from tqdm import trange
from math import floor, ceil
from torch.utils.data import DataLoader
try:
import matplotlib.pyplot as plt
MATPLOTLIB = True
except:
MATPLOTLIB = False
class Ui_MainWindow(QtGui.QMainWindow):
"""UI Widget Initialize and UI Layout Initialize,
With any bug or problem, please do connact us from Github Issue"""
def __init__(self, image=None):
super(Ui_MainWindow, self).__init__()
if image is not None:
self.filename = image
iopart._load_image(self, self.filename)
self.now_pyfile_path = os.path.dirname(os.path.abspath(__file__)).replace('\\', '/')
def setupUi(self, MainWindow, image=None):
MainWindow.setObjectName("MainWindow")
MainWindow.resize(1420, 800)
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap(self.now_pyfile_path + "/assets/logo.svg"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
MainWindow.setWindowIcon(icon)
QtWidgets.QApplication.setOverrideCursor(QtCore.Qt.CrossCursor)
menus.mainmenu(self)
menus.editmenu(self)
menus.helpmenu(self)
self.centralwidget = QtWidgets.QWidget(MainWindow)
self.centralwidget.setObjectName("centralwidget")
self.verticalLayout_2 = QtWidgets.QVBoxLayout(self.centralwidget)
self.verticalLayout_2.setContentsMargins(6, 6, 6, 6)
self.verticalLayout_2.setSpacing(6)
self.verticalLayout_2.setObjectName("verticalLayout_2")
self.splitter = QtWidgets.QSplitter(self.centralwidget)
self.splitter.setOrientation(QtCore.Qt.Horizontal)
self.splitter.setObjectName("splitter")
self.splitter2 = QtWidgets.QSplitter()
self.splitter2.setOrientation(QtCore.Qt.Horizontal)
self.splitter2.setObjectName("splitter2")
self.scrollArea = QtWidgets.QScrollArea(self.splitter)
self.scrollArea.setWidgetResizable(True)
self.scrollArea.setObjectName("scrollArea")
self.scrollAreaWidgetContents = QtWidgets.QWidget()
# self.scrollAreaWidgetContents.setFixedWidth(500)
self.scrollAreaWidgetContents.setGeometry(QtCore.QRect(0, 0, 1500, 848))
self.scrollAreaWidgetContents.setObjectName("scrollAreaWidgetContents")
# self.TableModel = QtGui.QStandardItemModel(self.tableRow, self.tableCol)
# self.TableModel.setHorizontalHeaderLabels(["INDEX", "NAME"])
# self.TableView = QtGui.QTableView()
# self.TableView.setModel(self.TableModel)
self.mainLayout = QtWidgets.QGridLayout(self.scrollAreaWidgetContents)
self.mainLayout.setContentsMargins(0, 0, 0, 0)
self.mainLayout.setSpacing(0)
self.mainLayout.setObjectName("mainLayout")
self.previous_button = QtWidgets.QPushButton("previous image [Ctrl + ←]")
self.load_folder = QtWidgets.QPushButton("load image folder ")
self.next_button = QtWidgets.QPushButton("next image [Ctrl + →]")
self.previous_button.setShortcut(Qt.QKeySequence.MoveToPreviousWord)
self.next_button.setShortcut(Qt.QKeySequence.MoveToNextWord)
self.mainLayout.addWidget(self.previous_button, 1, 1, 1, 1)
self.mainLayout.addWidget(self.load_folder, 1, 2, 1, 1)
self.mainLayout.addWidget(self.next_button, 1, 3, 1, 1)
self.previous_button.clicked.connect(self.PreImBntClicked)
self.next_button.clicked.connect(self.NextImBntClicked)
self.load_folder.clicked.connect(self.OpenDirBntClicked)
# leftside cell list widget
self.listView = QtWidgets.QTableView()
self.myCellList = []
self.listmodel = Qt.QStandardItemModel(0,1)
self.listmodel.setHorizontalHeaderLabels(["Annotation"])
# self.listmodel.setHorizontalHeaderItem(0, QtWidgets.QTableWidgetItem())
self.listView.horizontalHeader().setDefaultAlignment(QtCore.Qt.AlignLeft)
# self.listView.horizontalHeader().setStyle("background-color: #F0F0F0")
# self.listView.horizontalHeader().setVisible(False)
self.listView.verticalHeader().setVisible(False)
for i in range(len(self.myCellList)):
self.listmodel.setItem(i,Qt.QStandardItem(self.myCellList[i]))
self.listView.horizontalHeader().setDefaultSectionSize(140)
self.listView.setMaximumWidth(120)
self.listView.setModel(self.listmodel)
self.listView.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.listView.AdjustToContents
self.listView.customContextMenuRequested.connect(self.show_menu)
# self.listView.setSelectionMode(QtWidgets.QAbstractItemView.SingleSelection)
self.listView.clicked.connect(self.showChoosen)
self.scrollArea.setWidget(self.scrollAreaWidgetContents)
self.toolBox = QtWidgets.QToolBox(self.splitter)
self.toolBox.setObjectName("toolBox")
self.toolBox.setMaximumWidth(340)
self.page = QtWidgets.QWidget()
self.page.setFixedWidth(340)
self.page.setObjectName("page")
self.gridLayout = QtWidgets.QGridLayout(self.page)
self.gridLayout.setContentsMargins(0, 0, 0, 0)
self.gridLayout.setSpacing(6)
self.gridLayout.setObjectName("gridLayout")
# cross-hair/Draw area
self.vLine = pg.InfiniteLine(angle=90, movable=False)
self.hLine = pg.InfiniteLine(angle=0, movable=False)
self.layer_off = False
self.masksOn = True
self.win = pg.GraphicsLayoutWidget()
self.state_label = pg.LabelItem("Scellseg has been initialized!")
self.win.addItem(self.state_label, 3, 0)
self.win.scene().sigMouseClicked.connect(self.plot_clicked)
self.win.scene().sigMouseMoved.connect(self.mouse_moved)
self.make_viewbox()
bwrmap = make_bwr()
self.bwr = bwrmap.getLookupTable(start=0.0, stop=255.0, alpha=False)
self.cmap = []
# spectral colormap
self.cmap.append(make_spectral().getLookupTable(start=0.0, stop=255.0, alpha=False))
# single channel colormaps
for i in range(3):
self.cmap.append(make_cmap(i).getLookupTable(start=0.0, stop=255.0, alpha=False))
if MATPLOTLIB:
self.colormap = (plt.get_cmap('gist_ncar')(np.linspace(0.0, .9, 1000)) * 255).astype(np.uint8)
else:
self.colormap = ((np.random.rand(1000, 3) * 0.8 + 0.1) * 255).astype(np.uint8)
self.is_stack = True # always loading images of same FOV
# if called with image, load it
# if image is not None:
# self.filename = image
# iopart._load_image(self, self.filename)
self.setAcceptDrops(True)
self.win.show()
self.show()
self.splitter2.addWidget(self.listView)
self.splitter2.addWidget(self.win)
self.mainLayout.addWidget(self.splitter2,0,1,1,3)
self.label_2 = QtWidgets.QLabel(self.page)
self.label_2.setObjectName("label_2")
self.gridLayout.addWidget(self.label_2, 7, 0, 1, 1)
self.brush_size = 3
self.BrushChoose = QtWidgets.QComboBox()
self.BrushChoose.addItems(["1", "3", "5", "7", "9", "11", "13", "15", "17", "19"])
self.BrushChoose.currentIndexChanged.connect(self.brush_choose)
self.gridLayout.addWidget(self.BrushChoose, 7, 1, 1, 1)
# turn on single stroke mode
self.sstroke_On = True
self.SSCheckBox = QtWidgets.QCheckBox(self.page)
self.SSCheckBox.setObjectName("SSCheckBox")
self.SSCheckBox.setChecked(True)
self.SSCheckBox.toggled.connect(self.toggle_sstroke)
self.gridLayout.addWidget(self.SSCheckBox, 8, 0, 1, 1)
self.eraser_button = QtWidgets.QCheckBox(self.page)
self.eraser_button.setObjectName("Edit mask")
self.eraser_button.setChecked(False)
self.eraser_button.toggled.connect(self.eraser_model_change)
self.eraser_button.setToolTip("Right-click to add pixels\nShift+Right-click to delete pixels")
self.gridLayout.addWidget(self.eraser_button, 9, 0, 1, 1)
self.CHCheckBox = QtWidgets.QCheckBox(self.page)
self.CHCheckBox.setObjectName("CHCheckBox")
self.CHCheckBox.toggled.connect(self.cross_hairs)
self.gridLayout.addWidget(self.CHCheckBox, 10, 0, 1, 1)
self.MCheckBox = QtWidgets.QCheckBox(self.page)
self.MCheckBox.setChecked(True)
self.MCheckBox.setObjectName("MCheckBox")
self.MCheckBox.setChecked(True)
self.MCheckBox.toggled.connect(self.toggle_masks)
self.gridLayout.addWidget(self.MCheckBox, 11, 0, 1, 1)
self.OCheckBox = QtWidgets.QCheckBox(self.page)
self.outlinesOn = True
self.OCheckBox.setChecked(True)
self.OCheckBox.setObjectName("OCheckBox")
self.OCheckBox.toggled.connect(self.toggle_masks)
self.gridLayout.addWidget(self.OCheckBox, 12, 0, 1, 1)
self.scale_on = True
self.SCheckBox = QtWidgets.QCheckBox(self.page)
self.SCheckBox.setObjectName("SCheckBox")
self.SCheckBox.setChecked(True)
self.SCheckBox.toggled.connect(self.toggle_scale)
self.gridLayout.addWidget(self.SCheckBox, 13, 0, 1, 1)
self.autosaveOn = True
self.ASCheckBox = QtWidgets.QCheckBox(self.page)
self.ASCheckBox.setObjectName("ASCheckBox")
self.ASCheckBox.setChecked(True)
self.ASCheckBox.toggled.connect(self.toggle_autosave)
self.ASCheckBox.setToolTip("If ON, masks/npy/list will be autosaved")
self.gridLayout.addWidget(self.ASCheckBox, 14, 0, 1, 1)
spacerItem = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding)
self.gridLayout.addItem(spacerItem, 15, 0, 1, 2)
# self.eraser_combobox = QtWidgets.QComboBox()
# self.eraser_combobox.addItems(["Pixal delete", "Pixal add"])
# self.gridLayout.addWidget(self.eraser_combobox, 8, 1, 1, 1)
self.RGBChoose = guiparts.RGBRadioButtons(self, 3, 1)
self.RGBDropDown = QtGui.QComboBox()
self.RGBDropDown.addItems(["rgb", "gray", "spectral", "red", "green", "blue"])
self.RGBDropDown.currentIndexChanged.connect(self.color_choose)
self.gridLayout.addWidget(self.RGBDropDown, 3, 0, 1, 1)
self.saturation_label = QtWidgets.QLabel("Saturation")
self.gridLayout.addWidget(self.saturation_label, 0, 0, 1, 1)
self.autobtn = QtGui.QCheckBox('Auto-adjust')
self.autobtn.setChecked(True)
self.autobtn.toggled.connect(self.toggle_autosaturation)
self.gridLayout.addWidget(self.autobtn, 0, 1, 1, 1)
self.currentZ = 0
self.zpos = QtGui.QLineEdit()
self.zpos.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
self.zpos.setText(str(self.currentZ))
self.zpos.returnPressed.connect(self.compute_scale)
self.zpos.setFixedWidth(20)
# self.gridLayout.addWidget(self.zpos, 0, 2, 1, 1)
self.slider = guiparts.RangeSlider(self)
self.slider.setMaximum(255)
self.slider.setMinimum(0)
self.slider.setHigh(255)
self.slider.setLow(0)
self.gridLayout.addWidget(self.slider, 2, 0, 1, 4)
self.slider.setObjectName("rangeslider")
self.page_2 = QtWidgets.QWidget()
self.page_2.setFixedWidth(340)
self.page_2.setObjectName("page_2")
self.gridLayout_2 = QtWidgets.QGridLayout(self.page_2)
self.gridLayout_2.setContentsMargins(0, 0, 0, 0)
self.gridLayout_2.setObjectName("gridLayout_2")
page2_l = 0
self.useGPU = QtWidgets.QCheckBox(self.page_2)
self.useGPU.setObjectName("useGPU")
self.gridLayout_2.addWidget(self.useGPU, page2_l, 0, 1, 1)
self.check_gpu()
page2_l += 1
self.label_4 = QtWidgets.QLabel(self.page_2)
self.label_4.setObjectName("label_4")
self.gridLayout_2.addWidget(self.label_4, page2_l, 0, 1, 1)
self.ModelChoose = QtWidgets.QComboBox(self.page_2)
self.ModelChoose.setObjectName("ModelChoose")
self.project_path = os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + os.path.sep + ".")
self.model_dir = os.path.join(self.project_path, 'assets', 'pretrained_models')
print('self.model_dir', self.model_dir)
self.ModelChoose.addItem("")
self.ModelChoose.addItem("")
self.ModelChoose.addItem("")
self.gridLayout_2.addWidget(self.ModelChoose, page2_l, 1, 1, 1)
page2_l += 1
self.label_5 = QtWidgets.QLabel(self.page_2)
self.label_5.setObjectName("label_5")
self.gridLayout_2.addWidget(self.label_5, page2_l, 0, 1, 1)
self.jCBChanToSegment = QtWidgets.QComboBox(self.page_2)
self.jCBChanToSegment.setObjectName("jCBChanToSegment")
self.jCBChanToSegment.addItems(["gray", "red", "green", "blue"])
self.jCBChanToSegment.setCurrentIndex(0)
self.gridLayout_2.addWidget(self.jCBChanToSegment, page2_l, 1, 1, 1)
page2_l += 1
self.label_6 = QtWidgets.QLabel(self.page_2)
self.label_6.setObjectName("label_6")
self.gridLayout_2.addWidget(self.label_6, page2_l, 0, 1, 1)
self.jCBChan2 = QtWidgets.QComboBox(self.page_2)
self.jCBChan2.setObjectName("jCBChan2")
self.jCBChan2.addItems(["none", "red", "green", "blue"])
self.jCBChan2.setCurrentIndex(0)
self.gridLayout_2.addWidget(self.jCBChan2, page2_l, 1, 1, 1)
page2_l += 1
self.model_choose_btn = QtWidgets.QPushButton("Model file")
self.model_choose_btn.clicked.connect(self.model_file_dir_choose)
self.gridLayout_2.addWidget(self.model_choose_btn, page2_l, 0, 1, 1)
self.model_choose_btn = QtWidgets.QPushButton("Reset pre-trained")
self.model_choose_btn.clicked.connect(self.reset_pretrain_model)
self.gridLayout_2.addWidget(self.model_choose_btn, page2_l, 1, 1, 1)
page2_l += 1
self.label_null = QtWidgets.QLabel("")
self.gridLayout_2.addWidget(self.label_null, page2_l, 0, 1, 1)
slider_image_path = self.now_pyfile_path + '/assets/slider_handle.png'
self.sliderSheet = [
'QSlider::groove:vertical {',
'background-color: #D3D3D3;',
'position: absolute;',
'left: 4px; right: 4px;',
'}',
'',
'QSlider::groove:horizontal{',
'background-color:#D3D3D3;',
'position: absolute;',
'top: 4px; bottom: 4px;',
'}',
'',
'QSlider::handle:vertical {',
'height: 10px;',
'background-color: {0:s};'.format('#A9A9A9'),
'margin: 0 -4px;',
'}',
'',
'QSlider::handle:horizontal{',
'width: 10px;',
'border-image: url({0:s});'.format(slider_image_path),
'margin: -4px 0px -4px 0px;',
'}',
'QSlider::sub-page:horizontal',
'{',
'background-color: {0:s};'.format('#A9A9A9'),
'}',
'',
'QSlider::add-page {',
'background-color: {0:s};'.format('#D3D3D3'),
'}',
'',
'QSlider::sub-page {',
'background-color: {0:s};'.format('#D3D3D3'),
'}',
]
page2_l += 1
self.label_seg = QtWidgets.QLabel("Run seg for image in window")
self.gridLayout_2.addWidget(self.label_seg, page2_l, 0, 1, 4)
self.label_seg.setObjectName('label_seg')
page2_l += 1
self.label_3 = QtWidgets.QLabel(self.page_2)
self.label_3.setObjectName("label_3")
self.gridLayout_2.addWidget(self.label_3, page2_l, 0, 1, 4)
page2_l += 1
self.prev_selected = 0
self.diameter = 30
# self.Diameter = QtWidgets.QSpinBox(self.page_2)
self.Diameter = QtWidgets.QLineEdit(self.page_2)
self.Diameter.setObjectName("Diameter")
self.Diameter.setText(str(self.diameter))
self.Diameter.setFixedWidth(100)
self.Diameter.editingFinished.connect(self.compute_scale)
self.gridLayout_2.addWidget(self.Diameter, page2_l, 0, 1, 2)
self.SizeButton = QtWidgets.QPushButton(self.page_2)
self.SizeButton.setObjectName("SizeButton")
self.gridLayout_2.addWidget(self.SizeButton, page2_l, 1, 1, 1)
self.SizeButton.clicked.connect(self.calibrate_size)
self.SizeButton.setEnabled(False)
page2_l += 1
self.label_mode = QtWidgets.QLabel("Inference mode")
self.gridLayout_2.addWidget(self.label_mode, page2_l, 0, 1, 1)
self.NetAvg = QtWidgets.QComboBox(self.page_2)
self.NetAvg.setObjectName("NetAvg")
self.NetAvg.addItems(["run 1 net (fast)", "+ resample (slow)"])
self.gridLayout_2.addWidget(self.NetAvg, page2_l, 1, 1, 1)
page2_l += 1
self.invert = QtWidgets.QCheckBox(self.page_2)
self.invert.setObjectName("invert")
self.gridLayout_2.addWidget(self.invert, page2_l, 0, 1, 1)
page2_l += 1
self.ModelButton = QtWidgets.QPushButton(' Run segmentation ')
self.ModelButton.setObjectName("runsegbtn")
self.ModelButton.clicked.connect(self.compute_model)
self.gridLayout_2.addWidget(self.ModelButton, page2_l, 0, 1, 2)
self.ModelButton.setEnabled(False)
page2_l += 1
self.label_7 = QtWidgets.QLabel(self.page_2)
self.label_7.setObjectName("label_7")
self.gridLayout_2.addWidget(self.label_7, page2_l, 0, 1, 1)
self.threshold = 0.4
self.threshslider = QtWidgets.QSlider(self.page_2)
self.threshslider.setOrientation(QtCore.Qt.Horizontal)
self.threshslider.setObjectName("threshslider")
self.threshslider.setMinimum(1.0)
self.threshslider.setMaximum(30.0)
self.threshslider.setValue(31 - 4)
self.threshslider.valueChanged.connect(self.compute_cprob)
self.threshslider.setEnabled(False)
self.threshslider.setStyleSheet('\n'.join(self.sliderSheet))
self.gridLayout_2.addWidget(self.threshslider, page2_l, 1, 1, 1)
self.threshslider.setToolTip("Value: " + str(self.threshold))
page2_l += 1
self.label_8 = QtWidgets.QLabel(self.page_2)
self.label_8.setObjectName("label_8")
self.gridLayout_2.addWidget(self.label_8, page2_l, 0, 1, 1)
self.probslider = QtWidgets.QSlider(self.page_2)
self.probslider.setOrientation(QtCore.Qt.Horizontal)
self.probslider.setObjectName("probslider")
self.probslider.setStyleSheet('\n'.join(self.sliderSheet))
self.gridLayout_2.addWidget(self.probslider, page2_l, 1, 1, 1)
self.probslider.setMinimum(-6.0)
self.probslider.setMaximum(6.0)
self.probslider.setValue(0.0)
self.cellprob = 0.5
self.probslider.valueChanged.connect(self.compute_cprob)
self.probslider.setEnabled(False)
self.probslider.setToolTip("Value: " + str(self.cellprob))
page2_l += 1
self.label_batchseg = QtWidgets.QLabel("Batch segmentation")
self.label_batchseg.setObjectName('label_batchseg')
self.gridLayout_2.addWidget(self.label_batchseg, page2_l, 0, 1, 4)
page2_l += 1
self.label_bz = QtWidgets.QLabel("Batch size")
self.gridLayout_2.addWidget(self.label_bz, page2_l, 0, 1, 1)
self.bz_line = QtWidgets.QLineEdit()
self.bz_line.setPlaceholderText('Default: 8')
self.bz_line.setFixedWidth(120)
self.gridLayout_2.addWidget(self.bz_line, page2_l, 1, 1, 1)
page2_l += 1
self.dataset_inference_bnt = QtWidgets.QPushButton("Data path")
self.gridLayout_2.addWidget(self.dataset_inference_bnt, page2_l, 0, 1, 1)
self.dataset_inference_bnt.clicked.connect(self.batch_inference_dir_choose)
self.batch_inference_bnt = QtWidgets.QPushButton("Run batch")
self.batch_inference_bnt.setObjectName("binferbnt")
self.batch_inference_bnt.clicked.connect(self.batch_inference)
self.gridLayout_2.addWidget(self.batch_inference_bnt, page2_l, 1, 1, 1)
self.batch_inference_bnt.setEnabled(False)
page2_l += 1
self.label_getsingle = QtWidgets.QLabel("Get single instance")
self.label_getsingle.setObjectName('label_getsingle')
self.gridLayout_2.addWidget(self.label_getsingle, page2_l,0,1,2)
page2_l += 1
self.single_dir_bnt = QtWidgets.QPushButton("Data path")
self.single_dir_bnt.clicked.connect(self.single_dir_choose)
self.gridLayout_2.addWidget(self.single_dir_bnt, page2_l,0,1,1)
self.single_cell_btn = QtWidgets.QPushButton("Run batch")
self.single_cell_btn.setObjectName('single_cell_btn')
self.single_cell_btn.clicked.connect(self.get_single_cell)
self.gridLayout_2.addWidget(self.single_cell_btn, page2_l,1,1,1)
self.single_cell_btn.setEnabled(False)
page2_l += 1
spacerItem2 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding)
self.gridLayout_2.addItem(spacerItem2, page2_l, 0, 1, 2)
self.page_3 = QtWidgets.QWidget()
self.page_3.setFixedWidth(340)
self.page_3.setObjectName("page_3")
self.progress = QtWidgets.QProgressBar()
self.progress.setProperty("value", 0)
self.progress.setAlignment(QtCore.Qt.AlignCenter)
self.progress.setObjectName("progress")
self.gridLayout_3 = QtWidgets.QGridLayout(self.page_3)
self.gridLayout_3.setContentsMargins(0, 0, 0, 0)
self.gridLayout_3.setObjectName("gridLayout_3")
self.ftuseGPU = QtWidgets.QCheckBox("Use GPU")
self.ftuseGPU.setObjectName("ftuseGPU")
self.gridLayout_3.addWidget(self.ftuseGPU, 0, 0, 1, 2)
self.check_ftgpu()
self.ftdirbtn = QtWidgets.QPushButton("Dataset path")
self.ftdirbtn.clicked.connect(self.fine_tune_dir_choose)
self.gridLayout_3.addWidget(self.ftdirbtn, 0, 2, 1, 2)
self.label_10 = QtWidgets.QLabel("Model architecture")
self.gridLayout_3.addWidget(self.label_10, 1, 0, 1, 2)
self.ftmodelchooseBnt = QtWidgets.QComboBox()
self.ftmodelchooseBnt.addItems(["scellseg", "cellpose", "hover"])
self.gridLayout_3.addWidget(self.ftmodelchooseBnt, 1, 2, 1, 2)
self.label_11 = QtWidgets.QLabel("Chan to segment")
self.gridLayout_3.addWidget(self.label_11, 2, 0, 1, 2)
self.chan1chooseBnt = QtWidgets.QComboBox()
self.chan1chooseBnt.addItems(["gray", "red", "green", "blue"])
self.chan1chooseBnt.setCurrentIndex(0)
self.gridLayout_3.addWidget(self.chan1chooseBnt, 2, 2, 1, 2)
self.label_12 = QtWidgets.QLabel("Chan2 (optional)")
self.gridLayout_3.addWidget(self.label_12, 3, 0, 1, 2)
self.chan2chooseBnt = QtWidgets.QComboBox()
self.chan2chooseBnt.addItems(["none", "red", "green", "blue"])
self.chan2chooseBnt.setCurrentIndex(0)
self.gridLayout_3.addWidget(self.chan2chooseBnt, 3, 2, 1, 2)
self.label_13 = QtWidgets.QLabel("Fine-tune strategy")
self.gridLayout_3.addWidget(self.label_13, 4, 0, 1, 2)
self.stmodelchooseBnt = QtWidgets.QComboBox()
self.stmodelchooseBnt.addItems(["contrastive", "classic"])
self.gridLayout_3.addWidget(self.stmodelchooseBnt, 4, 2, 1, 2)
self.label_14 = QtWidgets.QLabel("Epoch")
self.gridLayout_3.addWidget(self.label_14, 5, 0, 1, 2)
self.epoch_line = QtWidgets.QLineEdit()
self.epoch_line.setPlaceholderText('Default: 100')
self.gridLayout_3.addWidget(self.epoch_line, 5, 2, 1, 2)
self.label_ftbz = QtWidgets.QLabel("Batch size")
self.gridLayout_3.addWidget(self.label_ftbz, 6, 0, 1, 2)
self.ftbz_line = QtWidgets.QLineEdit()
self.ftbz_line.setPlaceholderText('Default: 8')
self.gridLayout_3.addWidget(self.ftbz_line, 6, 2, 1, 2)
self.ftbnt = QtWidgets.QPushButton("Start fine-tuning")
self.ftbnt.setObjectName('ftbnt')
self.ftbnt.clicked.connect(self.fine_tune)
self.gridLayout_3.addWidget(self.ftbnt, 7, 0, 1, 4)
self.ftbnt.setEnabled(False)
spacerItem3 = QtWidgets.QSpacerItem(20, 320, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding)
self.gridLayout_3.addItem(spacerItem3, 8, 0, 1, 1)
#initialize scroll size
self.scroll = QtGui.QScrollBar(QtCore.Qt.Horizontal)
# self.scroll.setMaximum(10)
# self.scroll.valueChanged.connect(self.move_in_Z)
# self.gridLayout_3.addWidget(self.scroll)
spacerItem2 = QtWidgets.QSpacerItem(20, 320, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding)
self.gridLayout_3.addItem(spacerItem2)
self.toolBox.addItem(self.page, "")
self.toolBox.addItem(self.page_3, "")
self.toolBox.addItem(self.page_2, "")
self.verticalLayout_2.addWidget(self.splitter)
MainWindow.setCentralWidget(self.centralwidget)
self.retranslateUi(MainWindow)
self.toolBox.setCurrentIndex(2)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
self.centralwidget.setFocusPolicy(QtCore.Qt.StrongFocus)
self.reset()
def show_menu(self, point):
# print(point.x())
# item = self.listView.itemAt(point)
# print(item)
temp_cell_idx = self.listView.rowAt(point.y())
self.list_select_cell(temp_cell_idx+1)
# print(self.myCellList[temp_cell_idx])
if self.listView.rowAt(point.y()) >= 0:
self.contextMenu = QtWidgets.QMenu()
self.actionA = QtGui.QAction("Delete this cell", self)
self.actionB = QtGui.QAction("Edit this cell", self)
self.contextMenu.addAction(self.actionA)
self.contextMenu.addAction(self.actionB)
self.contextMenu.popup(QtGui.QCursor.pos())
self.actionA.triggered.connect(lambda: self.remove_cell(temp_cell_idx + 1))
self.actionB.triggered.connect(lambda: self.edit_cell(temp_cell_idx + 1))
self.contextMenu.show()
def edit_cell(self, index):
self.select_cell(index)
self.eraser_button.setChecked(True)
self.toolBox.setCurrentIndex(0)
def retranslateUi(self, MainWindow):
_translate = QtCore.QCoreApplication.translate
MainWindow.setWindowTitle(_translate("MainWindow", "Scellseg"))
self.CHCheckBox.setText(_translate("MainWindow", "Crosshair on [C]"))
self.MCheckBox.setText(_translate("MainWindow", "Masks on [X]"))
self.label_2.setText(_translate("MainWindow", "Brush size"))
self.OCheckBox.setText(_translate("MainWindow", "Outlines on [Z]"))
# self.ServerButton.setText(_translate("MainWindow", "send manual seg. to server"))
self.toolBox.setItemText(self.toolBox.indexOf(self.page), _translate("MainWindow", "View and Draw"))
self.SizeButton.setText(_translate("MainWindow", "Calibrate diam"))
self.label_3.setText(_translate("MainWindow", "Cell diameter (pixels):"))
self.useGPU.setText(_translate("MainWindow", "Use GPU"))
self.SCheckBox.setText(_translate("MainWindow", "Scale disk on [S]"))
self.ASCheckBox.setText(_translate("MainWindow", "Autosave [P]"))
self.SSCheckBox.setText(_translate("MainWindow", "Single stroke"))
self.eraser_button.setText(_translate("MainWindow", "Edit mask [E]"))
self.ModelChoose.setItemText(0, _translate("MainWindow", "scellseg"))
self.ModelChoose.setItemText(1, _translate("MainWindow", "cellpose"))
self.ModelChoose.setItemText(2, _translate("MainWindow", "hover"))
self.invert.setText(_translate("MainWindow", "Invert grayscale"))
self.label_4.setText(_translate("MainWindow", "Model architecture"))
self.label_5.setText(_translate("MainWindow", "Chan to segment"))
self.label_6.setText(_translate("MainWindow", "Chan2 (optional)"))
self.toolBox.setItemText(self.toolBox.indexOf(self.page_2), _translate("MainWindow", "Inference"))
self.label_7.setText(_translate("MainWindow", "Model match TH"))
self.label_8.setText(_translate("MainWindow", "Cell prob TH"))
self.toolBox.setItemText(self.toolBox.indexOf(self.page_3), _translate("MainWindow", "Fine-tune"))
# self.menuFile.setTitle(_translate("MainWindow", "File"))
# self.menuEdit.setTitle(_translate("MainWindow", "Edit"))
# self.menuHelp.setTitle(_translate("MainWindow", "Help"))
self.ImFolder = ''
self.ImNameSet = []
self.CurImId = 0
self.CurFolder = os.getcwd()
self.DefaultImFolder = self.CurFolder
def setWinTop(self):
print('get')
def OpenDirDropped(self, curFile=None):
# dir dropped callback func
if self.ImFolder != '':
self.ImNameSet = []
self.ImNameRowSet = os.listdir(self.ImFolder)
# print(self.ImNameRowSet)
for tmp in self.ImNameRowSet:
ext = os.path.splitext(tmp)[-1]
if ext in ['.png', '.jpg', '.jpeg', '.tif', '.tiff', '.jfif'] and '_mask' not in tmp:
self.ImNameSet.append(tmp)
self.ImNameSet.sort()
self.ImPath = self.ImFolder + r'/' + self.ImNameSet[0]
ImNameSetNosuffix = [os.path.splitext(imNameSeti)[0] for imNameSeti in self.ImNameSet]
# pix = QtGui.QPixmap(self.ImPath)
# self.ImShowLabel.setPixmap(pix)
if curFile is not None:
curFile = os.path.splitext(curFile)[0]
try:
self.CurImId = ImNameSetNosuffix.index(curFile)
print(self.CurImId)
except:
curFile = curFile.replace('_cp_masks', '')
curFile = curFile.replace('_masks', '')
self.CurImId = ImNameSetNosuffix.index(curFile)
print(self.CurImId)
return
# self.state_label.setText("", color='#FF6A56')
else:
self.CurImId = 0
iopart._load_image(self, filename=self.ImPath)
self.initialize_listView()
else:
print('Please Find Another File Folder')
def OpenDirBntClicked(self):
# dir choosing callback function
self.ImFolder = QtWidgets.QFileDialog.getExistingDirectory(None, "select folder", self.DefaultImFolder)
if self.ImFolder != '':
self.ImNameSet = []
self.ImNameRowSet = os.listdir(self.ImFolder)
# print(self.ImNameRowSet)
for tmp in self.ImNameRowSet:
ext = os.path.splitext(tmp)[-1]
if ext in ['.png', '.jpg', '.jpeg', '.tif', '.tiff', '.jfif'] and '_mask' not in tmp:
self.ImNameSet.append(tmp)
self.ImNameSet.sort()
print(self.ImNameSet)
self.ImPath = self.ImFolder + r'/' + self.ImNameSet[0]
# pix = QtGui.QPixmap(self.ImPath)
# self.ImShowLabel.setPixmap(pix)
self.CurImId = 0
iopart._load_image(self, filename=self.ImPath)
self.initialize_listView()
else:
print('Please Find Another File Folder')
def PreImBntClicked(self):
self.auto_save()
# show previous image
self.ImFolder = self.ImFolder
self.ImNameSet = self.ImNameSet
self.CurImId = self.CurImId
self.ImNum = len(self.ImNameSet)
print(self.ImFolder, self.ImNameSet)
self.CurImId = self.CurImId - 1
if self.CurImId >= 0: # 第一张图片没有前一张
self.ImPath = self.ImFolder + r'/' + self.ImNameSet[self.CurImId]
iopart._load_image(self, filename=self.ImPath)
self.initialize_listView()
if self.CurImId < 0:
self.CurImId = 0
self.state_label.setText("This is the first image", color='#FF6A56')
def NextImBntClicked(self):
self.auto_save()
# show next image
self.ImFolder = self.ImFolder
self.ImNameSet = self.ImNameSet
self.CurImId = self.CurImId
self.ImNum = len(self.ImNameSet)
if self.CurImId < self.ImNum - 1:
self.ImPath = self.ImFolder + r'/' + self.ImNameSet[self.CurImId + 1]
iopart._load_image(self, filename=self.ImPath)
self.initialize_listView()
self.CurImId = self.CurImId + 1
else:
self.state_label.setText("This is the last image", color='#FF6A56')
def eraser_model_change(self):
if self.eraser_button.isChecked() == True:
self.outlinesOn = False
self.OCheckBox.setChecked(False)
# self.OCheckBox.setEnabled(False)
QtWidgets.QApplication.setOverrideCursor(QtCore.Qt.CrossCursor)
# self.cur_size = self.brush_size * 6
# cursor = Qt.QPixmap("./assets/eraser.png")
# cursor_scaled = cursor.scaled(self.cur_size, self.cur_size)
# cursor_set = Qt.QCursor(cursor_scaled, self.cur_size/2, self.cur_size/2)
# QtWidgets.QApplication.setOverrideCursor(cursor_set)
self.update_plot()
else:
QtWidgets.QApplication.setOverrideCursor(QtCore.Qt.CrossCursor)
def showChoosen(self, item):
temp_cell_idx = int(item.row())
self.list_select_cell(int(temp_cell_idx) + 1)
def save_cell_list(self):
self.listView.selectAll()
self.myCellList = []
for item in self.listView.selectedIndexes():
data = item.data()
self.myCellList.append(data)
self.cell_list_name = os.path.splitext(self.filename)[0] + "_instance_list.txt"
np.savetxt(self.cell_list_name, np.array(self.myCellList), fmt="%s")
self.listView.clearSelection()
def save_cell_list_menu(self):
self.listView.selectAll()
self.myCellList = []
for item in self.listView.selectedIndexes():
data = item.data()
self.myCellList.append(data)
self.cell_list_name = os.path.splitext(self.filename)[0] + "_instance_list.txt"
np.savetxt(self.cell_list_name, np.array(self.myCellList), fmt="%s")
self.state_label.setText("Saved outlines", color='#39B54A')
self.listView.clearSelection()
def help_window(self):
HW = guiparts.HelpWindow(self)
HW.show()
def gui_window(self):
EG = guiparts.ExampleGUI(self)
EG.show()
def toggle_autosave(self):
if self.ASCheckBox.isChecked():
self.autosaveOn = True
else:
self.autosaveOn = False
print('self.autosaveOn', self.autosaveOn)
def toggle_sstroke(self):
if self.SSCheckBox.isChecked():
self.sstroke_On = True
else:
self.sstroke_On = False
print('self.sstroke_On', self.sstroke_On)
def toggle_autosaturation(self):
if self.autobtn.isChecked():
self.compute_saturation()
self.update_plot()
def cross_hairs(self):
if self.CHCheckBox.isChecked():
self.p0.addItem(self.vLine, ignoreBounds=True)
self.p0.addItem(self.hLine, ignoreBounds=True)
else:
self.p0.removeItem(self.vLine)
self.p0.removeItem(self.hLine)
def plot_clicked(self, event):
if event.double():
if event.button() == QtCore.Qt.LeftButton:
print("will initialize the range")
if (event.modifiers() != QtCore.Qt.ShiftModifier and
event.modifiers() != QtCore.Qt.AltModifier):
try:
self.p0.setYRange(0,self.Ly+self.pr)
except:
self.p0.setYRange(0,self.Ly)
self.p0.setXRange(0,self.Lx)
def mouse_moved(self, pos):
# print('moved')
items = self.win.scene().items(pos)
for x in items:
if x == self.p0:
mousePoint = self.p0.mapSceneToView(pos)
if self.CHCheckBox.isChecked():
self.vLine.setPos(mousePoint.x())
self.hLine.setPos(mousePoint.y())
# else:
# QtWidgets.QApplication.restoreOverrideCursor()
# QtWidgets.QApplication.setOverrideCursor(QtCore.Qt.DefaultCursor)
def color_choose(self):
self.color = self.RGBDropDown.currentIndex()
self.view = 0
self.RGBChoose.button(self.view).setChecked(True)
self.update_plot()
def update_ztext(self):
zpos = self.currentZ
try:
zpos = int(self.zpos.text())
except:
print('ERROR: zposition is not a number')
self.currentZ = max(0, min(self.NZ - 1, zpos))
self.zpos.setText(str(self.currentZ))
self.scroll.setValue(self.currentZ)
def calibrate_size(self):
model_type = self.ModelChoose.currentText()
pretrained_model = os.path.join(self.model_dir, model_type)
self.initialize_model(pretrained_model=pretrained_model, gpu=self.useGPU.isChecked(),
model_type=model_type)
diams, _ = self.model.sz.eval(self.stack[self.currentZ].copy(), invert=self.invert.isChecked(),
channels=self.get_channels(), progress=self.progress)
diams = np.maximum(5.0, diams)
print('estimated diameter of cells using %s model = %0.1f pixels' %
(self.current_model, diams))
self.state_label.setText('Estimated diameter of cells using %s model = %0.1f pixels' %
(self.current_model, diams), color='#969696')
self.Diameter.setText('%0.1f'%diams)
self.diameter = diams
self.compute_scale()
self.progress.setValue(100)
def enable_buttons(self):
# self.X2Up.setEnabled(True)
# self.X2Down.setEnabled(True)
self.ModelButton.setEnabled(True)
self.SizeButton.setEnabled(True)
self.saveSet.setEnabled(True)
self.savePNG.setEnabled(True)
self.saveOutlines.setEnabled(True)
self.saveCellList.setEnabled(True)
self.saveAll.setEnabled(True)
self.loadMasks.setEnabled(True)
self.loadManual.setEnabled(True)
self.loadCellList.setEnabled(True)
self.toggle_mask_ops()
self.update_plot()
self.setWindowTitle('Scellseg @ ' + self.filename)
def add_set(self):
if len(self.current_point_set) > 0:
# print(self.current_point_set)
# print(np.array(self.current_point_set).shape)
self.current_point_set = np.array(self.current_point_set)
while len(self.strokes) > 0:
self.remove_stroke(delete_points=False)
if len(self.current_point_set) > 8:
col_rand = np.random.randint(1000)
color = self.colormap[col_rand, :3]
median = self.add_mask(points=self.current_point_set, color=color)
if median is not None:
self.removed_cell = []
self.toggle_mask_ops()
self.cellcolors.append(color)
self.ncells += 1
self.add_list_item()
self.ismanual = np.append(self.ismanual, True)
# if self.NZ == 1:
# # only save after each cell if single image
# iopart._save_sets(self)
self.current_stroke = []
self.strokes = []
self.current_point_set = []
self.update_plot()
def add_mask(self, points=None, color=None):
# loop over z values
median = []
if points.shape[1] < 3:
points = np.concatenate((np.zeros((points.shape[0], 1), np.int32), points), axis=1)
zdraw = np.unique(points[:, 0])
zrange = np.arange(zdraw.min(), zdraw.max() + 1, 1, int)
zmin = zdraw.min()
pix = np.zeros((2, 0), np.uint16)
mall = np.zeros((len(zrange), self.Ly, self.Lx), np.bool)
k = 0
for z in zdraw:
iz = points[:, 0] == z
vr = points[iz, 1]
vc = points[iz, 2]
# get points inside drawn points
mask = np.zeros((np.ptp(vr) + 4, np.ptp(vc) + 4), np.uint8)
pts = np.stack((vc - vc.min() + 2, vr - vr.min() + 2), axis=-1)[:, np.newaxis, :]
mask = cv2.fillPoly(mask, [pts], (255, 0, 0))
ar, ac = np.nonzero(mask)
ar, ac = ar + vr.min() - 2, ac + vc.min() - 2
# get dense outline
contours = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
pvc, pvr = contours[-2][0].squeeze().T
vr, vc = pvr + vr.min() - 2, pvc + vc.min() - 2
# concatenate all points
ar, ac = np.hstack((np.vstack((vr, vc)), np.vstack((ar, ac))))
# if these pixels are overlapping with another cell, reassign them
ioverlap = self.cellpix[z][ar, ac] > 0
if (~ioverlap).sum() < 8:
print('ERROR: cell too small without overlaps, not drawn')
return None
elif ioverlap.sum() > 0:
ar, ac = ar[~ioverlap], ac[~ioverlap]
# compute outline of new mask
mask = np.zeros((np.ptp(ar) + 4, np.ptp(ac) + 4), np.uint8)
mask[ar - ar.min() + 2, ac - ac.min() + 2] = 1
contours = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
pvc, pvr = contours[-2][0].squeeze().T
vr, vc = pvr + ar.min() - 2, pvc + ac.min() - 2
self.draw_mask(z, ar, ac, vr, vc, color)
median.append(np.array([np.median(ar), np.median(ac)]))
mall[z - zmin, ar, ac] = True
pix = np.append(pix, np.vstack((ar, ac)), axis=-1)
mall = mall[:, pix[0].min():pix[0].max() + 1, pix[1].min():pix[1].max() + 1].astype(np.float32)
ymin, xmin = pix[0].min(), pix[1].min()
if len(zdraw) > 1:
mall, zfill = interpZ(mall, zdraw - zmin)
for z in zfill:
mask = mall[z].copy()
ar, ac = np.nonzero(mask)
ioverlap = self.cellpix[z + zmin][ar + ymin, ac + xmin] > 0
if (~ioverlap).sum() < 5:
print('WARNING: stroke on plane %d not included due to overlaps' % z)
elif ioverlap.sum() > 0:
mask[ar[ioverlap], ac[ioverlap]] = 0
ar, ac = ar[~ioverlap], ac[~ioverlap]
# compute outline of mask
outlines = utils.masks_to_outlines(mask)
vr, vc = np.nonzero(outlines)
vr, vc = vr + ymin, vc + xmin
ar, ac = ar + ymin, ac + xmin
self.draw_mask(z + zmin, ar, ac, vr, vc, color)
self.zdraw.append(zdraw)
return median
def move_in_Z(self):
if self.loaded:
self.currentZ = min(self.NZ, max(0, int(self.scroll.value())))
self.zpos.setText(str(self.currentZ))
self.update_plot()
def make_viewbox(self):
# intialize the main viewport widget
# print("making viewbox")
self.p0 = guiparts.ViewBoxNoRightDrag(
parent=self,
lockAspect=True,
name="plot1",
border=[100, 100, 100],
invertY=True
)
# self.p0.setBackgroundColor(color='#292929')
self.brush_size = 3
self.win.addItem(self.p0, 0, 0)
self.p0.setMenuEnabled(False)
self.p0.setMouseEnabled(x=True, y=True)
self.img = pg.ImageItem(viewbox=self.p0, parent=self, axisOrder='row-major')
self.img.autoDownsample = False
# self.null_image = np.ones((200,200))
# self.img.setImage(self.null_image)
self.layer = guiparts.ImageDraw(viewbox=self.p0, parent=self)
self.layer.setLevels([0, 255])
self.scale = pg.ImageItem(viewbox=self.p0, parent=self)
self.scale.setLevels([0, 255])
self.p0.scene().contextMenuItem = self.p0
# self.p0.setMouseEnabled(x=False,y=False)
self.Ly, self.Lx = 512, 512
self.p0.addItem(self.img)
self.p0.addItem(self.layer)
self.p0.addItem(self.scale)
# guiparts.make_quadrants(self)
def get_channels(self):
channels = [self.jCBChanToSegment.currentIndex(), self.jCBChan2.currentIndex()]
return channels
def compute_saturation(self):
# compute percentiles from stack
self.saturation = []
self.slider._low = np.percentile(self.stack[0].astype(np.float32), 1)
self.slider._high = np.percentile(self.stack[0].astype(np.float32), 99)
for n in range(len(self.stack)):
print('n,', n)
self.saturation.append([np.percentile(self.stack[n].astype(np.float32), 1),
np.percentile(self.stack[n].astype(np.float32), 99)])
def keyReleaseEvent(self, event):
# print('self.loaded', self.loaded)
if self.loaded:
# self.p0.setMouseEnabled(x=True, y=True)
if (event.modifiers() != QtCore.Qt.ControlModifier and
event.modifiers() != QtCore.Qt.ShiftModifier and
event.modifiers() != QtCore.Qt.AltModifier) and not self.in_stroke:
updated = False
if len(self.current_point_set) > 0:
if event.key() == QtCore.Qt.Key_Return:
self.add_set()
if self.NZ > 1:
if event.key() == QtCore.Qt.Key_Left:
self.currentZ = max(0, self.currentZ - 1)
self.zpos.setText(str(self.currentZ))
elif event.key() == QtCore.Qt.Key_Right:
self.currentZ = min(self.NZ - 1, self.currentZ + 1)
self.zpos.setText(str(self.currentZ))
else:
if event.key() == QtCore.Qt.Key_M:
self.MCheckBox.toggle()
if event.key() == QtCore.Qt.Key_O:
self.OCheckBox.toggle()
if event.key() == QtCore.Qt.Key_C:
self.CHCheckBox.toggle()
if event.key() == QtCore.Qt.Key_S:
self.SCheckBox.toggle()
if event.key() == QtCore.Qt.Key_E:
self.eraser_button.toggle()
self.toolBox.setCurrentIndex(0)
if event.key() == QtCore.Qt.Key_P:
self.ASCheckBox.toggle()
if event.key() == QtCore.Qt.Key_PageDown:
self.view = (self.view + 1) % (len(self.RGBChoose.bstr))
print('self.view ', self.view)
self.RGBChoose.button(self.view).setChecked(True)
elif event.key() == QtCore.Qt.Key_PageUp:
self.view = (self.view - 1) % (len(self.RGBChoose.bstr))
print('self.view ', self.view)
self.RGBChoose.button(self.view).setChecked(True)
# can change background or stroke size if cell not finished
if event.key() == QtCore.Qt.Key_Up:
self.color = (self.color - 1) % (6)
print('self.color', self.color)
self.RGBDropDown.setCurrentIndex(self.color)
elif event.key() == QtCore.Qt.Key_Down:
self.color = (self.color + 1) % (6)
print('self.color', self.color)
self.RGBDropDown.setCurrentIndex(self.color)
if (event.key() == QtCore.Qt.Key_BracketLeft or
event.key() == QtCore.Qt.Key_BracketRight):
count = self.BrushChoose.count()
gci = self.BrushChoose.currentIndex()
if event.key() == QtCore.Qt.Key_BracketLeft:
gci = max(0, gci - 1)
else:
gci = min(count - 1, gci + 1)
self.BrushChoose.setCurrentIndex(gci)
self.brush_choose()
self.state_label.setText("Brush size: %s"%(2*gci+1), color='#969696')
if not updated:
self.update_plot()
elif event.modifiers() == QtCore.Qt.ControlModifier:
if event.key() == QtCore.Qt.Key_Z:
self.undo_action()
if event.key() == QtCore.Qt.Key_0:
self.clear_all()
def keyPressEvent(self, event):
if event.modifiers() == QtCore.Qt.ControlModifier:
if event.key() == QtCore.Qt.Key_1:
self.toolBox.setCurrentIndex(0)
if event.key() == QtCore.Qt.Key_2:
self.toolBox.setCurrentIndex(1)
if event.key() == QtCore.Qt.Key_3:
self.toolBox.setCurrentIndex(2)
if event.key() == QtCore.Qt.Key_Minus or event.key() == QtCore.Qt.Key_Equal:
self.p0.keyPressEvent(event)
def chanchoose(self, image):
if image.ndim > 2:
if self.jCBChanToSegment.currentIndex() == 0:
image = image.astype(np.float32).mean(axis=-1)[..., np.newaxis]
else:
chanid = [self.jCBChanToSegment.currentIndex() - 1]
if self.jCBChan2.currentIndex() > 0:
chanid.append(self.jCBChan2.currentIndex() - 1)
image = image[:, :, chanid].astype(np.float32)
return image
def initialize_model(self, gpu=False, pretrained_model=False, model_type='scellseg',
diam_mean=30., net_avg=False, device=None, nclasses=3,
residual_on=True, style_on=True, concatenation=False, update_step=1,
last_conv_on=True, attn_on=False, dense_on=False, style_scale_on=True,
task_mode='cellpose', model=None):
self.current_model = model_type
self.model = models.sCellSeg(gpu=gpu, pretrained_model=pretrained_model, model_type=model_type,
diam_mean=diam_mean, net_avg=net_avg, device=device, nclasses=nclasses,
residual_on=residual_on, style_on=style_on, concatenation=concatenation, update_step=update_step,
last_conv_on=last_conv_on, attn_on=attn_on, dense_on=dense_on, style_scale_on=style_scale_on,
task_mode=task_mode, model=model)
def set_compute_thread(self):
self.seg_thread = threading.Thread(target = self.compute_model)
self.seg_thread.setDeamon(True)
self.seg_thread.start()
def compute_model(self):
self.progress.setValue(0)
self.update_plot()
self.state_label.setText("Running...", color='#969696')
QtWidgets.qApp.processEvents() # force update gui
if True:
tic = time.time()
self.clear_all()
self.flows = [[], [], []]
pretrained_model = os.path.join(self.model_dir, self.ModelChoose.currentText())
self.initialize_model(pretrained_model=pretrained_model, gpu=self.useGPU.isChecked(),
model_type=self.ModelChoose.currentText())
print('using model %s' % self.current_model)
self.progress.setValue(10)
do_3D = False
if self.NZ > 1:
do_3D = True
data = self.stack.copy()
else:
data = self.stack[0].copy()
channels = self.get_channels()
# print(channels)
self.diameter = float(self.Diameter.text())
self.update_plot()
try:
# net_avg = self.NetAvg.currentIndex() == 0
resample = self.NetAvg.currentIndex() == 1 # we need modify from here
min_size = ((30. // 2) ** 2) * np.pi * 0.05
try:
finetune_model = self.model_file_path[0]
print('ft_model', finetune_model)
except:
finetune_model = None
# inference
masks, flows, _ = self.model.inference(finetune_model=finetune_model, net_avg=False,
query_images=data, channel=channels,
diameter=self.diameter,
resample=resample, flow_threshold=self.threshold,
cellprob_threshold=self.cellprob,
min_size=min_size, eval_batch_size=8,
postproc_mode=self.model.postproc_mode,
progress=self.progress)
self.state_label.setText(
'%d cells found with scellseg net in %0.3fs' % (
len(np.unique(masks)[1:]), time.time() - tic),
color='#39B54A')
# self.state_label.setStyleSheet("color:green;")
self.update_plot()
self.progress.setValue(75)
self.flows[0] = flows[0].copy()
self.flows[1] = (np.clip(utils.normalize99(flows[2].copy()), 0, 1) * 255).astype(np.uint8)
if not do_3D:
masks = masks[np.newaxis, ...]
self.flows[0] = transforms.resize_image(self.flows[0], masks.shape[-2], masks.shape[-1],
interpolation=cv2.INTER_NEAREST)
self.flows[1] = transforms.resize_image(self.flows[1], masks.shape[-2], masks.shape[-1])
if not do_3D:
self.flows[2] = np.zeros(masks.shape[1:], dtype=np.uint8)
self.flows = [self.flows[n][np.newaxis, ...] for n in range(len(self.flows))]
else:
self.flows[2] = (flows[1][0] / 10 * 127 + 127).astype(np.uint8)
if len(flows) > 2:
self.flows.append(flows[3])
self.flows.append(np.concatenate((flows[1], flows[2][np.newaxis, ...]), axis=0))
print()
self.progress.setValue(80)
z = 0
self.masksOn = True
self.outlinesOn = True
self.MCheckBox.setChecked(True)
self.OCheckBox.setChecked(True)
iopart._masks_to_gui(self, masks, outlines=None)
self.progress.setValue(100)
self.first_load_listView()
# self.toggle_server(off=True)
if not do_3D:
self.threshslider.setEnabled(True)
self.probslider.setEnabled(True)
self.masks_for_save = masks
except Exception as e:
print('NET ERROR: %s' % e)
self.progress.setValue(0)
return
else: # except Exception as e:
print('ERROR: %s' % e)
print('Finished inference')
def batch_inference(self):
self.progress.setValue(0)
# print('threshold', self.threshold, self.cellprob)
# self.update_plot()
if True:
tic = time.time()
self.clear_all()
model_type =self.ModelChoose.currentText()
pretrained_model = os.path.join(self.model_dir, model_type)
self.initialize_model(pretrained_model=pretrained_model, gpu=self.useGPU.isChecked(),
model_type=model_type)
print('using model %s' % self.current_model)
self.progress.setValue(10)
channels = self.get_channels()
self.diameter = float(self.Diameter.text())
try:
# net_avg = self.NetAvg.currentIndex() < 2
# resample = self.NetAvg.currentIndex() == 1
min_size = ((30. // 2) ** 2) * np.pi * 0.05
try:
finetune_model = self.model_file_path[0]
print('ft_model', finetune_model)
except:
finetune_model = None
try:
dataset_path = self.batch_inference_dir
except:
dataset_path = None
# batch inference
bz = 8 if self.bz_line.text() == '' else int(self.bz_line.text())
save_name = self.current_model + '_' + dataset_path.split('\\')[-1]
utils.set_manual_seed(5)
try:
shotset = dataset.DatasetShot(eval_dir=dataset_path, class_name=None, image_filter='_img',
mask_filter='_masks',
channels=channels, task_mode=self.model.task_mode, active_ind=None,
rescale=True)
iopart._initialize_image_portable(self, iopart.imread(self.now_pyfile_path + '/assets/Loading1.png'),
resize=self.resize, X2=0)
self.state_label.setText("Running...", color='#969696')
QtWidgets.qApp.processEvents() # force update gui
except:
iopart._initialize_image_portable(self, iopart.imread(self.now_pyfile_path + '/assets/Loading4.png'),
resize=self.resize, X2=0)
self.state_label.setText("Please choose right data path",
color='#FF6A56')
print("Please choose right data path")
self.batch_inference_bnt.setEnabled(False)
return
queryset = dataset.DatasetQuery(dataset_path, class_name=None, image_filter='_img',
mask_filter='_masks')
query_image_names = queryset.query_image_names
diameter = shotset.md
print('>>>> mean diameter of this style,', round(diameter, 3))
self.model.net.save_name = save_name
self.img.setImage(iopart.imread(self.now_pyfile_path + '/assets/Loading2.png'), autoLevels=False, lut=None)
self.state_label.setText("Running...", color='#969696')
QtWidgets.qApp.processEvents() # force update gui
# flow_threshold was set to 0.4, and cellprob_threshold was set to 0.5
try:
masks, flows, _ = self.model.inference(finetune_model=finetune_model, net_avg=False,
query_image_names=query_image_names, channel=channels,
diameter=diameter,
resample=False, flow_threshold=0.4,
cellprob_threshold=0.5,
min_size=min_size, eval_batch_size=bz,
postproc_mode=self.model.postproc_mode,
progress=self.progress)
except RuntimeError:
iopart._initialize_image_portable(self,
iopart.imread(self.now_pyfile_path + '/assets/Loading4.png'),
resize=self.resize, X2=0)
self.state_label.setText("Batch size is too big, please set smaller",
color='#FF6A56')
print("Batch size is too big, please set smaller")
return
# save output images
diams = np.ones(len(query_image_names)) * diameter
imgs = [io.imread(query_image_name) for query_image_name in query_image_names]
io.masks_flows_to_seg(imgs, masks, flows, diams, query_image_names,
[channels for i in range(len(query_image_names))])
io.save_to_png(imgs, masks, flows, query_image_names, labels=None, aps=None,
task_mode=self.model.task_mode)
self.masks_for_save = masks
except:
iopart._initialize_image_portable(self, iopart.imread(self.now_pyfile_path + '/assets/Loading4.png'), resize=self.resize,
X2=0)
self.state_label.setText("Please choose right data path",
color='#FF6A56')
return
else: # except Exception as e:
print('ERROR: %s' % e)
self.img.setImage(iopart.imread(self.now_pyfile_path + '/assets/Loading3.png'), autoLevels=False, lut=None)
self.state_label.setText('Finished inference in %0.3fs!'%(time.time() - tic), color='#39B54A')
self.batch_inference_bnt.setEnabled(False)
def compute_cprob(self):
rerun = False
if self.cellprob != self.probslider.value():
rerun = True
self.cellprob = self.probslider.value()
if self.threshold != (31 - self.threshslider.value()) / 10.:
rerun = True
self.threshold = (31 - self.threshslider.value()) / 10.
if not rerun:
return
if self.threshold == 3.0 or self.NZ > 1:
thresh = None
print('computing masks with cell prob=%0.3f, no flow error threshold' %
(self.cellprob))
else:
thresh = self.threshold
print('computing masks with cell prob=%0.3f, flow error threshold=%0.3f' %
(self.cellprob, thresh))
maski = dynamics.get_masks(self.flows[3].copy(), iscell=(self.flows[4][-1] > self.cellprob),
flows=self.flows[4][:-1], threshold=thresh)
if self.NZ == 1:
maski = utils.fill_holes_and_remove_small_masks(maski)
maski = transforms.resize_image(maski, self.cellpix.shape[-2], self.cellpix.shape[-1],
interpolation=cv2.INTER_NEAREST)
self.masksOn = True
self.outlinesOn = True
self.MCheckBox.setChecked(True)
self.OCheckBox.setChecked(True)
if maski.ndim < 3:
maski = maski[np.newaxis, ...]
print('%d cells found' % (len(np.unique(maski)[1:])))
iopart._masks_to_gui(self, maski, outlines=None)
self.threshslider.setToolTip("Value: " + str(self.threshold))
self.probslider.setToolTip("Value: " + str(self.cellprob))
self.first_load_listView()
self.show()
def reset(self):
# ---- start sets of points ---- #
self.selected = 0
self.X2 = 0
self.resize = -1
self.onechan = False
self.loaded = False
self.channel = [0, 1]
self.current_point_set = []
self.in_stroke = False
self.strokes = []
self.stroke_appended = True
self.ncells = 0
self.zdraw = []
self.removed_cell = []
self.cellcolors = [np.array([255, 255, 255])]
# -- set menus to default -- #
self.color = 0
self.RGBDropDown.setCurrentIndex(self.color)
self.view = 0
self.RGBChoose.button(self.view).setChecked(True)
self.BrushChoose.setCurrentIndex(1)
self.CHCheckBox.setChecked(False)
self.OCheckBox.setEnabled(True)
self.SSCheckBox.setChecked(True)
# -- zero out image stack -- #
self.opacity = 128 # how opaque masks should be
self.outcolor = [200, 200, 255, 200]
self.NZ, self.Ly, self.Lx = 1, 512, 512
if self.autobtn.isChecked():
self.saturation = [[0, 255] for n in range(self.NZ)]
self.currentZ = 0
self.flows = [[], [], [], [], [[]]]
self.stack = np.zeros((1, self.Ly, self.Lx, 3))
# masks matrix
self.layers = 0 * np.ones((1, self.Ly, self.Lx, 4), np.uint8)
# image matrix with a scale disk
self.radii = 0 * np.ones((self.Ly, self.Lx, 4), np.uint8)
self.cellpix = np.zeros((1, self.Ly, self.Lx), np.uint16)
self.outpix = np.zeros((1, self.Ly, self.Lx), np.uint16)
self.ismanual = np.zeros(0, np.bool)
self.update_plot()
self.filename = []
self.loaded = False
def first_load_listView(self):
self.listmodel = Qt.QStandardItemModel(self.ncells,1)
# self.listmodel = Qt.QStringListModel()
self.listmodel.setHorizontalHeaderLabels(["Annotation"])
self.myCellList = ['instance_' + str(i) for i in range(1, self.ncells + 1)]
for i in range(len(self.myCellList)):
self.listmodel.setItem(i,Qt.QStandardItem(self.myCellList[i]))
self.listView.setModel(self.listmodel)
def initialize_listView(self):
if self.filename != []:
if os.path.isfile(os.path.splitext(self.filename)[0] + '_instance_list.txt'):
self.list_file_name = str(os.path.splitext(self.filename)[0] + '_instance_list.txt')
self.myCellList_array = np.loadtxt(self.list_file_name, dtype=str)
self.myCellList = self.myCellList_array.tolist()
if len(self.myCellList) == self.ncells:
self.listmodel = Qt.QStandardItemModel(self.ncells, 1)
self.listmodel.setHorizontalHeaderLabels(["Annotation"])
for i in range(len(self.myCellList)):
self.listmodel.setItem(i,Qt.QStandardItem(self.myCellList[i]))
self.listView.setModel(self.listmodel)
else:
self.listmodel = Qt.QStandardItemModel(self.ncells, 1)
# self.listmodel = Qt.QStringListModel()
self.listmodel.setHorizontalHeaderLabels(["Annotation"])
self.myCellList = ['instance_' + str(i) for i in range(1, self.ncells + 1)]
for i in range(len(self.myCellList)):
self.listmodel.setItem(i,Qt.QStandardItem(self.myCellList[i]))
self.listView.setModel(self.listmodel)
else:
self.myCellList = ['instance_' + str(i) for i in range(1, self.ncells + 1)]
self.listmodel = Qt.QStandardItemModel(self.ncells, 1)
# self.listmodel = Qt.QStringListModel()
self.listmodel.setHorizontalHeaderLabels(["Annotation"])
for i in range(len(self.myCellList)):
self.listmodel.setItem(i,Qt.QStandardItem(self.myCellList[i]))
self.listView.setModel(self.listmodel)
def initinal_p0(self):
# self.p0.removeItem(self.img)
self.p0.removeItem(self.layer)
self.p0.removeItem(self.scale)
# self.img.deleteLater()
self.layer.deleteLater()
self.scale.deleteLater()
# self.img = pg.ImageItem(viewbox=self.p0, parent=self, axisOrder='row-major')
# self.img.autoDownsample = False
self.layer = guiparts.ImageDraw(viewbox=self.p0, parent=self)
self.layer.setLevels([0, 255])
self.scale = pg.ImageItem(viewbox=self.p0, parent=self)
self.scale.setLevels([0, 255])
self.p0.scene().contextMenuItem = self.p0
# self.p0.addItem(self.img)
self.p0.addItem(self.layer)
self.p0.addItem(self.scale)
def add_list_item(self):
# print(self.ncells)
# self.myCellList = self.listmodel.data()
self.listView.selectAll()
self.myCellList = []
for item in self.listView.selectedIndexes():
data = item.data()
self.myCellList.append(data)
temp_nums = []
for celli in self.myCellList:
if 'instance_' in celli:
temp_nums.append(int(celli.split('instance_')[-1]))
if len(temp_nums) == 0:
now_cellIdx = 0
else:
now_cellIdx = np.max(np.array(temp_nums))
self.myCellList.append('instance_' + str(now_cellIdx+1))
# self.myCellList.append('instance_' + str(self.ncells))
self.listmodel = Qt.QStandardItemModel(self.ncells, 1)
# self.listmodel = Qt.QStringListModel()
self.listmodel.setHorizontalHeaderLabels(["Annotation"])
for i in range(len(self.myCellList)):
self.listmodel.setItem(i, Qt.QStandardItem(self.myCellList[i]))
self.listView.setModel(self.listmodel)
def delete_list_item(self, index):
# self.myCellList = self.listmodel.data()
self.listView.selectAll()
self.myCellList = []
for item in self.listView.selectedIndexes():
data = item.data()
self.myCellList.append(data)
self.last_remove_index = index
self.last_remove_item = self.myCellList.pop(index - 1)
self.listmodel = Qt.QStandardItemModel(self.ncells, 1)
# self.listmodel = Qt.QStringListModel()
self.listmodel.setHorizontalHeaderLabels(["Annotation"])
for i in range(len(self.myCellList)):
self.listmodel.setItem(i, Qt.QStandardItem(self.myCellList[i]))
self.listView.setModel(self.listmodel)
def check_gpu(self, torch=True):
# also decide whether or not to use torch
self.useGPU.setChecked(False)
self.useGPU.setEnabled(False)
if models.use_gpu():
self.useGPU.setEnabled(True)
self.useGPU.setChecked(True)
def check_ftgpu(self, torch=True):
# also decide whether or not to use torch
self.ftuseGPU.setChecked(False)
self.ftuseGPU.setEnabled(False)
if models.use_gpu():
self.ftuseGPU.setEnabled(True)
self.ftuseGPU.setChecked(True)
def clear_all(self):
self.prev_selected = 0
self.selected = 0
# self.layers_undo, self.cellpix_undo, self.outpix_undo = [],[],[]
self.layers = 0 * np.ones((self.NZ, self.Ly, self.Lx, 4), np.uint8)
self.cellpix = np.zeros((self.NZ, self.Ly, self.Lx), np.uint16)
self.outpix = np.zeros((self.NZ, self.Ly, self.Lx), np.uint16)
self.cellcolors = [np.array([255, 255, 255])]
self.ncells = 0
self.initialize_listView()
print('removed all cells')
self.toggle_removals()
self.update_plot()
def list_select_cell(self, idx):
self.prev_selected = self.selected
self.selected = idx
# print(idx)
# print(self.prev_selected)
if self.selected > 0:
self.layers[self.cellpix == idx] = np.array([255, 255, 255, 255])
if idx < self.ncells + 1 and self.prev_selected > 0 and self.prev_selected != idx:
self.layers[self.cellpix == self.prev_selected] = np.append(self.cellcolors[self.prev_selected],
self.opacity)
# if self.outlinesOn:
# self.layers[self.outpix == idx] = np.array(self.outcolor).astype(np.uint8)
self.update_plot()
def select_cell(self, idx):
self.prev_selected = self.selected
self.selected = idx
self.listView.selectRow(idx - 1)
# print('the prev-selected is ', self.prev_selected)
if self.selected > 0:
self.layers[self.cellpix == idx] = np.array([255, 255, 255, self.opacity])
print('idx', self.prev_selected, idx)
if idx < self.ncells + 1 and self.prev_selected > 0 and self.prev_selected != idx:
self.layers[self.cellpix == self.prev_selected] = np.append(self.cellcolors[self.prev_selected],
self.opacity)
# if self.outlinesOn:
# self.layers[self.outpix==idx] = np.array(self.outcolor)
self.update_plot()
def unselect_cell(self):
if self.selected > 0:
idx = self.selected
if idx < self.ncells + 1:
self.layers[self.cellpix == idx] = np.append(self.cellcolors[idx], self.opacity)
if self.outlinesOn:
self.layers[self.outpix == idx] = np.array(self.outcolor).astype(np.uint8)
# [0,0,0,self.opacity])
self.update_plot()
self.selected = 0
def remove_cell(self, idx):
# remove from manual array
# self.selected = 0
for z in range(self.NZ):
cp = self.cellpix[z] == idx
op = self.outpix[z] == idx
# remove from mask layer
self.layers[z, cp] = | np.array([0, 0, 0, 0]) | numpy.array |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""Testing suite for ParamStandard.
"""
from __future__ import print_function, division
import unittest as ut
import numpy as np
import numpy.testing as npt
import scipy.linalg as scl
from bekk import ParamStandard
class ParamStandardTestCase(ut.TestCase):
"""Test ParamStandard."""
def test_init(self):
"""Test init."""
nstocks = 2
param = ParamStandard(nstocks)
self.assertIsInstance(param.amat, np.ndarray)
self.assertIsInstance(param.bmat, np.ndarray)
self.assertIsInstance(param.cmat, np.ndarray)
self.assertEqual(param.amat.shape, (nstocks, nstocks))
self.assertEqual(param.bmat.shape, (nstocks, nstocks))
self.assertEqual(param.bmat.shape, (nstocks, nstocks))
def test_find_cmat(self):
"""Test find C matrix."""
nstocks = 2
alpha, beta = .09, .81
# A, B, C - n x n matrices
amat = np.eye(nstocks) * alpha**.5
bmat = np.eye(nstocks) * beta**.5
target = np.eye(nstocks)
# Choose intercept to normalize unconditional variance to one
cmat1 = ParamStandard.find_cmat(amat=amat, bmat=bmat, target=target)
ccmat = target - amat.dot(target).dot(amat.T) \
- bmat.dot(target).dot(bmat.T)
cmat2 = scl.cholesky(ccmat, 1)
npt.assert_array_equal(cmat1, cmat2)
def test_find_stationary_var(self):
"""Test find stationary variance matrix."""
nstocks = 2
alpha, beta = .09, .5
# A, B, C - n x n matrices
amat = np.eye(nstocks) * alpha**.5
bmat = np.eye(nstocks) * beta**.5
target = np.eye(nstocks)
# Choose intercept to normalize unconditional variance to one
cmat = ParamStandard.find_cmat(amat=amat, bmat=bmat, target=target)
param = ParamStandard.from_abc(amat=amat, bmat=bmat, cmat=cmat)
hvar = param.get_uvar()
npt.assert_array_almost_equal(hvar, target)
hvar = ParamStandard.find_stationary_var(amat=amat, bmat=bmat,
cmat=cmat)
npt.assert_array_almost_equal(hvar, target)
npt.assert_array_equal(hvar, hvar.transpose())
def test_from_abc(self):
"""Test init from abc."""
nstocks = 2
amat = np.eye(nstocks)
bmat = np.eye(nstocks)
cmat = np.eye(nstocks)
param = ParamStandard.from_abc(amat=amat, bmat=bmat, cmat=cmat)
npt.assert_array_equal(amat, param.amat)
npt.assert_array_equal(bmat, param.bmat)
npt.assert_array_equal(cmat, param.cmat)
nstocks = 2
alpha, beta = .09, .81
# A, B, C - n x n matrices
amat = np.eye(nstocks) * alpha**.5
bmat = np.eye(nstocks) * beta**.5
target = np.eye(nstocks)
# Choose intercept to normalize unconditional variance to one
cmat = ParamStandard.find_cmat(amat=amat, bmat=bmat, target=target)
param = ParamStandard.from_abc(amat=amat, bmat=bmat, cmat=cmat)
npt.assert_array_equal(amat, param.amat)
npt.assert_array_equal(bmat, param.bmat)
npt.assert_array_equal(cmat, param.cmat)
def test_from_target(self):
"""Test init from abc."""
nstocks = 2
target = np.eye(nstocks)*.5
param = ParamStandard.from_target(target=target)
param_default = ParamStandard(nstocks)
cmat = ParamStandard.find_cmat(amat=param_default.amat,
bmat=param_default.bmat, target=target)
param_default = ParamStandard.from_abc(amat=param_default.amat,
bmat=param_default.bmat, cmat=cmat)
npt.assert_array_equal(param.amat, param_default.amat)
npt.assert_array_equal(param.bmat, param_default.bmat)
npt.assert_array_equal(param.cmat, cmat)
amat = np.eye(nstocks)*.1
bmat = np.eye(nstocks)*.5
param = ParamStandard.from_target(amat=amat, bmat=bmat, target=target)
cmat = ParamStandard.find_cmat(amat=amat, bmat=bmat, target=target)
npt.assert_array_equal(amat, param.amat)
npt.assert_array_equal(bmat, param.bmat)
npt.assert_array_equal(cmat, param.cmat)
def test_theta(self):
"""Test theta."""
nstocks = 2
alpha, beta = .09, .81
# A, B, C - n x n matrices
amat = np.eye(nstocks) * alpha**.5
bmat = np.eye(nstocks) * beta**.5
target = np.eye(nstocks)
cmat = ParamStandard.find_cmat(amat=amat, bmat=bmat, target=target)
restriction = 'scalar'
theta = [[alpha**.5], [beta**.5]]
theta = np.concatenate(theta)
param = ParamStandard.from_theta(theta=theta, nstocks=nstocks,
target=target, restriction=restriction)
npt.assert_array_equal(amat, param.amat)
npt.assert_array_equal(bmat, param.bmat)
npt.assert_array_equal(cmat, param.cmat)
restriction = 'scalar'
theta = [[alpha**.5], [beta**.5]]
theta.append(cmat[np.tril_indices(cmat.shape[0])])
theta = np.concatenate(theta)
param = ParamStandard.from_theta(theta=theta, nstocks=nstocks,
restriction=restriction)
npt.assert_array_equal(amat, param.amat)
| npt.assert_array_equal(bmat, param.bmat) | numpy.testing.assert_array_equal |
# -*- coding: utf-8 -*-
"""
Created on Wed Jun 24 11:04:41 2020
@author: MGD
"""
import numpy as np
import struct
class transitions:
def __init__(self, title):
self.title = title
self.site = []
self.hfre = []
self.hfim = []
self.lfre = []
self.lfim = []
self.tt = []
self.center = []
self.origin = []
def add(self, site, hfre, hfim, lfre, lfim, tt, center, origin):
self.site.append(site)
self.hfre.append(hfre)
self.hfim.append(hfim)
self.lfre.append(lfre)
self.lfim.append(lfim)
self.tt.append(tt)
self.center.append(center)
self.origin.append(origin)
def add_freq(self, freq):
self.freq = np.ones(len(self.lfre)) * freq
def list2array(self):
self.site = np.asarray(self.site)
self.hfre = np.asarray(self.hfre)
self.hfim = np.asarray(self.hfim)
self.lfre = np.asarray(self.lfre)
self.lfim = np.asarray(self.lfim)
self.tt = np.asarray(self.tt)
self.center = np.asarray(self.center)
self.lf_phase = np.arctan2(self.lfim, self.lfre)
self.hf_phase = np.arctan2(self.hfim, self.hfre)
self.hf_amp = np.sqrt(np.add(np.square(self.hfim), np.square(self.hfre)))
self.lf_amp = np.sqrt(np.add( | np.square(self.lfim) | numpy.square |
#
# Pocket SDR Python Library - GNSS Spreading Code Functions
#
# References:
# [1] IS-GPS-200K, NAVSTAR GPS Space Segment/Navigation User Segment
# Interfaces, May 19, 2019
# [2] IS-GPS-705A, Navstar GPS Space Segment / User Segment L5 Interfaces,
# June 8, 2010
# [3] IS-QZSS-PNT-004, Quasi-Zenith Satellite System Interface Specification
# Satellite Positioning, Navigation and Timing Service, November 5, 2018
# [4] IS-QZSS-L6-001, Quasi-Zenith Satellite System Interface Specification
# Centimeter Level Augmentation Service, November 5, 2018
# [5] Galileo Open Service Signal In Space Interface Control Document -
# Issue 1, February 2010
# [6] Galileo E6-B/C Codes Technical Note - Issue 1, January 2019
# [7] IS-GPS-800F, Navstar GPS Space Segment / User Segment L1C Interfaces,
# March 4, 2019
# [8] BeiDou Navigation Satellite System Signal In Space Interface Control
# Document - Open Service Signal B1C (Version 1.0), December, 2017
# [9] BeiDou Navigation Satellite System Signal In Space Interface Control
# Document - Open Service Signal B2a (Version 1.0), December, 2017
# [10] BeiDou Navigation Satellite System Signal In Space Interface Control
# Document - Open Service Signal B2b (Version 1.0), July, 2020
# [11] BeiDou Navigation Satellite System Signal In Space Interface Control
# Document - Precise Positioning Service Signal PPP-B2b (Version 1.0),
# July, 2020
# [12] BeiDou Navigation Satellite System Signal In Space Interface Control
# Document - Open Service Signal B1I (Version 3.0), February, 2019
# [13] BeiDou Navigation Satellite System Signal In Space Interface Control
# Document - Open Service Signal B3I (Version 1.0), February, 2018
# [14] Global Navigation Satellite System GLONASS Interface Control Document
# Navigation radiosignal in bands L1, L2 (Version 5.1), 2008
# [15] IS-QZSS-TV-003, Quasi-Zenith Satellite System Interface Specification
# Positioning Technology Verification Service, December 27, 2019
# [16] IRNSS SIS ICD for Standard Positioning Service version 1.1, August,
# 2017
# [17] GLONASS Interface Control Document Code Devision Multiple Access Open
# Service Navigation Signal in L3 frequency band Edition 1.0, 2016
#
# Author:
# T.TAKASU
#
# History:
# 2021-12-01 1.0 new
# 2021-12-05 1.1 add signals: G1CA, G2CA, B1I, B2I, B1CD, B1CP, B2AD, B2AP,
# B2BI, B3I
# 2021-12-22 1.2 add secondary code generation
# 2021-12-24 1.3 add L1S, L5SI, L5SQ
# 2022-01-13 1.4 change API gen_code_fft()
# add support of G1CA, G2CA and B3I in sec_code()
# 2022-01-17 1.5 add signals: L2CL, I5S, ISS
# 2022-01-27 1.6 add signals: G3OCD, G3OCP
#
import numpy as np
import scipy.fftpack as fft
import sdr_func, sdr_code_gal
# constants --------------------------------------------------------------------
NONE = np.array([], dtype='int8')
CHIP = (-1, 1)
# code caches ------------------------------------------------------------------
L1CA = {}
L1CP, L1CD = {}, {}
L1CO = {}
L2CM, L2CL = {}, {}
L5I , L5Q = {}, {}
L6D, L6E = {}, {}
G1CA = {}
G3OCD, G3OCP = {}, {}
E1B , E1C = {}, {}
E5AI, E5AQ = {}, {}
E5BI, E5BQ = {}, {}
E6B , E6C = {}, {}
B1I = {}
B1CD, B1CP = {}, {}
B1CS = {}
B2AD, B2AP = {}, {}
B2AS = {}
B2BI = {}
B3I = {}
I5S, ISS = {}, {}
L1CA_G1, L1CA_G2 = [], []
L1C_L_SEQ = []
L5_XA, L5_XB = [], []
G3OC_D1 = []
B1C_L_SEQ, B1C_L_SEQ_S = [], []
B2AD_G1, B2AP_G1 = [], []
B2A_L_SEQ = []
B2BI_G1 = []
B3I_G1 = []
# code tables ------------------------------------------------------------------
L1CA_G2_delay = ( # PRN 1 - 210
5, 6, 7, 8, 17, 18, 139, 140, 141, 251, 252, 254, 255, 256, 257,
258, 469, 470, 471, 472, 473, 474, 509, 512, 513, 514, 515, 516, 859, 860,
861, 862, 863, 950, 947, 948, 950, 67, 103, 91, 19, 679, 225, 625, 946,
638, 161,1001, 554, 280, 710, 709, 775, 864, 558, 220, 397, 55, 898, 759,
367, 299,1018, 729, 695, 780, 801, 788, 732, 34, 320, 327, 389, 407, 525,
405, 221, 761, 260, 326, 955, 653, 699, 422, 188, 438, 959, 539, 879, 677,
586, 153, 792, 814, 446, 264,1015, 278, 536, 819, 156, 957, 159, 712, 885,
461, 248, 713, 126, 807, 279, 122, 197, 693, 632, 771, 467, 647, 203, 145,
175, 52, 21, 237, 235, 886, 657, 634, 762, 355,1012, 176, 603, 130, 359,
595, 68, 386, 797, 456, 499, 883, 307, 127, 211, 121, 118, 163, 628, 853,
484, 289, 811, 202,1021, 463, 568, 904, 670, 230, 911, 684, 309, 644, 932,
12, 314, 891, 212, 185, 675, 503, 150, 395, 345, 846, 798, 992, 357, 995,
877, 112, 144, 476, 193, 109, 445, 291, 87, 399, 292, 901, 339, 208, 711,
189, 263, 537, 663, 942, 173, 900, 30, 500, 935, 556, 373, 85, 652, 310)
L1CP_weil_idx = ( # PRN 1 - 210
5111, 5109, 5108, 5106, 5103, 5101, 5100, 5098, 5095, 5094, 5093, 5091,
5090, 5081, 5080, 5069, 5068, 5054, 5044, 5027, 5026, 5014, 5004, 4980,
4915, 4909, 4893, 4885, 4832, 4824, 4591, 3706, 5092, 4986, 4965, 4920,
4917, 4858, 4847, 4790, 4770, 4318, 4126, 3961, 3790, 4911, 4881, 4827,
4795, 4789, 4725, 4675, 4539, 4535, 4458, 4197, 4096, 3484, 3481, 3393,
3175, 2360, 1852, 5065, 5063, 5055, 5012, 4981, 4952, 4934, 4932, 4786,
4762, 4640, 4601, 4563, 4388, 3820, 3687, 5052, 5051, 5047, 5039, 5015,
5005, 4984, 4975, 4974, 4972, 4962, 4913, 4907, 4903, 4833, 4778, 4721,
4661, 4660, 4655, 4623, 4590, 4548, 4461, 4442, 4347, 4259, 4256, 4166,
4155, 4109, 4100, 4023, 3998, 3979, 3903, 3568, 5088, 5050, 5020, 4990,
4982, 4966, 4949, 4947, 4937, 4935, 4906, 4901, 4872, 4865, 4863, 4818,
4785, 4781, 4776, 4775, 4754, 4696, 4690, 4658, 4607, 4599, 4596, 4530,
4524, 4451, 4441, 4396, 4340, 4335, 4296, 4267, 4168, 4149, 4097, 4061,
3989, 3966, 3789, 3775, 3622, 3523, 3515, 3492, 3345, 3235, 3169, 3157,
3082, 3072, 3032, 3030, 4582, 4595, 4068, 4871, 4514, 4439, 4122, 4948,
4774, 3923, 3411, 4745, 4195, 4897, 3047, 4185, 4354, 5077, 4042, 2111,
4311, 5024, 4352, 4678, 5034, 5085, 3646, 4868, 3668, 4211, 2883, 2850,
2815, 2542, 2492, 2376, 2036, 1920)
L1CP_ins_idx = ( # PRN 1 - 210
412, 161, 1, 303, 207, 4971, 4496, 5, 4557, 485, 253, 4676,
1, 66, 4485, 282, 193, 5211, 729, 4848, 982, 5955, 9805, 670,
464, 29, 429, 394, 616, 9457, 4429, 4771, 365, 9705, 9489, 4193,
9947, 824, 864, 347, 677, 6544, 6312, 9804, 278, 9461, 444, 4839,
4144, 9875, 197, 1156, 4674,10035, 4504, 5, 9937, 430, 5, 355,
909, 1622, 6284, 9429, 77, 932, 5973, 377,10000, 951, 6212, 686,
9352, 5999, 9912, 9620, 635, 4951, 5453, 4658, 4800, 59, 318, 571,
565, 9947, 4654, 148, 3929, 293, 178,10142, 9683, 137, 565, 35,
5949, 2, 5982, 825, 9614, 9790, 5613, 764, 660, 4870, 4950, 4881,
1151, 9977, 5122,10074, 4832, 77, 4698, 1002, 5549, 9606, 9228, 604,
4678, 4854, 4122, 9471, 5026, 272, 1027, 317, 691, 509, 9708, 5033,
9938, 4314,10140, 4790, 9823, 6093, 469, 1215, 799, 756, 9994, 4843,
5271, 9661, 6255, 5203, 203,10070, 30, 103, 5692, 32, 9826, 76,
59, 6831, 958, 1471,10070, 553, 5487, 55, 208, 645, 5268, 1873,
427, 367, 1404, 5652, 5, 368, 451, 9595, 1030, 1324, 692, 9819,
4520, 9911, 278, 642, 6330, 5508, 1872, 5445,10131, 422, 4918, 787,
9864, 9753, 9859, 328, 1, 4733, 164, 135, 174, 132, 538, 176,
198, 595, 574, 321, 596, 491)
L1CD_weil_idx = ( # PRN 1 - 210
5097, 5110, 5079, 4403, 4121, 5043, 5042, 5104, 4940, 5035, 4372, 5064,
5084, 5048, 4950, 5019, 5076, 3736, 4993, 5060, 5061, 5096, 4983, 4783,
4991, 4815, 4443, 4769, 4879, 4894, 4985, 5056, 4921, 5036, 4812, 4838,
4855, 4904, 4753, 4483, 4942, 4813, 4957, 4618, 4669, 4969, 5031, 5038,
4740, 4073, 4843, 4979, 4867, 4964, 5025, 4579, 4390, 4763, 4612, 4784,
3716, 4703, 4851, 4955, 5018, 4642, 4840, 4961, 4263, 5011, 4922, 4317,
3636, 4884, 5041, 4912, 4504, 4617, 4633, 4566, 4702, 4758, 4860, 3962,
4882, 4467, 4730, 4910, 4684, 4908, 4759, 4880, 4095, 4971, 4873, 4561,
4588, 4773, 4997, 4583, 4900, 4574, 4629, 4676, 4181, 5057, 4944, 4401,
4586, 4699, 3676, 4387, 4866, 4926, 4657, 4477, 4359, 4673, 4258, 4447,
4570, 4486, 4362, 4481, 4322, 4668, 3967, 4374, 4553, 4641, 4215, 3853,
4787, 4266, 4199, 4545, 4208, 4485, 3714, 4407, 4182, 4203, 3788, 4471,
4691, 4281, 4410, 3953, 3465, 4801, 4278, 4546, 3779, 4115, 4193, 3372,
3786, 3491, 3812, 3594, 4028, 3652, 4224, 4334, 3245, 3921, 3840, 3514,
2922, 4227, 3376, 3560, 4989, 4756, 4624, 4446, 4174, 4551, 3972, 4399,
4562, 3133, 4157, 5053, 4536, 5067, 3905, 3721, 3787, 4674, 3436, 2673,
4834, 4456, 4056, 3804, 3672, 4205, 3348, 4152, 3883, 3473, 3669, 3455,
2318, 2945, 2947, 3220, 4052, 2953)
L1CD_ins_idx = ( # PRN 1 - 210
181, 359, 72, 1110, 1480, 5034, 4622, 1, 4547, 826, 6284, 4195,
368, 1, 4796, 523, 151, 713, 9850, 5734, 34, 6142, 190, 644,
467, 5384, 801, 594, 4450, 9437, 4307, 5906, 378, 9448, 9432, 5849,
5547, 9546, 9132, 403, 3766, 3, 684, 9711, 333, 6124,10216, 4251,
9893, 9884, 4627, 4449, 9798, 985, 4272, 126,10024, 434, 1029, 561,
289, 638, 4353, 9899, 4629, 669, 4378, 4528, 9718, 5485, 6222, 672,
1275, 6083, 5264,10167, 1085, 194, 5012, 4938, 9356, 5057, 866, 2,
204, 9808, 4365, 162, 367, 201, 18, 251,10167, 21, 685, 92,
1057, 3, 5756, 14, 9979, 9569, 515, 753, 1181, 9442, 669, 4834,
541, 9933, 6683, 4828, 9710,10170, 9629, 260, 86, 5544, 923, 257,
507, 4572, 4491, 341, 130, 79, 1142, 448, 875, 555, 1272, 5198,
9529, 4459,10019, 9353, 9780, 375, 503, 4507, 875, 1246, 1, 4534,
8, 9549, 6240, 22, 5652,10069, 4796, 4980, 27, 90, 9788, 715,
9720, 301, 5450, 5215, 13, 1147, 4855, 1190, 1267, 1302, 1, 5007,
549, 368, 6300, 5658, 4302, 851, 4353, 9618, 9652, 1232, 109,10174,
6178, 1851, 1299, 325,10206, 9968,10191, 5438,10080, 219, 758, 2140,
9753, 4799,10126, 241, 1245, 1274, 1456, 9967, 235, 512, 1078, 1078,
953, 5647, 669, 1311, 5827, 15)
L1CO_S1_poly = ( # PRN 1 - 210
0o5111, 0o5421, 0o5501, 0o5403, 0o6417, 0o6141, 0o6351, 0o6501, 0o6205,
0o6235, 0o7751, 0o6623, 0o6733, 0o7627, 0o5667, 0o5051, 0o7665, 0o6325,
0o4365, 0o4745, 0o7633, 0o6747, 0o4475, 0o4225, 0o7063, 0o4423, 0o6651,
0o4161, 0o7237, 0o4473, 0o5477, 0o6163, 0o7223, 0o6323, 0o7125, 0o7035,
0o4341, 0o4353, 0o4107, 0o5735, 0o6741, 0o7071, 0o4563, 0o5755, 0o6127,
0o4671, 0o4511, 0o4533, 0o5357, 0o5607, 0o6673, 0o6153, 0o7565, 0o7107,
0o6211, 0o4321, 0o7201, 0o4451, 0o5411, 0o5141, 0o7041, 0o6637, 0o4577,
0o5111, 0o5111, 0o5111, 0o5111, 0o5111, 0o5111, 0o5111, 0o5111, 0o5111,
0o5111, 0o5111, 0o5111, 0o5111, 0o5111, 0o5111, 0o5111, 0o5111, 0o5111,
0o5111, 0o5111, 0o5111, 0o5111, 0o5111, 0o5111, 0o5111, 0o5111, 0o5111,
0o5111, 0o5111, 0o5111, 0o5111, 0o5111, 0o5111, 0o5111, 0o5111, 0o5111,
0o5421, 0o5421, 0o5421, 0o5421, 0o5421, 0o5421, 0o5421, 0o5421, 0o5421,
0o5421, 0o5421, 0o5421, 0o5421, 0o5421, 0o5421, 0o5421, 0o5421, 0o5421,
0o5421, 0o5421, 0o5421, 0o5421, 0o5421, 0o5421, 0o5421, 0o5421, 0o5421,
0o5421, 0o5421, 0o5421, 0o5421, 0o5421, 0o5421, 0o5421, 0o5421, 0o5421,
0o5421, 0o5421, 0o5421, 0o5403, 0o5403, 0o5403, 0o5403, 0o5403, 0o5403,
0o5403, 0o5403, 0o5403, 0o5403, 0o5403, 0o5403, 0o5403, 0o5403, 0o5403,
0o5403, 0o5403, 0o5403, 0o5403, 0o5403, 0o5403, 0o5403, 0o5403, 0o5403,
0o5403, 0o5403, 0o5403, 0o5403, 0o5403, 0o5403, 0o5403, 0o5403, 0o5403,
0o5403, 0o5403, 0o5403, 0o5403, 0o5403, 0o5403, 0o5403, 0o5403, 0o5403,
0o5403, 0o5403, 0o5403, 0o5403, 0o5403, 0o5403, 0o5403, 0o5403, 0o5403,
0o5403, 0o5403, 0o5403, 0o5403, 0o5403, 0o5403, 0o5403, 0o5403, 0o6501,
0o6501, 0o6501, 0o6501, 0o6501, 0o6501, 0o6501, 0o6501, 0o6501, 0o6501,
0o6501, 0o6501, 0o6501)
L1CO_S1_init = ( # PRN 1 - 210
0o3266, 0o2040, 0o1527, 0o3307, 0o3756, 0o3026, 0o0562, 0o0420, 0o3415,
0o0337, 0o0265, 0o1230, 0o2204, 0o1440, 0o2412, 0o3516, 0o2761, 0o3750,
0o2701, 0o1206, 0o1544, 0o1774, 0o0546, 0o2213, 0o3707, 0o2051, 0o3650,
0o1777, 0o3203, 0o1762, 0o2100, 0o0571, 0o3710, 0o3535, 0o3110, 0o1426,
0o0255, 0o0321, 0o3124, 0o0572, 0o1736, 0o3306, 0o1307, 0o3763, 0o1604,
0o1021, 0o2624, 0o0406, 0o0114, 0o0077, 0o3477, 0o1000, 0o3460, 0o2607,
0o2057, 0o3467, 0o0706, 0o2032, 0o1464, 0o0520, 0o1766, 0o3270, 0o0341,
0o1740, 0o3664, 0o1427, 0o2627, 0o0701, 0o3460, 0o1373, 0o2540, 0o2004,
0o2274, 0o1340, 0o0602, 0o2502, 0o0327, 0o2600, 0o0464, 0o3674, 0o3040,
0o1153, 0o0747, 0o1770, 0o3772, 0o1731, 0o1672, 0o1333, 0o2705, 0o2713,
0o3562, 0o3245, 0o3770, 0o3202, 0o3521, 0o3250, 0o2117, 0o0530, 0o3021,
0o2511, 0o1562, 0o1067, 0o0424, 0o3402, 0o1326, 0o2142, 0o0733, 0o0504,
0o1611, 0o2724, 0o0753, 0o3724, 0o2652, 0o1743, 0o0013, 0o3464, 0o2300,
0o1334, 0o2175, 0o2564, 0o3075, 0o3455, 0o3627, 0o0617, 0o1324, 0o3506,
0o2231, 0o1110, 0o1271, 0o3740, 0o3652, 0o1644, 0o3635, 0o3436, 0o3076,
0o0434, 0o3340, 0o0054, 0o2446, 0o0025, 0o0150, 0o2746, 0o2723, 0o2601,
0o3440, 0o1312, 0o0544, 0o2062, 0o0176, 0o3616, 0o1740, 0o3777, 0o0432,
0o2466, 0o1667, 0o3601, 0o2706, 0o2022, 0o1363, 0o2331, 0o3556, 0o2205,
0o3734, 0o2115, 0o0010, 0o2140, 0o3136, 0o0272, 0o3264, 0o2017, 0o2505,
0o3532, 0o0647, 0o1542, 0o2154, 0o3734, 0o2621, 0o2711, 0o0217, 0o3503,
0o3457, 0o3750, 0o2525, 0o0113, 0o0265, 0o1711, 0o0552, 0o0675, 0o1706,
0o3513, 0o1135, 0o0566, 0o0500, 0o0254, 0o3445, 0o2542, 0o1257, 0o0211,
0o0534, 0o1420, 0o3401, 0o0714, 0o0613, 0o2475, 0o2572, 0o3265, 0o1250,
0o1711, 0o2704, 0o0135)
L1CO_S2_init = ( # 64 - 210
0o3035, 0o1557, 0o0237, 0o2527, 0o3307, 0o1402, 0o1225, 0o0607, 0o0351,
0o3724, 0o1675, 0o2625, 0o1030, 0o1443, 0o3277, 0o1132, 0o0572, 0o1241,
0o0535, 0o1366, 0o0041, 0o0561, 0o0122, 0o1205, 0o3753, 0o2543, 0o3031,
0o2260, 0o3773, 0o3156, 0o2215, 0o0146, 0o2413, 0o2564, 0o3310, 0o2267,
0o3120, 0o0064, 0o1042, 0o0476, 0o1020, 0o0431, 0o0216, 0o2736, 0o2527,
0o2431, 0o1013, 0o0524, 0o0726, 0o1042, 0o3362, 0o1364, 0o3354, 0o0623,
0o0145, 0o0214, 0o0223, 0o0151, 0o2405, 0o2522, 0o3235, 0o0452, 0o2617,
0o1300, 0o1430, 0o0773, 0o0772, 0o3561, 0o0607, 0o0420, 0o0527, 0o3770,
0o2536, 0o2233, 0o3366, 0o3766, 0o3554, 0o2060, 0o2070, 0o0713, 0o3366,
0o3247, 0o2776, 0o1244, 0o2102, 0o1712, 0o1245, 0o3344, 0o1277, 0o0165,
0o2131, 0o3623, 0o0141, 0o0421, 0o3032, 0o2065, 0o3024, 0o2663, 0o2274,
0o2114, 0o1664, 0o0413, 0o1512, 0o0135, 0o2737, 0o1015, 0o1075, 0o1255,
0o3473, 0o2716, 0o0101, 0o1105, 0o1407, 0o3407, 0o1046, 0o3237, 0o0154,
0o3010, 0o2245, 0o2051, 0o2144, 0o1743, 0o2511, 0o3410, 0o1414, 0o1275,
0o2257, 0o2331, 0o0276, 0o3261, 0o1760, 0o0430, 0o3477, 0o1676, 0o1636,
0o2411, 0o1473, 0o2266, 0o2104, 0o2070, 0o1766, 0o0711, 0o2533, 0o0353,
0o1744, 0o0053, 0o2222)
L2CM_R_init_1 = ( # PRN 1 - 63
0o742417664, 0o756014035, 0o002747144, 0o066265724, 0o601403471,
0o703232733, 0o124510070, 0o617316361, 0o047541621, 0o733031046,
0o713512145, 0o024437606, 0o021264003, 0o230655351, 0o001314400,
0o222021506, 0o540264026, 0o205521705, 0o064022144, 0o120161274,
0o044023533, 0o724744327, 0o045743577, 0o741201660, 0o700274134,
0o010247261, 0o713433445, 0o737324162, 0o311627434, 0o710452007,
0o722462133, 0o050172213, 0o500653703, 0o755077436, 0o136717361,
0o756675453, 0o435506112, 0o771353753, 0o226107701, 0o022025110,
0o402466344, 0o752566114, 0o702011164, 0o041216771, 0o047457275,
0o266333164, 0o713167356, 0o060546335, 0o355173035, 0o617201036,
0o157465571, 0o767360553, 0o023127030, 0o431343777, 0o747317317,
0o045706125, 0o002744276, 0o060036467, 0o217744147, 0o603340174,
0o326616775, 0o063240065, 0o111460621)
L2CM_R_init_2 = ( # PRN 159 - 210
0o604055104, 0o157065232, 0o013305707, 0o603552017, 0o230461355,
0o603653437, 0o652346475, 0o743107103, 0o401521277, 0o167335110,
0o014013575, 0o362051132, 0o617753265, 0o216363634, 0o755561123,
0o365304033, 0o625025543, 0o054420334, 0o415473671, 0o662364360,
0o373446602, 0o417564100, 0o000526452, 0o226631300, 0o113752074,
0o706134401, 0o041352546, 0o664630154, 0o276524255, 0o714720530,
0o714051771, 0o044526647, 0o207164322, 0o262120161, 0o204244652,
0o202133131, 0o714351204, 0o657127260, 0o130567507, 0o670517677,
0o607275514, 0o045413633, 0o212645405, 0o613700455, 0o706202440,
0o705056276, 0o020373522, 0o746013617, 0o132720621, 0o434015513,
0o566721727, 0o140633660)
L2CL_R_init_1 = ( # PRN 1 - 63
0o624145772, 0o506610362, 0o220360016, 0o710406104, 0o001143345,
0o053023326, 0o652521276, 0o206124777, 0o015563374, 0o561522076,
0o023163525, 0o117776450, 0o606516355, 0o003037343, 0o046515565,
0o671511621, 0o605402220, 0o002576207, 0o525163451, 0o266527765,
0o006760703, 0o501474556, 0o743747443, 0o615534726, 0o763621420,
0o720727474, 0o700521043, 0o222567263, 0o132765304, 0o746332245,
0o102300466, 0o255231716, 0o437661701, 0o717047302, 0o222614207,
0o561123307, 0o240713073, 0o101232630, 0o132525726, 0o315216367,
0o377046065, 0o655351360, 0o435776513, 0o744242321, 0o024346717,
0o562646415, 0o731455342, 0o723352536, 0o000013134, 0o011566642,
0o475432222, 0o463506741, 0o617127534, 0o026050332, 0o733774235,
0o751477772, 0o417631550, 0o052247456, 0o560404163, 0o417751005,
0o004302173, 0o715005045, 0o001154457)
L2CL_R_init_2 = ( # PRN 159 - 210
0o605253024, 0o063314262, 0o066073422, 0o737276117, 0o737243704,
0o067557532, 0o227354537, 0o704765502, 0o044746712, 0o720535263,
0o733541364, 0o270060042, 0o737176640, 0o133776704, 0o005645427,
0o704321074, 0o137740372, 0o056375464, 0o704374004, 0o216320123,
0o011322115, 0o761050112, 0o725304036, 0o721320336, 0o443462103,
0o510466244, 0o745522652, 0o373417061, 0o225526762, 0o047614504,
0o034730440, 0o453073141, 0o533654510, 0o377016461, 0o235525312,
0o507056307, 0o221720061, 0o520470122, 0o603764120, 0o145604016,
0o051237167, 0o033326347, 0o534627074, 0o645230164, 0o000171400,
0o022715417, 0o135471311, 0o137422057, 0o714426456, 0o640724672,
0o501254540, 0o513322453)
L5I_XB_adv = ( # PRN 1 - 210
266, 365, 804, 1138, 1509, 1559, 1756, 2084, 2170, 2303, 2527, 2687,
2930, 3471, 3940, 4132, 4332, 4924, 5343, 5443, 5641, 5816, 5898, 5918,
5955, 6243, 6345, 6477, 6518, 6875, 7168, 7187, 7329, 7577, 7720, 7777,
8057, 5358, 3550, 3412, 819, 4608, 3698, 962, 3001, 4441, 4937, 3717,
4730, 7291, 2279, 7613, 5723, 7030, 1475, 2593, 2904, 2056, 2757, 3756,
6205, 5053, 6437, 7789, 2311, 7432, 5155, 1593, 5841, 5014, 1545, 3016,
4875, 2119, 229, 7634, 1406, 4506, 1819, 7580, 5446, 6053, 7958, 5267,
2956, 3544, 1277, 2996, 1758, 3360, 2718, 3754, 7440, 2781, 6756, 7314,
208, 5252, 696, 527, 1399, 5879, 6868, 217, 7681, 3788, 1337, 2424,
4243, 5686, 1955, 4791, 492, 1518, 6566, 5349, 506, 113, 1953, 2797,
934, 3023, 3632, 1330, 4909, 4867, 1183, 3990, 6217, 1224, 1733, 2319,
3928, 2380, 841, 5049, 7027, 1197, 7208, 8000, 152, 6762, 3745, 4723,
5502, 4796, 123, 8142, 5091, 7875, 330, 5272, 4912, 374, 2045, 6616,
6321, 7605, 2570, 2419, 1234, 1922, 4317, 5110, 825, 958, 1089, 7813,
6058, 7703, 6702, 1714, 6371, 2281, 1986, 6282, 3201, 3760, 1056, 6233,
1150, 2823, 6250, 645, 2401, 1639, 2946, 7091, 923, 7045, 6493, 1706,
5836, 926, 6086, 950, 5905, 3240, 6675, 3197, 1555, 3589, 4555, 5671,
6948, 4664, 2086, 5950, 5521, 1515)
L5Q_XB_adv = ( # PRN 1 - 210
1701, 323, 5292, 2020, 5429, 7136, 1041, 5947, 4315, 148, 535, 1939,
5206, 5910, 3595, 5135, 6082, 6990, 3546, 1523, 4548, 4484, 1893, 3961,
7106, 5299, 4660, 276, 4389, 3783, 1591, 1601, 749, 1387, 1661, 3210,
708, 4226, 5604, 6375, 3056, 1772, 3662, 4401, 5218, 2838, 6913, 1685,
1194, 6963, 5001, 6694, 991, 7489, 2441, 639, 2097, 2498, 6470, 2399,
242, 3768, 1186, 5246, 4259, 5907, 3870, 3262, 7387, 3069, 2999, 7993,
7849, 4157, 5031, 5986, 4833, 5739, 7846, 898, 2022, 7446, 6404, 155,
7862, 7795, 6121, 4840, 6585, 429, 6020, 200, 1664, 1499, 7298, 1305,
7323, 7544, 4438, 2485, 3387, 7319, 1853, 5781, 1874, 7555, 2132, 6441,
6722, 1192, 2588, 2188, 297, 1540, 4138, 5231, 4789, 659, 871, 6837,
1393, 7383, 611, 4920, 5416, 1611, 2474, 118, 1382, 1092, 7950, 7223,
1769, 4721, 1252, 5147, 2165, 7897, 4054, 3498, 6571, 2858, 8126, 7017,
1901, 181, 1114, 5195, 7479, 4186, 3904, 7128, 1396, 4513, 5967, 2580,
2575, 7961, 2598, 4508, 2090, 3685, 7748, 684, 913, 5558, 2894, 5858,
6432, 3813, 3573, 7523, 5280, 3376, 7424, 2918, 5793, 1747, 7079, 2921,
2490, 4119, 3373, 977, 681, 4273, 5419, 5626, 1266, 5804, 2414, 6444,
4757, 427, 5452, 5182, 6606, 6531, 4268, 3115, 6835, 862, 4856, 2765,
37, 1943, 7977, 2512, 4451, 4071)
L6D_R_init = ( # PRN 193 - 201
0o00255021, 0o00327455, 0o00531421, 0o00615350, 0o00635477, 0o00000000,
0o01715254, 0o01741247, 0o02322713)
L6E_R_init = ( # PRN 203 - 211
0o01142153, 0o01723711, 0o03672765, 0o00030404, 0o00000546, 0o00000000,
0o03642512, 0o00255043, 0o02020075)
E5AI_X2_init = ( # PRN 1 - 50
0o30305, 0o14234, 0o27213, 0o20577, 0o23312, 0o33463, 0o15614, 0o12537,
0o01527, 0o30236, 0o27344, 0o07272, 0o36377, 0o17046, 0o06434, 0o15405,
0o24252, 0o11631, 0o24776, 0o00630, 0o11560, 0o17272, 0o27445, 0o31702,
0o13012, 0o14401, 0o34727, 0o22627, 0o30623, 0o27256, 0o01520, 0o14211,
0o31465, 0o22164, 0o33516, 0o02737, 0o21316, 0o35425, 0o35633, 0o24655,
0o14054, 0o27027, 0o06604, 0o31455, 0o34465, 0o25273, 0o20763, 0o31721,
0o17312, 0o13277)
E5AQ_X2_init = ( # PRN 1 - 50
0o25652, 0o05142, 0o24723, 0o31751, 0o27366, 0o24660, 0o33655, 0o27450,
0o07626, 0o01705, 0o12717, 0o32122, 0o16075, 0o16644, 0o37556, 0o02477,
0o02265, 0o06430, 0o25046, 0o12735, 0o04262, 0o11230, 0o00037, 0o06137,
0o04312, 0o20606, 0o11162, 0o22252, 0o30533, 0o24614, 0o07767, 0o32705,
0o05052, 0o27553, 0o03711, 0o02041, 0o34775, 0o05274, 0o37356, 0o16205,
0o36270, 0o06600, 0o26773, 0o17375, 0o35267, 0o36255, 0o12044, 0o26442,
0o21621, 0o25411)
E5BI_X2_init = ( # PRN 1 - 50
0o07220, 0o26047, 0o00252, 0o17166, 0o14161, 0o02540, 0o01537, 0o26023,
0o01725, 0o20637, 0o02364, 0o27731, 0o30640, 0o34174, 0o06464, 0o07676,
0o32231, 0o10353, 0o00755, 0o26077, 0o11644, 0o11537, 0o35115, 0o20452,
0o34645, 0o25664, 0o21403, 0o32253, 0o02337, 0o30777, 0o27122, 0o22377,
0o36175, 0o33075, 0o33151, 0o13134, 0o07433, 0o10216, 0o35466, 0o02533,
0o05351, 0o30121, 0o14010, 0o32576, 0o30326, 0o37433, 0o26022, 0o35770,
0o06670, 0o12017)
E5BQ_X2_init = ( # PRN 1 - 50
0o03331, 0o06143, 0o25322, 0o23371, 0o00413, 0o36235, 0o17750, 0o04745,
0o13005, 0o37140, 0o30155, 0o20237, 0o03461, 0o31662, 0o27146, 0o05547,
0o02456, 0o30013, 0o00322, 0o10761, 0o26767, 0o36004, 0o30713, 0o07662,
0o21610, 0o20134, 0o11262, 0o10706, 0o34143, 0o11051, 0o25460, 0o17665,
0o32354, 0o21230, 0o20146, 0o11362, 0o37246, 0o16344, 0o15034, 0o25471,
0o25646, 0o22157, 0o04336, 0o16356, 0o04075, 0o02626, 0o11706, 0o37011,
0o27041, 0o31024)
B1I_ph_sel = ( # PRN 1 - 63
(1, 3) , (1, 4) , (1, 5) , (1, 6) , (1, 8) , (1, 9) ,
(1, 10) , (1, 11) , (2, 7) , (3, 4) , (3, 5) , (3, 6) ,
(3, 8) , (3, 9) , (3, 10) , (3, 11) , (4, 5) , (4, 6) ,
(4, 8) , (4, 9) , (4, 10) , (4, 11) , (5, 6) , (5, 8) ,
(5, 9) , (5, 10) , (5, 11) , (6, 8) , (6, 9) , (6, 10) ,
(6, 11) , (8, 9) , (8, 10) , (8, 11) , (9, 10) , (9, 11) ,
(10, 11) , (1, 2, 7) , (1, 3, 4), (1, 3, 6) , (1, 3, 8) , (1, 3, 10),
(1, 3, 11), (1, 4, 5) , (1, 4, 9), (1, 5, 6) , (1, 5, 8) , (1, 5, 10),
(1, 5, 11), (1, 6, 9) , (1, 8, 9), (1, 9, 10), (1, 9, 11), (2, 3, 7) ,
(2, 5, 7) , (2, 7, 9) , (3, 4, 5), (3, 4, 9) , (3, 5, 6) , (3, 5, 8) ,
(3, 5, 10), (3, 5, 11), (3, 6, 9))
B1CD_ph_diff = ( # PRN 1 - 63
2678, 4802, 958, 859, 3843, 2232, 124, 4352, 1816, 1126, 1860, 4800,
2267, 424, 4192, 4333, 2656, 4148, 243, 1330, 1593, 1470, 882, 3202,
5095, 2546, 1733, 4795, 4577, 1627, 3638, 2553, 3646, 1087, 1843, 216,
2245, 726, 1966, 670, 4130, 53, 4830, 182, 2181, 2006, 1080, 2288,
2027, 271, 915, 497, 139, 3693, 2054, 4342, 3342, 2592, 1007, 310,
4203, 455, 4318)
B1CD_trunc_pnt = ( # PRN 1 - 63
699, 694, 7318, 2127, 715, 6682, 7850, 5495, 1162, 7682, 6792, 9973,
6596, 2092, 19,10151, 6297, 5766, 2359, 7136, 1706, 2128, 6827, 693,
9729, 1620, 6805, 534, 712, 1929, 5355, 6139, 6339, 1470, 6867, 7851,
1162, 7659, 1156, 2672, 6043, 2862, 180, 2663, 6940, 1645, 1582, 951,
6878, 7701, 1823, 2391, 2606, 822, 6403, 239, 442, 6769, 2560, 2502,
5072, 7268, 341)
B1CP_ph_diff = ( # PRN 1 - 63
796, 156, 4198, 3941, 1374, 1338, 1833, 2521, 3175, 168, 2715, 4408,
3160, 2796, 459, 3594, 4813, 586, 1428, 2371, 2285, 3377, 4965, 3779,
4547, 1646, 1430, 607, 2118, 4709, 1149, 3283, 2473, 1006, 3670, 1817,
771, 2173, 740, 1433, 2458, 3459, 2155, 1205, 413, 874, 2463, 1106,
1590, 3873, 4026, 4272, 3556, 128, 1200, 130, 4494, 1871, 3073, 4386,
4098, 1923, 1176)
B1CP_trunc_pnt = ( # PRN 1 - 63
7575, 2369, 5688, 539, 2270, 7306, 6457, 6254, 5644, 7119, 1402, 5557,
5764, 1073, 7001, 5910,10060, 2710, 1546, 6887, 1883, 5613, 5062, 1038,
10170, 6484, 1718, 2535, 1158, 526, 7331, 5844, 6423, 6968, 1280, 1838,
1989, 6468, 2091, 1581, 1453, 6252, 7122, 7711, 7216, 2113, 1095, 1628,
1713, 6102, 6123, 6070, 1115, 8047, 6795, 2575, 53, 1729, 6388, 682,
5565, 7160, 2277)
B1CS_ph_diff = ( # PRN 1 - 63
269, 1448, 1028, 1324, 822, 5, 155, 458, 310, 959, 1238, 1180,
1288, 334, 885, 1362, 181, 1648, 838, 313, 750, 225, 1477, 309,
108, 1457, 149, 322, 271, 576, 1103, 450, 399, 241, 1045, 164,
513, 687, 422, 303, 324, 495, 725, 780, 367, 882, 631, 37,
647, 1043, 24, 120, 134, 136, 158, 214, 335, 340, 661, 889,
929, 1002, 1149)
B1CS_trunc_pnt = ( # PRN 1 - 63
1889, 1268, 1593, 1186, 1239, 1930, 176, 1696, 26, 1344, 1271, 1182,
1381, 1604, 1333, 1185, 31, 704, 1190, 1646, 1385, 113, 860, 1656,
1921, 1173, 1928, 57, 150, 1214, 1148, 1458, 1519, 1635, 1257, 1687,
1382, 1514, 1, 1583, 1806, 1664, 1338, 1111, 1706, 1543, 1813, 228,
2871, 2884, 1823, 75, 11, 63, 1937, 22, 1768, 1526, 1402, 1445,
1680, 1290, 1245)
B2AD_G2_init = ( # PRN 1 - 63
0b1000000100101, 0b1000000110100, 0b1000010101101, 0b1000101001111,
0b1000101010101, 0b1000110101110, 0b1000111101110, 0b1000111111011,
0b1001100101001, 0b1001111011010, 0b1010000110101, 0b1010001000100,
0b1010001010101, 0b1010001011011, 0b1010001011100, 0b1010010100011,
0b1010011110111, 0b1010100000001, 0b1010100111110, 0b1010110101011,
0b1010110110001, 0b1011001010011, 0b1011001100010, 0b1011010011000,
0b1011010110110, 0b1011011110010, 0b1011011111111, 0b1011100010010,
0b1011100111100, 0b1011110100001, 0b1011111001000, 0b1011111010100,
0b1011111101011, 0b1011111110011, 0b1100001010001, 0b1100010010100,
0b1100010110111, 0b1100100010001, 0b1100100011001, 0b1100110101011,
0b1100110110001, 0b1100111010010, 0b1101001010101, 0b1101001110100,
0b1101011001011, 0b1101101010111, 0b1110000110100, 0b1110010000011,
0b1110010001011, 0b1110010100011, 0b1110010101000, 0b1110100111011,
0b1110110010111, 0b1111001001000, 0b1111010010100, 0b1111010011001,
0b1111011011010, 0b1111011111000, 0b1111011111111, 0b1111110110101,
0b0010000000010, 0b1101111110101, 0b0001111010010)
B2AP_G2_init = ( # PRN 1 - 63
0b1000000100101, 0b1000000110100, 0b1000010101101, 0b1000101001111,
0b1000101010101, 0b1000110101110, 0b1000111101110, 0b1000111111011,
0b1001100101001, 0b1001111011010, 0b1010000110101, 0b1010001000100,
0b1010001010101, 0b1010001011011, 0b1010001011100, 0b1010010100011,
0b1010011110111, 0b1010100000001, 0b1010100111110, 0b1010110101011,
0b1010110110001, 0b1011001010011, 0b1011001100010, 0b1011010011000,
0b1011010110110, 0b1011011110010, 0b1011011111111, 0b1011100010010,
0b1011100111100, 0b1011110100001, 0b1011111001000, 0b1011111010100,
0b1011111101011, 0b1011111110011, 0b1100001010001, 0b1100010010100,
0b1100010110111, 0b1100100010001, 0b1100100011001, 0b1100110101011,
0b1100110110001, 0b1100111010010, 0b1101001010101, 0b1101001110100,
0b1101011001011, 0b1101101010111, 0b1110000110100, 0b1110010000011,
0b1110010001011, 0b1110010100011, 0b1110010101000, 0b1110100111011,
0b1110110010111, 0b1111001001000, 0b1111010010100, 0b1111010011001,
0b1111011011010, 0b1111011111000, 0b1111011111111, 0b1111110110101,
0b1010010000110, 0b0010111111000, 0b0001101010101)
B2AS_ph_diff = ( # PRN 1 - 63
123, 55, 40, 139, 31, 175, 350, 450, 478, 8, 73, 97,
213, 407, 476, 4, 15, 47, 163, 280, 322, 353, 375, 510,
332, 7, 13, 16, 18, 25, 50, 81, 118, 127, 132, 134,
164, 177, 208, 249, 276, 349, 439, 477, 498, 88, 155, 330,
3, 21, 84, 111, 128, 153, 197, 199, 214, 256, 265, 291,
324, 326, 340)
B2AS_trunc_pnt = ( # PRN 1 - 63
138, 570, 351, 77, 885, 247, 413, 180, 3, 26, 17, 172,
30, 1008, 646, 158, 170, 99, 53, 179, 925, 114, 10, 584,
60, 3, 684, 263, 545, 22, 546, 190, 303, 234, 38, 822,
57, 668, 697, 93, 18, 66, 318, 133, 98, 70, 132, 26,
354, 58, 41, 182, 944, 205, 23, 1, 792, 641, 83, 7,
111, 96, 92)
B2BI_G2_init = ( # PRN 1 - 63
0b1000000100101, 0b1000000110100, 0b1000010101101, 0b1000101001111,
0b1000101010101, 0b1000110101110, 0b1000111101110, 0b1000111111011,
0b1001100101001, 0b1001111011010, 0b1010000110101, 0b1010001000100,
0b1010001010101, 0b1010001011011, 0b1010001011100, 0b1010010100011,
0b1010011110111, 0b1010100000001, 0b1010100111110, 0b1010110101011,
0b1010110110001, 0b1011001010011, 0b1011001100010, 0b1011010011000,
0b1011010110110, 0b1011011110010, 0b1011011111111, 0b1011100010010,
0b1011100111100, 0b1011110100001, 0b1011111001000, 0b1011111010100,
0b1011111101011, 0b1011111110011, 0b1100001010001, 0b1100010010100,
0b1100010110111, 0b1100100010001, 0b1100100011001, 0b1100110101011,
0b1100110110001, 0b1100111010010, 0b1101001010101, 0b1101001110100,
0b1101011001011, 0b1101101010111, 0b1110000110100, 0b1110010000011,
0b1110010001011, 0b1110010100011, 0b1110010101000, 0b1110100111011,
0b1110110010111, 0b1111001001000, 0b1111010010100, 0b1111010011001,
0b1111011011010, 0b1111011111000, 0b1111011111111, 0b1111110110101,
0b1111110111101, 0b0101110000101, 0b0101100111011)
B3I_G2_init = ( # PRN 1 - 63
0b1010111111111, 0b1111000101011, 0b1011110001010, 0b1111111111011,
0b1100100011111, 0b1001001100100, 0b1111111010010, 0b1110111111101,
0b1010000000010, 0b0010000011011, 0b1110101110000, 0b0010110011110,
0b0110010010101, 0b0111000100110, 0b1000110001001, 0b1110001111100,
0b0010011000101, 0b0000011101100, 0b1000101010111, 0b0001011011110,
0b0010000101101, 0b0010110001010, 0b0001011001111, 0b0011001100010,
0b0011101001000, 0b0100100101001, 0b1011011010011, 0b1010111100010,
0b0001011110101, 0b0111111111111, 0b0110110001111, 0b1010110001001,
0b1001010101011, 0b1100110100101, 0b1101001011101, 0b1111101110100,
0b0010101100111, 0b1110100010000, 0b1101110010000, 0b1101011001110,
0b1000000110100, 0b0101111011001, 0b0110110111100, 0b1101001110001,
0b0011100100010, 0b0101011000101, 0b1001111100110, 0b1111101001000,
0b0000101001001, 0b1000010101100, 0b1111001001100, 0b0100110001111,
0b0000000011000, 0b1000000000100, 0b0011010100110, 0b1011001000110,
0b0111001111000, 0b0010111001010, 0b1100111110110, 0b1001001000101,
0b0111000100000, 0b0011001000010, 0b0010001001110)
I5S_G2_init = ( # PRN 1 - 14
0b1110100111, 0b0000100110, 0b1000110100, 0b0101110010, 0b1110110000,
0b0001101011, 0b0000010100, 0b0100110000, 0b0010011000, 0b1101100100,
0b0001001100, 0b1101111100, 0b1011010010, 0b0111101010)
ISS_G2_init = ( # PRN 1 - 14
0b0011101111, 0b0101111101, 0b1000110001, 0b0010101011, 0b1010010001,
0b0100101100, 0b0010001110, 0b0100100110, 0b1100001110, 0b1010111110,
0b1110010001, 0b1101101001, 0b0101000101, 0b0100001101)
NH10 = ( # 10 bits Neuman-Hoffman code
-1, -1, -1, -1, 1, 1, -1, 1, -1, 1)
NH20 = ( # 20 bits Neuman-Hoffman code
-1, -1, -1, -1, -1, 1, -1, -1, 1, 1, -1, 1, -1, 1, -1, -1, 1, 1, 1, -1)
BC = ( # Baker code
-1, -1, -1, 1, -1)
#-------------------------------------------------------------------------------
# Generate primary code.
#
# args:
# sig (I) Signal type as string ('L1CA', 'L1CB', 'L1CP', ....)
# prn (I) PRN number
#
# returns:
# code Primary code as int8 ndarray (-1 or 1)
# (sub-carrier modulated for BOC or zero-padded for TDM)
#
def gen_code(sig, prn):
sig = sig.upper()
if sig == 'L1CA':
return gen_code_L1CA(prn)
elif sig == 'L1S':
return gen_code_L1S(prn)
elif sig == 'L1CB':
return gen_code_L1CB(prn)
elif sig == 'L1CP':
return gen_code_L1CP(prn)
elif sig == 'L1CD':
return gen_code_L1CD(prn)
elif sig == 'L2CM':
return gen_code_L2CM(prn)
elif sig == 'L2CL':
return gen_code_L2CL(prn)
elif sig == 'L5I':
return gen_code_L5I(prn)
elif sig == 'L5Q':
return gen_code_L5Q(prn)
elif sig == 'L5SI':
return gen_code_L5SI(prn)
elif sig == 'L5SQ':
return gen_code_L5SQ(prn)
elif sig == 'L6D':
return gen_code_L6D(prn)
elif sig == 'L6E':
return gen_code_L6E(prn)
elif sig == 'G1CA':
return gen_code_G1CA(prn)
elif sig == 'G2CA':
return gen_code_G2CA(prn)
elif sig == 'G3OCD':
return gen_code_G3OCD(prn)
elif sig == 'G3OCP':
return gen_code_G3OCP(prn)
elif sig == 'E1B':
return gen_code_E1B(prn)
elif sig == 'E1C':
return gen_code_E1C(prn)
elif sig == 'E5AI':
return gen_code_E5AI(prn)
elif sig == 'E5AQ':
return gen_code_E5AQ(prn)
elif sig == 'E5BI':
return gen_code_E5BI(prn)
elif sig == 'E5BQ':
return gen_code_E5BQ(prn)
elif sig == 'E6B':
return gen_code_E6B(prn)
elif sig == 'E6C':
return gen_code_E6C(prn)
elif sig == 'B1I':
return gen_code_B1I(prn)
elif sig == 'B1CD':
return gen_code_B1CD(prn)
elif sig == 'B1CP':
return gen_code_B1CP(prn)
elif sig == 'B2I':
return gen_code_B2I(prn)
elif sig == 'B2AD':
return gen_code_B2AD(prn)
elif sig == 'B2AP':
return gen_code_B2AP(prn)
elif sig == 'B2BI':
return gen_code_B2BI(prn)
elif sig == 'B3I':
return gen_code_B3I(prn)
elif sig == 'I5S':
return gen_code_I5S(prn)
elif sig == 'ISS':
return gen_code_ISS(prn)
else:
return NONE
#-------------------------------------------------------------------------------
# Generate secondary (overlay) code.
#
# args:
# sig (I) Signal type as string ('L1CA', 'L1CB', 'L1CP', ....)
# prn (I) PRN number
#
# returns:
# code Secondary code as int8 ndarray (-1 or 1)
#
def sec_code(sig, prn):
sig = sig.upper()
if sig in ('L1CA', 'L1S', 'L1CB','L1CD', 'L2CM', 'L2CL', 'L6D', 'L6E', 'E1B',
'E6B', 'B1CD', 'B2BI', 'I5S', 'ISS'):
return np.array([1], dtype='int8') # no secondary code
elif sig == 'L1CP':
return sec_code_L1CP(prn)
elif sig == 'L5I':
return sec_code_L5I(prn)
elif sig == 'L5Q':
return sec_code_L5Q(prn)
elif sig == 'L5SI':
return sec_code_L5SI(prn)
elif sig == 'L5SQ':
return sec_code_L5SQ(prn)
elif sig == 'G1CA':
return sec_code_G1CA(prn)
elif sig == 'G2CA':
return sec_code_G2CA(prn)
elif sig == 'G3OCD':
return sec_code_G3OCD(prn)
elif sig == 'G3OCP':
return sec_code_G3OCP(prn)
elif sig == 'E1C':
return sec_code_E1C(prn)
elif sig == 'E5AI':
return sec_code_E5AI(prn)
elif sig == 'E5AQ':
return sec_code_E5AQ(prn)
elif sig == 'E5BI':
return sec_code_E5BI(prn)
elif sig == 'E5BQ':
return sec_code_E5BQ(prn)
elif sig == 'E6C':
return sec_code_E6C(prn)
elif sig == 'B1I':
return sec_code_B1I(prn)
elif sig == 'B1CP':
return sec_code_B1CP(prn)
elif sig == 'B2I':
return sec_code_B2I(prn)
elif sig == 'B2AD':
return sec_code_B2AD(prn)
elif sig == 'B2AP':
return sec_code_B2AP(prn)
elif sig == 'B3I':
return sec_code_B3I(prn)
else:
return NONE
#-------------------------------------------------------------------------------
# Generate resampled and zero-padded code.
#
# args:
# code (I) Code as int8 ndarray (-1 or 1)
# T (I) Code cycle (period) (s)
# coff (I) Code offset (s)
# fs (I) Sampling frequency (Hz)
# N (I) Number of samples
# Nz=0 (I) Number of zero-padding (optional)
#
# returns:
# code Resampled and zero-padded code as complex64 ndarray (-1 or 1)
#
def res_code(code, T, coff, fs, N, Nz=0):
dx = len(code) / T / fs
ix = ((coff * fs + | np.arange(N) | numpy.arange |
import sys
sys.path.append('../')
import numpy as np
import cv2
import math
import os
from ObstacleDetectionObjectives import numpy_iou
class Obstacle(object):
def __init__(self, x, y, w, h, depth_seg=None, obs_stats=None, conf_score=None, iou=None):
self.x = int(x) #top
self.y = int(y) #left
self.w = int(w)
self.h = int(h)
self.valid_points = -1 #obstacle area
self.max_iou = None
self.multiple_detection_flag = False
if depth_seg is not None:
self.segmentation = depth_seg[1]
self.depth_mean, self.depth_variance, self.valid_points = self.compute_depth_stats(depth_seg[0])
elif obs_stats is not None:
self.segmentation = None
self.depth_mean = obs_stats[0]
self.depth_variance = obs_stats[1]
if conf_score is not None:
self.confidence = conf_score
def compute_depth_stats(self, depth):
if len(depth.shape) == 4:
roi_depth = depth[0, self.y:self.y+self.h, self.x:self.x+self.w, 0]
else:
roi_depth = depth[self.y:self.y+self.h, self.x:self.x+self.w]
mean_depth = 0
squared_sum = 0
valid_points = 0
for y in range(0, self.h):
for x in range(0, self.w):
if roi_depth[y,x] < 20 and roi_depth[y,x] > 0.0:
mean_depth += roi_depth.item(y, x)
squared_sum += roi_depth.item(y, x)**2
valid_points += 1
if valid_points > 0:
mean_depth /= valid_points
var_depth = (squared_sum / valid_points) - (mean_depth**2)
else:
mean_depth = -1
var_depth = -1
return mean_depth, var_depth, valid_points
def evaluate_estimation(self, estimated_depth):
estimated_mean, estimated_var, valid_points = self.compute_depth_stats(estimated_depth)
mean_rmse = (self.depth_mean - estimated_mean)**2
mean_variance = (self.depth_variance - estimated_var)**2
return np.sqrt(mean_rmse + 1e-6), np.sqrt(mean_variance + 1e-6), valid_points
def set_iou(self, iou):
self.max_iou = iou
return
def set_detection_duplicated_flag(self):
self.multiple_detection_flag = True
return
def get_bbox(self):
return [self.x, self.y, self.x+self.w, self.y+self.h]
def depth_to_meters_airsim(depth):
depth = depth.astype(np.float64)
for i in range(0, depth.shape[0]):
for j in range(0, depth.shape[1]):
depth[i,j] = (-4.586e-09 * (depth[i,j] ** 4.)) + (3.382e-06 * (depth[i,j] ** 3.)) - (0.000105 * (depth[i,j] ** 2.)) + (0.04239 * depth[i,j]) + 0.04072
return depth
def depth_to_meters_base(depth):
return depth * 39.75 / 255.
def get_obstacles_from_list(list):
obstacles = []
for obstacle_def in list:
obstacle = Obstacle(obstacle_def[0][0], obstacle_def[0][1], obstacle_def[0][2], obstacle_def[0][3], obs_stats=(obstacle_def[1][0], obstacle_def[1][1]), conf_score=obstacle_def[2])
obstacles.append(obstacle)
return obstacles
def get_detected_obstacles_from_detector_v1(prediction, confidence_thr=0.5, output_img=None):
def sigmoid(x):
return 1 / (1 + math.exp(-x))
if len(prediction.shape) == 4:
prediction = np.expand_dims(prediction, axis=0)
confidence = []
conf_pred = prediction[0, :, 0]
x_pred = prediction[0, :, 1]
y_pred = prediction[0, :, 2]
w_pred = prediction[0, :, 3]
h_pred = prediction[0, :, 4]
mean_pred = prediction[0, :, 5]
var_pred = prediction[0, :, 6]
# img shape
IMG_WIDTH = 256.
IMG_HEIGHT = 160.
# obstacles list
detected_obstacles = []
for i in range(0, 40):
val_conf = sigmoid(conf_pred[i])
if val_conf >= confidence_thr:
x = sigmoid(x_pred[i])
y = sigmoid(y_pred[i])
w = sigmoid(w_pred[i]) * IMG_WIDTH
h = sigmoid(h_pred[i]) * IMG_HEIGHT
mean = mean_pred[i] * 25
var = var_pred[i] * 100
x_top_left = np.floor(((x + int(i % 8)) * 32.) - (w / 2.))
y_top_left = np.floor(((y + (i / 8)) * 32.) - (h / 2.))
if output_img is not None:
cv2.rectangle(output_img, (x_top_left, y_top_left), (x_top_left+int(w), y_top_left+int(h)), (0,0,255), 2)
detected_obstacles.append([(x_top_left, y_top_left, w, h), (mean, var), val_conf])
obstacles = get_obstacles_from_list(detected_obstacles)
return obstacles, output_img
def get_detected_obstacles_from_detector_v2(prediction, confidence_thr=0.5, output_img=None):
def sigmoid(x):
return 1 / (1 + math.exp(-x))
if len(prediction.shape) == 4:
prediction = np.expand_dims(prediction, axis=0)
confidence = []
conf_pred = prediction[0, :, :, :, 0]
x_pred = prediction[0, :, :, :, 1]
y_pred = prediction[0, :, :, :, 2]
w_pred = prediction[0, :, :, :, 3]
h_pred = prediction[0, :, :, :, 4]
mean_pred = prediction[0, :, :, :, 5]
var_pred = prediction[0, :, :, :, 6]
# img shape
IMG_WIDTH = 256.
IMG_HEIGHT = 160.
# Anchors
anchors = np.array([[0.21651918, 0.78091232],
[0.85293483, 0.96561908]], dtype=np.float32)
#anchors = np.array([[0.14461305, 0.2504421],
# [0.35345449, 0.8233705]], dtype=np.float32)
# obstacles list
detected_obstacles = []
for i in range(0, 5):
for j in range(0, 8):
for k in range(0, 2):
val_conf = sigmoid(conf_pred[i, j, k])
if val_conf >= confidence_thr:
x = sigmoid(x_pred[i, j, k])
y = sigmoid(y_pred[i, j, k])
w = np.exp(w_pred[i, j, k]) * anchors[k, 0] * IMG_WIDTH
h = np.exp(h_pred[i, j, k]) * anchors[k, 1] * IMG_HEIGHT
mean = mean_pred[i, j, k] * 25
var = var_pred[i, j, k] * 100
x_top_left = np.floor(((x + j) * 32.) - (w / 2.))
y_top_left = np.floor(((y + i) * 32.) - (h / 2.))
if output_img is not None:
cv2.rectangle(output_img, (x_top_left, y_top_left), (x_top_left+int(w), y_top_left+int(h)), (0,0,255), 2)
detected_obstacles.append([(x_top_left, y_top_left, w, h), (mean, var), val_conf])
obstacles = get_obstacles_from_list(detected_obstacles)
return obstacles, output_img
def rmse_error_on_vector(y_true, y_pred):
# mean error
mean = np.mean(np.square(y_true - y_pred))# / float(np.count_nonzero(y_true) + 1e-6)
rmse_error = np.sqrt(mean + 1e-6)
return rmse_error
def sc_inv_logrmse_error_on_vector(y_true, y_pred):
first_log = np.log(y_pred + 1.)
second_log = np.log(y_true + 1.)
log_term = np.mean(np.square((first_log - second_log)))# / (np.count_nonzero(first_log) + 1e-6)
sc_inv_term = np.square(np.mean(first_log - second_log))# / (np.count_nonzero(first_log)**2 + 1e-6)
error = log_term - sc_inv_term
return error
def rmse_log_error_on_matrix(y_true, y_pred):
y_true = y_true.flatten()
y_pred = y_pred.flatten()
#
diff = np.square(np.log(y_pred + 1) - | np.log(y_true + 1) | numpy.log |
import six.moves.cPickle as pickle
import gzip
import os
from pycode.tinyflow import autodiff as ad
from pycode.tinyflow import ndarray
from pycode.tinyflow import gpu_op
from pycode.tinyflow import TrainExecuteAdam
import numpy as np
import random
from pycode.tinyflow import train
import pickle
import time
class_num = 10
image_size = 32
img_channels = 3
iterations = 200
batch_size = 100
weight_decay = 0.0003
dropout_rate = 0.5
momentum_rate = 0.9
data_dir = './cifar-10/'
log_save_path = './vgg_16_logs'
model_save_path = './model/'
# 读文件
def unpickle(file):
with open(file, 'rb') as fo:
dict = pickle.load(fo, encoding='latin1')
return dict
# 从读入的文件中获取图片数据(data)和标签信息(labels)
def load_data_one(file):
batch = unpickle(file)
data = batch['data']
labels = batch['labels']
print("Loading %s : img num %d." % (file, len(data)))
return data, labels
# 将从文件中获取的信息进行处理，得到可以输入到神经网络中的数据。
def load_data(files, data_dir, label_count):
global image_size, img_channels
data, labels = load_data_one(data_dir + files[0])
for f in files[1:]:
data_n, labels_n = load_data_one(data_dir + f)
data = np.append(data, data_n, axis=0)
labels = np.append(labels, labels_n, axis=0)
# 标签labels从0-9的数字转化为float类型(-1,10)的标签矩阵
labels = np.array([[float(i == label) for i in range(label_count)] for label in labels])
# 将图片数据从(-1,3072)转化为(-1,3,32,32)
data = data.reshape([-1, img_channels, image_size, image_size])
# 将(-1,3,32,32)转化为(-1,32,32,3)的图片标准输入
# data = data.transpose([0, 2, 3, 1])
# data数据归一化
data = data.astype('float32')
data[:, :, :, 0] = (data[:, :, :, 0] - np.mean(data[:, :, :, 0])) / np.std(data[:, :, :, 0])
data[:, :, :, 1] = (data[:, :, :, 1] - np.mean(data[:, :, :, 1])) / np.std(data[:, :, :, 1])
data[:, :, :, 2] = (data[:, :, :, 2] - np.mean(data[:, :, :, 2])) / np.std(data[:, :, :, 2])
return data, labels
def prepare_data():
print("======Loading data======")
image_dim = image_size * image_size * img_channels
meta = unpickle(data_dir + 'batches.meta')
print(meta)
label_names = meta['label_names']
# 依次读取data_batch_1-5的内容
train_files = ['data_batch_%d' % d for d in range(1, 6)]
train_data, train_labels = load_data(train_files, data_dir, class_num)
test_data, test_labels = load_data(['test_batch'], data_dir, class_num)
print("Train data:", np.shape(train_data), np.shape(train_labels))
print("Test data :", np.shape(test_data), np.shape(test_labels))
print("======Load finished======")
# 重新打乱训练集的顺序
indices = np.random.permutation(len(train_data))
train_data = train_data[indices]
train_labels = train_labels[indices]
print("======数据准备结束======")
return train_data, train_labels, test_data, test_labels
def sgd_update_gpu(param, grad_param, learning_rate):
"""Helper GPU SGD update method. Avoids copying NDArray to cpu."""
assert isinstance(param, ndarray.NDArray)
assert isinstance(grad_param, ndarray.NDArray)
gpu_op.matrix_elementwise_multiply_by_const(
grad_param, -learning_rate, grad_param)
gpu_op.matrix_elementwise_add(param, grad_param, param)
def convert_to_one_hot(vals):
"""Helper method to convert label array to one-hot array."""
one_hot_vals = np.zeros((vals.size, vals.max()+1))
one_hot_vals[ | np.arange(vals.size) | numpy.arange |
import numpy as np
import argparse
import sys
import os
from sklearn.linear_model import LogisticRegression
from sklearn import svm
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV
from sklearn.datasets import load_svmlight_file
from sklearn.decomposition import PCA
from ope_estimators import OPEestimators
alphas = [0.7, 0.4, 0.1]
def process_args(arguments):
parser = argparse.ArgumentParser(
description='Off-policy Evaluation',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('--dataset', '-d', type=str, default='satimage',
help='Name of dataset')
parser.add_argument('--history_sample_size', '-s', type=int, default=1000,
help='Sample size')
parser.add_argument('--num_trials', '-n', type=int, default=100,
help='The number of trials')
parser.add_argument('--preset', '-p', type=str, default=None,
choices=['satimage', 'vehicle', 'pendigits'],
help="Presets of configuration")
args = parser.parse_args(arguments)
return args
def data_generation(data_name, N):
X, Y = load_svmlight_file('data/{}'.format(data_name))
X = X.toarray()
maxX = X.max(axis=0)
maxX[maxX == 0] = 1
X = X / maxX
Y = np.array(Y, np.int64)
perm = np.random.permutation(len(X))
X, Y = X[perm[:N]], Y[perm[:N]]
if data_name == 'satimage':
Y = Y - 1
elif data_name == 'vehicle':
Y = Y - 1
elif data_name == 'mnist':
pca = PCA(n_components=100).fit(X)
X = pca.transform(X)
elif data_name == 'letter':
Y = Y - 1
elif data_name == 'Sensorless':
Y = Y - 1
elif data_name == 'connect-4':
Y = Y + 1
classes = np.unique(Y)
Y_matrix = np.zeros(shape=(N, len(classes)))
for i in range(N):
Y_matrix[i, Y[i]] = 1
return X, Y, Y_matrix, classes
def fit_logreg(X, Y):
return LogisticRegression(random_state=0, penalty='l2', C=0.1, solver='saga', multi_class='multinomial').fit(X, Y)
def create_policy(X, classes, classifier, alpha=0.7):
N = len(X)
num_class = len(classes)
predict = np.array(classifier.predict(X), np.int64)
pi_predict = np.zeros(shape=(N, num_class))
for i in range(N):
pi_predict[i, predict[i]] = 1
pi_random = np.random.uniform(size=(N, num_class))
pi_random = pi_random.T
pi_random /= pi_random.sum(axis=0)
pi_random = pi_random.T
policy = alpha * pi_predict + (1 - alpha) * pi_random
return policy
def evaluation_policy(X, A, R, classes, method_list):
N = len(X)
num_class = len(classes)
pi_random = | np.random.uniform(size=(N, num_class)) | numpy.random.uniform |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: percent
# format_version: '1.3'
# jupytext_version: 1.4.2
# kernelspec:
# display_name: Python [conda env:mdd] *
# language: python
# name: conda-env-mdd-py
# ---
# %% jupyter={"outputs_hidden": false}
import numpy as np
import matplotlib.pyplot as pl
# %matplotlib inline
from matplotlib import rcParams
rcParams.update({'figure.figsize': (10, 8)})
rcParams.update({'font.size': 14})
# %% jupyter={"outputs_hidden": false}
fs = 100 # Hz
y = np.loadtxt('../../data/FFT_Example_data_with_window.txt')
t = np.linspace(0,len(y)/fs,len(y))
# %% jupyter={"outputs_hidden": false}
pl.plot(t,y)
pl.xlabel('$t$ [sec]',fontsize=16)
pl.ylabel('$y$ [V]',fontsize=16)
# %% jupyter={"outputs_hidden": false}
# subtract the DC:
yf = y - np.mean(y)
# %% jupyter={"outputs_hidden": false}
pl.plot(t,yf)
pl.xlabel('$t$ [sec]',fontsize=16)
pl.ylabel('$y - DC(y) $ [V]',fontsize=16)
# %% jupyter={"outputs_hidden": false}
def spectrum(y,Fs):
"""
Plots a Single-Sided Amplitude Spectrum of a sampled
signal y(t), sampling frequency Fs (lenght of a signal
provides the number of samples recorded)
Following: http://goo.gl/wRoUn
"""
n = len(y) # length of the signal
k = | np.arange(n) | numpy.arange |
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.parameter import Parameter
import math
import functools
import numpy as np
class Graph:
""" The Graph to model the skeletons extracted by the openpose
Args:
strategy (string): must be one of the follow candidates
- uniform: Uniform Labeling
- distance: Distance Partitioning
- spatial: Spatial Configuration
- directed: Directed graph configuration
For more information, please refer to the section 'Partition Strategies'
in our paper (https://arxiv.org/abs/1801.07455).
layout (string): must be one of the follow candidates
- openpose: Is consists of 18 joints. For more information, please
refer to https://github.com/CMU-Perceptual-Computing-Lab/openpose#output
- ntu-rgb+d: Is consists of 25 joints. For more information, please
refer to https://github.com/shahroudy/NTURGB-D
max_hop (int): the maximal distance between two connected nodes
dilation (int): controls the spacing between the kernel points
"""
def __init__(self,
layout='h36m',
strategy='directed',
max_hop=1,
dilation=1):
self.max_hop = max_hop
self.dilation = dilation
self.get_edge(layout)
if strategy == 'directed':
self.hop_dis = get_directed_hop_distance(self.num_node, self.edge, max_hop=max_hop)
else:
self.hop_dis = get_hop_distance(self.num_node, self.edge, max_hop=max_hop)
self.get_adjacency(strategy)
def __str__(self):
return self.A
def get_edge(self, layout):
if layout == 'h36m':
self.num_node = 17
self_link = [(i, i) for i in range(self.num_node)]
neighbor_link = [(0, 1), (1, 2), (2, 3), (0, 4), (4, 5), (5, 6),
(0, 7), (7, 8), (8, 9), (9, 10), (8, 11), (11, 12),
(12, 13), (8, 14), (14, 15), (15, 16)]
self.edge = self_link + neighbor_link
self.source_nodes = [node[0] for node in neighbor_link]
self.target_nodes = [node[1] for node in neighbor_link]
self.center = 0
elif layout == 'openpose':
self.num_node = 18
self_link = [(i, i) for i in range(self.num_node)]
neighbor_link = [(4, 3), (3, 2), (7, 6), (6, 5), (13, 12), (12, 11),
(10, 9), (9, 8), (11, 5), (8, 2), (5, 1), (2, 1),
(0, 1), (15, 0), (14, 0), (17, 15), (16, 14)]
self.edge = self_link + neighbor_link
self.center = 1
elif layout == 'ntu-rgb+d':
self.num_node = 25
self_link = [(i, i) for i in range(self.num_node)]
neighbor_1base = [(1, 2), (2, 21), (3, 21), (4, 3), (5, 21),
(6, 5), (7, 6), (8, 7), (9, 21), (10, 9),
(11, 10), (12, 11), (13, 1), (14, 13), (15, 14),
(16, 15), (17, 1), (18, 17), (19, 18), (20, 19),
(22, 23), (23, 8), (24, 25), (25, 12)]
neighbor_link = [(i - 1, j - 1) for (i, j) in neighbor_1base]
self.edge = self_link + neighbor_link
self.center = 21 - 1
elif layout == 'ntu_edge':
self.num_node = 24
self_link = [(i, i) for i in range(self.num_node)]
neighbor_1base = [(1, 2), (3, 2), (4, 3), (5, 2), (6, 5), (7, 6),
(8, 7), (9, 2), (10, 9), (11, 10), (12, 11),
(13, 1), (14, 13), (15, 14), (16, 15), (17, 1),
(18, 17), (19, 18), (20, 19), (21, 22), (22, 8),
(23, 24), (24, 12)]
neighbor_link = [(i - 1, j - 1) for (i, j) in neighbor_1base]
self.edge = self_link + neighbor_link
self.center = 2
# elif layout=='customer settings'
# pass
else:
raise ValueError("Do Not Exist This Layout.")
def get_adjacency(self, strategy):
valid_hop = range(0, self.max_hop + 1, self.dilation)
adjacency = np.zeros((self.num_node, self.num_node))
for hop in valid_hop:
adjacency[self.hop_dis == hop] = 1
normalize_adjacency = normalize_undigraph(adjacency)
if strategy == 'uniform':
A = np.zeros((1, self.num_node, self.num_node))
A[0] = normalize_adjacency
self.A = A
elif strategy == 'distance':
A = np.zeros((len(valid_hop), self.num_node, self.num_node))
for i, hop in enumerate(valid_hop):
A[i][self.hop_dis == hop] = normalize_adjacency[self.hop_dis ==
hop]
self.A = A
elif strategy == 'spatial':
A = []
for hop in valid_hop:
a_root = np.zeros((self.num_node, self.num_node))
a_close = np.zeros((self.num_node, self.num_node))
a_further = | np.zeros((self.num_node, self.num_node)) | numpy.zeros |
#!/usr/bin/python
import os, sys, inspect
import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
currentdir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
parentdir = os.path.dirname(currentdir)
sys.path.insert(0,parentdir)
import common
import config as cfg
def calcReads(sample, statsDir):
infile = statsDir + common.findInfile(sample, statsDir, ext='.bincount.stats.txt')
with open(infile, 'r') as IN:
data = IN.readline()
readCount = data.rstrip().split('\t')[1]
return int(readCount)
def calcMAPD(sample, lowessDir):
infile = lowessDir + common.findInfile(sample, lowessDir)
data = np.loadtxt(infile)
MAPD = np.median(abs(data[1:] - data[:-1]))
return MAPD, data
def calcCS(data):
CS = 1 - ( 2 * np.median( abs( data - np.round(data) ) ) )
return CS
def getPloidy(segData, sample, plotDir, cutoff):
ploidyTestValues = np.arange(1.25, 2.76, 0.01)
CSarray = np.zeros(len(ploidyTestValues))
peakPloidy = 1.
peakCS = 0.
for i,j in enumerate(ploidyTestValues):
testData = np.copy(segData) * j
CSarray[i] = calcCS(testData)
if CSarray[i] > peakCS:
peakCS = CSarray[i]
peakPloidy = j
xTicks = np.arange(1.25, 2.76, 0.25)
yTicks = np.arange(0, 1.1, 0.2)
fig, ax = plt.subplots()
ax.plot(ploidyTestValues, CSarray, color='#2000b1', lw=3)
ax.plot([2, 2], [-1, 1.1], color='#6b7c85', lw=0.5, zorder=0)
ax.plot([1., 3], [cutoff, cutoff], color='#6b7c85', lw=0.5, zorder=0)
ax.set_xticks(xTicks)
ax.set_xticklabels(xTicks)
ax.set_xlabel('Ploidy Value', labelpad=5)
ax.set_xlim(1.25, 2.75)
ax.set_yticks(yTicks)
ax.set_yticklabels(yTicks)
ax.set_ylabel('Confidence Score', labelpad=5)
ax.set_ylim(-0.02, 1.02)
ax.tick_params(direction='out', which='both', pad=0., length=3, top='off', right='off')
fig.set_size_inches(4, 4, forward=True)
plt.subplots_adjust(left=0.15, right=0.93, bottom=0.12, top=0.95)
plt.savefig(plotDir + sample + '.ploidyDeterminationPlot.png', dpi=666)
plt.close()
return peakCS, peakPloidy
def getGender(data, chroms, ploidy):
binCN = 2 ** data * ploidy
xData = [y for x,y in enumerate(binCN) if chroms[x] == 'chrX']
xCN = np.median(xData)
xGender = 'NA'
if np.round(xCN) >= 2.:
xGender = 'F'
elif np.round(xCN) <= 1.:
xGender = 'M'
yData = [y for x,y in enumerate(binCN) if chroms[x] == 'chrY']
yCN = np.median(yData)
yGender = 'NA'
if np.round(yCN) < 1.:
yGender = 'F'
elif np.round(yCN) >= 1.:
yGender = 'M'
if xGender == yGender and xGender != 'NA':
gender = xGender
elif (yCN >= 0.25 and xGender == 'M') or np.round(np.percentile(yData, 75)) == 1.:
gender = 'M'
###Note: this is strange, but gender can be indistinguishable in this case,
#so going the more conservative route (for CNV calls) and assuming it is male
elif (yGender == 'F' and | np.round(yCN) | numpy.round |
from styx_msgs.msg import TrafficLight
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
from PIL import Image
from PIL import ImageDraw
from PIL import ImageColor
import time
from scipy.stats import norm
import cv2 as cv
import h5py
from keras.models import load_model
from keras import __version__ as keras_version
class TLClassifierSimple(object):
def __init__(self):
# load the model for the traffic light bounding box detection
SSD_GRAPH_FILE = './models/ssd_mobilenet_v1_coco_11_06_2017/frozen_inference_graph.pb'
detection_graph = self.load_graph(SSD_GRAPH_FILE)
# The input placeholder for the image.
# `get_tensor_by_name` returns the Tensor with the associated name in the Graph.
self.image_tensor = detection_graph.get_tensor_by_name('image_tensor:0')
# Each box represents a part of the image where a particular object was detected.
self.detection_boxes = detection_graph.get_tensor_by_name(
'detection_boxes:0')
# Each score represent how level of confidence for each of the objects.
# Score is shown on the result image, together with the class label.
self.detection_scores = detection_graph.get_tensor_by_name(
'detection_scores:0')
# The classification of the object (integer id).
self.detection_classes = detection_graph.get_tensor_by_name(
'detection_classes:0')
self.sess = tf.Session(graph=detection_graph)
# Load the model for the traffic light state classification
global keras_version
TL_CNN_H5 = './models/tl_state_classifier/model.h5'
f = h5py.File(TL_CNN_H5, mode='r')
model_version = f.attrs.get('keras_version')
keras_version = str(keras_version).encode('utf8')
# if model_version != keras_version:
# print('You are using Keras version ', keras_version,
# ', but the model was built using ', model_version)
global tl_state_model
tl_state_model = load_model(TL_CNN_H5)
global tl_state_graph
tl_state_graph = tf.get_default_graph()
def filter_boxes(self, min_score, boxes, scores, classes):
"""Return boxes with a confidence >= `min_score`"""
n = len(classes)
idxs = []
for i in range(n):
if scores[i] >= min_score and classes[i] == 10:
idxs.append(i)
filtered_boxes = boxes[idxs, ...]
filtered_scores = scores[idxs, ...]
filtered_classes = classes[idxs, ...]
return filtered_boxes, filtered_scores, filtered_classes
def to_image_coords(self, box, height, width):
"""
The original box coordinate output is normalized, i.e [0, 1].
This converts it back to the original coordinate based on the image
size.
"""
box_coords = np.zeros_like(box)
box_coords[0] = box[0] * height
box_coords[1] = box[1] * width
box_coords[2] = box[2] * height
box_coords[3] = box[3] * width
return box_coords
def load_graph(self, graph_file):
"""Loads a frozen inference graph"""
graph = tf.Graph()
with graph.as_default():
od_graph_def = tf.GraphDef()
with tf.gfile.GFile(graph_file, 'rb') as fid:
serialized_graph = fid.read()
od_graph_def.ParseFromString(serialized_graph)
tf.import_graph_def(od_graph_def, name='')
return graph
def crop_box(self, image, box):
bottom, left, top, right = box[...]
return image[int(bottom):int(top), int(left):int(right), :]
def detect_tl_circles(self, img):
height = img.shape[0]
img = img[:, :, ::-1].copy() # convert to BGR
gimg = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
gimg = cv.medianBlur(gimg, 5)
circles = cv.HoughCircles(gimg, cv.HOUGH_GRADIENT, 1, int(height * 0.25),
param1=50, param2=30, minRadius=0, maxRadius=0)
if circles is not None:
circles = np.uint16(np.around(circles))[0]
return circles
def sort_circles_by_y(self, circles):
if circles is not None:
if len(circles) == 3:
# determine top, middle and bottom circle w.r.t. y-coord
top_idx = np.argmin(circles[:, 1])
top_circ = circles[top_idx]
circles = np.delete(circles, top_idx, axis=0)
mid_idx = np.argmin(circles[:, 1])
mid_circ = circles[mid_idx]
circles = np.delete(circles, mid_idx, axis=0)
bot_circ = circles[0]
return top_circ, mid_circ, bot_circ
return None, None, None
def apply_color_threshold(self, img):
img = cv.cvtColor(img, cv.COLOR_BGR2HSV)
img = cv.medianBlur(img, 5)
# RED
lower_red = np.array([0, 50, 50])
upper_red = np.array([30, 255, 255])
mask = cv.inRange(img, lower_red, upper_red)
res = cv.bitwise_and(img, img, mask=mask)
# since the H value is circular and red les between 160 and 30,
# we have to deal with this here
lower_red_1 = np.array([160, 50, 50])
upper_red_1 = np.array([180, 255, 255])
mask = cv.inRange(img, lower_red_1, upper_red_1)
res_1 = cv.bitwise_and(img, img, mask=mask)
res_red = cv.bitwise_or(res, res_1)
# YELLOW
lower_yellow = np.array([20, 50, 50])
upper_yellow = np.array([30, 255, 255])
mask = cv.inRange(img, lower_yellow, upper_yellow)
res_yellow = cv.bitwise_and(img, img, mask=mask)
# GREEN
lower_green = np.array([60, 50, 50])
upper_green = np.array([80, 255, 255])
mask = cv.inRange(img, lower_green, upper_green)
res_green = cv.bitwise_and(img, img, mask=mask)
# combine results for red, yellow and green
res = cv.bitwise_or(res_red, res_green)
res = cv.bitwise_or(res, res_yellow)
res = cv.cvtColor(res, cv.COLOR_RGB2GRAY)
res[res > 0] = 255
return res
def determine_active_light(self, thresh_img, red_circ, yellow_circ, green_circ):
# create binary circle mask
circle_image_red = np.zeros(
(thresh_img.shape[0], thresh_img.shape[1]), np.uint8)
circle_image_yellow = np.zeros(
(thresh_img.shape[0], thresh_img.shape[1]), np.uint8)
circle_image_green = np.zeros(
(thresh_img.shape[0], thresh_img.shape[1]), np.uint8)
cv.circle(circle_image_red,
(red_circ[0], red_circ[1]), red_circ[2], 255, -1)
cv.circle(circle_image_yellow,
(yellow_circ[0], yellow_circ[1]), yellow_circ[2], 255, -1)
cv.circle(circle_image_green,
(green_circ[0], green_circ[1]), green_circ[2], 255, -1)
sum_red_pix = sum(sum(circle_image_red == 255))
sum_yellow_pix = sum(sum(circle_image_yellow == 255))
sum_green_pix = sum(sum(circle_image_green == 255))
red_overlap = cv.bitwise_and(thresh_img, circle_image_red)
yellow_overlap = cv.bitwise_and(thresh_img, circle_image_yellow)
green_overlap = cv.bitwise_and(thresh_img, circle_image_green)
sum_red_overlap = sum(sum(red_overlap == 255))
sum_yellow_overlap = sum(sum(yellow_overlap == 255))
sum_green_overlap = sum(sum(green_overlap == 255))
state_red = False
state_yellow = False
state_green = False
if float(sum_red_overlap) / float(sum_red_pix) > 0.7:
state_red = True
if float(sum_yellow_overlap) / float(sum_yellow_pix) > 0.7:
state_yellow = True
if float(sum_green_overlap) / float(sum_green_pix) > 0.7:
state_green = True
return state_red, state_yellow, state_green
def apply_box_detector(self, image):
image_np = np.expand_dims(np.asarray(image, dtype=np.uint8), 0)
(boxes, scores, classes) = self.sess.run([self.detection_boxes, self.detection_scores, self.detection_classes],
feed_dict={self.image_tensor: image_np})
# Remove unnecessary dimensions
boxes = np.squeeze(boxes)
scores = np.squeeze(scores)
classes = np.squeeze(classes)
return boxes, scores, classes
def classify_tl_with_cnn(self, img):
"""Classifies a 16x16x3 image by using a CNN model
Args:
img (cv::Mat): 16x16x3 image containing a cropped traffic light
Return:
vector<int> with size (3,1), which contains the softmax output of the
traffic light state classifier [red, yellow, green]
"""
global tl_state_model
global tl_state_graph
# Resize to input size of CNN
img = cv.resize(img, (16, 16))
# The model needs the R and B channel swapped
img = cv.cvtColor(img, cv.COLOR_RGB2BGR)
img = np.expand_dims(np.asarray(img, dtype=np.uint8), 0)
# res = self.tl_state_model.predict(img, batch_size=1)
# return res
preds = [0, 0, 0]
with tl_state_graph.as_default():
preds = tl_state_model.predict(img, batch_size=1)
return preds
def classifiy_tl_with_hough(self, img):
# Detect traffic light countours with Hough transform
circles = self.detect_tl_circles(img)
# Distinguish the red, yellow and green light by sorting the w.r.t. their y coords
red_circ, yellow_circ, green_circ = self.sort_circles_by_y(circles)
red = yellow = green = False
if red_circ is not None and yellow_circ is not None and green_circ is not None:
# Apply color thresholds, to determine, which light is active
thresh_image = self.apply_color_threshold(img)
red, yellow, green = self.determine_active_light(thresh_image, red_circ, yellow_circ, green_circ)
return [float(red), float(yellow), float(green)]
def get_classification(self, image):
"""Determines the color of the traffic light in the image
Args:
image (cv::Mat): image containing the traffic light
Returns:
int: ID of traffic light color (specified in styx_msgs/TrafficLight)
"""
boxes, scores, classes = self.apply_box_detector(image)
confidence_cutoff = 0.5
# Filter boxes with a confidence score less than `confidence_cutoff`
boxes, scores, classes = self.filter_boxes(
confidence_cutoff, boxes, scores, classes)
if boxes.size > 0:
# Get the box with the highest probability
box = boxes[np.argmax(scores)]
# The current box coordinates are normalized to a range between 0 and 1.
# This converts the coordinates actual location on the image.
height, width, _ = image.shape
box_coords = self.to_image_coords(box, height, width)
image = self.crop_box(image, box_coords)
tl_state_probs = self.classify_tl_with_cnn(image)
# check, if there is only one highest probability
if len(np.where(tl_state_probs == | np.max(tl_state_probs) | numpy.max |
import numpy
import math
import sys
import numpy
from scipy import signal
from scipy import ndimage
from skimage import io
import sys
import re
import math
import sys
import numpy
from scipy import signal
from scipy import ndimage
# import gauss
import matplotlib.pyplot as plt
#!/usr/bin/env python
"""Module providing functionality surrounding gaussian function.
"""
SVN_REVISION = '$LastChangedRevision: 16541 $'
import sys
import numpy
# def gaussian2(size, sigma):
# """Returns a normalized circularly symmetric 2D gauss kernel array
# f(x,y) = A.e^{-(x^2/2*sigma^2 + y^2/2*sigma^2)} where
# A = 1/(2*pi*sigma^2)
# as define by Wolfram Mathworld
# http://mathworld.wolfram.com/GaussianFunction.html
# """
# A = 1/(2.0*numpy.pi*sigma**2)
# x, y = numpy.mgrid[-size//2 + 1:size//2 + 1, -size//2 + 1:size//2 + 1]
# g = A*numpy.exp(-((x**2/(2.0*sigma**2))+(y**2/(2.0*sigma**2))))
# return g
def fspecial_gauss(size, sigma):
"""Function to mimic the 'fspecial' gaussian MATLAB function
"""
x, y = numpy.mgrid[-size//2 + 1:size//2 + 1, -size//2 + 1:size//2 + 1]
g = numpy.exp(-((x**2 + y**2)/(2.0*sigma**2)))
return g/g.sum()
def ssim(img1, img2, cs_map=False):
"""Return the Structural Similarity Map corresponding to input images img1
and img2 (images are assumed to be uint8)
This function attempts to mimic precisely the functionality of ssim.m a
MATLAB provided by the author's of SSIM
https://ece.uwater<EMAIL>.ca/~z70wang/research/ssim/ssim_index.m
"""
img1 = img1.astype(numpy.float64)
img2 = img2.astype(numpy.float64)
size = 11
sigma = 1.5
window = fspecial_gauss(size, sigma)
K1 = 0.01
K2 = 0.03
L = 255 #bitdepth of image
C1 = (K1 * L)**2
C2 = (K2 * L)**2
mu1 = signal.fftconvolve(window, img1, mode='valid')
mu2 = signal.fftconvolve(window, img2, mode='valid')
mu1_sq = mu1 * mu1
mu2_sq = mu2 * mu2
mu1_mu2 = mu1 * mu2
sigma1_sq = signal.fftconvolve(window, img1 * img1, mode='valid') - mu1_sq
sigma2_sq = signal.fftconvolve(window, img2 * img2, mode='valid') - mu2_sq
sigma12 = signal.fftconvolve(window, img1 * img2, mode='valid') - mu1_mu2
if cs_map:
return (((2 * mu1_mu2 + C1) * (2 * sigma12 + C2)) / ((mu1_sq + mu2_sq + C1) * (sigma1_sq + sigma2_sq + C2)),
(2.0 * sigma12 + C2) / (sigma1_sq + sigma2_sq + C2))
else:
return ((2 * mu1_mu2 + C1) * (2 * sigma12 + C2)) / ((mu1_sq + mu2_sq + C1) * (sigma1_sq + sigma2_sq + C2))
def msssim(img1, img2):
"""This function implements Multi-Scale Structural Similarity (MSSSIM) Image
Quality Assessment according to <NAME>'s "Multi-scale structural similarity
for image quality assessment" Invited Paper, IEEE Asilomar Conference on
Signals, Systems and Computers, Nov. 2003
Author's MATLAB implementation:-
http://www.cns.nyu.edu/~lcv/ssim/msssim.zip
"""
level = 5
weight = numpy.array([0.0448, 0.2856, 0.3001, 0.2363, 0.1333])
downsample_filter = numpy.ones((2, 2)) / 4.0
im1 = img1.astype(numpy.float64)
im2 = img2.astype(numpy.float64)
mssim = numpy.array([])
mcs = numpy.array([])
for l in range(level):
ssim_map, cs_map = ssim(im1, im2, cs_map=True)
mssim = numpy.append(mssim, ssim_map.mean())
mcs = numpy.append(mcs, cs_map.mean())
filtered_im1 = ndimage.filters.convolve(im1, downsample_filter, mode='reflect')
filtered_im2 = ndimage.filters.convolve(im2, downsample_filter, mode='reflect')
im1 = filtered_im1[::2, ::2]
im2 = filtered_im2[::2, ::2]
return (numpy.prod(mcs[0:level - 1]**weight[0:level - 1]) * (mssim[level - 1]**weight[level - 1]))
def psnr(ref, target):
diff = ref/255.0 - target/255.0
diff = diff.flatten('C')
rmse = math.sqrt(numpy.mean(diff**2.))
return 20 * math.log10(1.0 / (rmse))
def main():
im_width = float(sys.argv[2])
im_height = float(sys.argv[3])
prefix = 'out/'
psnr_arr = []
msssim_arr = []
bpp_arr = []
with open('ffreport.log') as f:
lines = f.readlines()
size_line = []
for l in lines:
if ", size " in l:
size = l.split(',')[1]
size_line.append(int(size[5:]))
size_line = numpy.array(size_line)*8.0/(im_width*im_height)
# print(size_line)
# bpp_str = ''
# for l in lines:
# if "Lsize" in l:
# bpp_str = l
# break
# bpp_strs = re.findall(r"[-+]?\d*\.\d+|\d+", bpp_str)
# bpp = float(bpp_strs[3])*8000/(im_width*im_height)
import time
for i in range(len(size_line)):
#
if (i) % 12 == 0:
#if True:
source = prefix + 'source/img' + "{0:0=6d}".format(i+1) + '.png'
h265 = prefix + 'h265/img' + "{0:0=6d}".format(i+1) + '.png'
source_img = io.imread(source)
h265_img = io.imread(h265)
# print(source_img.shape)
# print(h265_img.shape)
psnr_val = 0#psnr(source_img, h265_img)
tmpssim = 0
# tmpssim = msssim(h265_img[:, :, 0], source_img[:, :, 0])
# tmpssim += msssim(h265_img[:, :, 1], source_img[:, :, 1])
# tmpssim += msssim(h265_img[:, :, 2], source_img[:, :, 2])
ms_ssim_val = tmpssim/3.0
psnr_arr.append(psnr_val)
msssim_arr.append(ms_ssim_val)
bpp_arr.append(size_line[i])
# print(psnr_val)
# print(ms_ssim_val)
# print(size_line[i])
print(sys.argv[1])
print('psnr:' + str(numpy.array(psnr_arr).mean(0)))
print('bpp:' +str(numpy.array(bpp_arr).mean(0)))
print('msssim:' +str( | numpy.array(msssim_arr) | numpy.array |
# emacs: -*- mode: python; py-indent-offset: 4; indent-tabs-mode: nil -*-
# vi: set ft=python sts=4 ts=4 sw=4 et:
""" Test conversion between NIFTI and NIPY conventions. The algorithms are
mostly written out in the :mod:`nipy.io.nifti_ref` docstrings.
"""
import warnings
from copy import copy
import numpy as np
import nibabel as nib
from nibabel.affines import from_matvec
from nibabel.spatialimages import HeaderDataError
from ...core.api import (Image,
AffineTransform as AT,
CoordinateSystem as CS)
from ...core.reference.spaces import (unknown_csm, scanner_csm, aligned_csm,
talairach_csm, mni_csm, unknown_space,
vox2mni)
from ..files import load
from ..nifti_ref import (nipy2nifti, nifti2nipy, NiftiError)
from ..nibcompat import get_header, get_affine
from nose.tools import assert_equal, assert_true, assert_false, assert_raises
from numpy.testing import assert_almost_equal, assert_array_equal
from ...testing import anatfile, funcfile
def copy_of(fname):
# Make a fresh copy of a image stored in a file
img = load(fname)
hdr = img.metadata['header'].copy()
return Image(img.get_data().copy(),
copy(img.coordmap),
{'header': hdr})
def setup():
# Suppress warnings during tests
warnings.simplefilter("ignore")
def teardown():
# Clear list of warning filters
warnings.resetwarnings()
def test_basic_nipy2nifti():
# Go from nipy image to header and data for nifti
fimg = copy_of(funcfile)
hdr = fimg.metadata['header']
data = fimg.get_data()
# Header is preserved
# Put in some information to check header is preserved
hdr['slice_duration'] = 0.25
ni_img = nipy2nifti(fimg)
new_hdr = get_header(ni_img)
# header copied on the way through
assert_false(hdr is new_hdr)
# Check information preserved
assert_equal(hdr['slice_duration'], new_hdr['slice_duration'])
assert_array_equal(data, ni_img.get_data())
# Shape obviously should be same
assert_equal(ni_img.shape, fimg.shape)
def test_xyz_affines():
fimg = copy_of(funcfile)
data = fimg.get_data()
# Check conversion to xyz affable
# Roll time to front in array
fimg_t0 = fimg.reordered_axes((3, 0, 1, 2))
# Nifti conversion rolls it back
assert_array_equal(nipy2nifti(fimg_t0).get_data(), data)
# Roll time to position 1
fimg_t0 = fimg.reordered_axes((0, 3, 1, 2))
assert_array_equal(nipy2nifti(fimg_t0).get_data(), data)
# Check bad names cause NiftiError
out_coords = fimg.reference.coord_names
bad_img = fimg.renamed_reference(**{out_coords[0]: 'not a known axis'})
assert_raises(NiftiError, nipy2nifti, bad_img)
# Check xyz works for not strict
bad_img = fimg.renamed_reference(**dict(zip(out_coords, 'xyz')))
assert_array_equal(nipy2nifti(bad_img, strict=False).get_data(), data)
# But fails for strict
assert_raises(NiftiError, nipy2nifti, bad_img, strict=True)
# 3D is OK
aimg = copy_of(anatfile)
adata = aimg.get_data()
assert_array_equal(nipy2nifti(aimg).get_data(), adata)
# For now, always error on 2D (this depends on as_xyz_image)
assert_raises(NiftiError, nipy2nifti, aimg[:, :, 1])
assert_raises(NiftiError, nipy2nifti, aimg[:, 1, :])
assert_raises(NiftiError, nipy2nifti, aimg[1, :, :])
# Do not allow spaces not in the NIFTI canon
for i in range(3):
displaced_img = fimg.renamed_reference(**{out_coords[i]: 'obscure'})
assert_raises(NiftiError, nipy2nifti, displaced_img)
def test_unknown():
# The 'unknown' coordinate space results from loading an image with no
# affine set; allow setting into nifti iff the affine corresponds to the
# default that would be created when there is no affine
aimg = copy_of(anatfile)
bare_affine = aimg.metadata['header'].get_base_affine()
# The affine does not match the header-only affine
assert_false(np.allclose(bare_affine, aimg.coordmap.affine))
unknown_cs = unknown_csm(3)
out_coords = aimg.reference.coord_names
# So nipy2nifti raises an error
displaced_img = aimg.renamed_reference(
**dict(zip(out_coords[:3], unknown_cs.coord_names)))
assert_raises(NiftiError, nipy2nifti, displaced_img)
# If the affine is the same, no error
displaced_img.coordmap.affine[:] = bare_affine
assert_true(np.allclose(bare_affine, displaced_img.coordmap.affine))
nimg = nipy2nifti(displaced_img)
assert_array_equal(get_affine(nimg), bare_affine)
# Get and check coordinate map
inimg = nifti2nipy(nimg)
assert_true(inimg.coordmap.function_range in unknown_space)
# This also so if there is no header
displaced_img.metadata.pop('header')
nimg = nipy2nifti(displaced_img)
assert_array_equal(get_affine(nimg), bare_affine)
# Get and check coordinate map
inimg = nifti2nipy(nimg)
assert_true(inimg.coordmap.function_range in unknown_space)
def test_orthogonal_dims():
# Test whether conversion to nifti raises an error for non-orthogonal
# non-spatial dimensions
# This affine is all nicely diagonal
aff = from_matvec(np.diag([2., 3, 4, 5, 6]), [10, 11, 12, 13, 14])
data = np.random.normal(size=(3, 4, 5, 6, 7))
img = Image(data, vox2mni(aff))
def as3d(aff):
return from_matvec(aff[:3, :3], aff[:3, -1])
assert_array_equal(get_affine(nipy2nifti(img)), as3d(aff))
# Non-orthogonal spatial dimensions OK
aff[:3, :3] = np.random.normal(size=(3, 3))
img = Image(data, vox2mni(aff))
assert_array_equal(get_affine(nipy2nifti(img)), as3d(aff))
# Space must be orthogonal to time etc
aff[0, 3] = 0.1
assert_raises(NiftiError, nipy2nifti, img)
aff[0, 3] = 0
assert_array_equal(get_affine(nipy2nifti(img)), as3d(aff))
aff[3, 0] = 0.1
assert_raises(NiftiError, nipy2nifti, img)
aff[3, 0] = 0
assert_array_equal(get_affine(nipy2nifti(img)), as3d(aff))
aff[4, 0] = 0.1
assert_raises(NiftiError, nipy2nifti, img)
def test_dim_info():
# Test slice, freq, phase get set OK
fimg = copy_of(funcfile)
hdr = fimg.metadata['header']
assert_equal(hdr.get_dim_info(), (None, None, None))
ni_img = nipy2nifti(fimg)
assert_equal(get_header(ni_img).get_dim_info(), (None, None, None))
data = fimg.get_data()
cmap = fimg.coordmap
for i in range(3):
for order, name in enumerate(('freq', 'phase', 'slice')):
ncmap = cmap.renamed_domain({i: name})
ni_img = nipy2nifti(Image(data, ncmap, {'header': hdr}))
exp_info = [None, None, None]
exp_info[order] = i
assert_equal(get_header(ni_img).get_dim_info(),
tuple(exp_info))
ncmap = cmap.renamed_domain(
dict(zip(range(3), ('phase', 'slice', 'freq'))))
ni_img = nipy2nifti(Image(data, ncmap, {'header': hdr}))
assert_equal(get_header(ni_img).get_dim_info(), (2, 0, 1))
def test_time_like_matching():
# Check checks for matching time-like axes
shape = (2, 3, 4, 5, 6)
shape_shifted = (2, 3, 4, 6, 5)
data = np.random.normal(size=shape)
aff = np.diag([3, 4, 5, 6, 7, 1])
mni_names = mni_csm(3).coord_names
time_cans = ('t', 'hz', 'ppm', 'rads')
aliases = dict(t='time',
hz='frequency-hz',
ppm='concentration-ppm',
rads='radians/s')
all_names = set(time_cans + tuple(v for v in aliases.values()))
for time_like in time_cans:
alias = aliases[time_like]
for name in (time_like, alias):
# Names match
cmap = AT(CS(('i', 'j', 'k', name, 'u')),
CS(mni_names + (name, 'u')), aff)
assert_equal(nipy2nifti(Image(data, cmap)).shape, shape)
cmap = AT(CS(('i', 'j', 'k', 'u', name)),
CS(mni_names + ('u', name)), aff)
assert_equal(nipy2nifti(Image(data, cmap)).shape, shape_shifted)
# No time-like in output is OK
cmap = AT(CS(('i', 'j', 'k', 'u', name)),
CS(mni_names + ('u', 'v')), aff)
assert_equal(nipy2nifti(Image(data, cmap)).shape, shape_shifted)
# No time-like in input is OK
cmap = AT(CS(('i', 'j', 'k', 'u', 'v')),
CS(mni_names + ('u', name)), aff)
assert_equal(nipy2nifti(Image(data, cmap)).shape, shape_shifted)
# Time-like in both, but not matching, not OK
cmap = AT(CS(('i', 'j', 'k', 'u', name)),
CS(mni_names + (name, 'u')), aff)
assert_raises(NiftiError, nipy2nifti, Image(data, cmap))
# Time like in both with no match between but no match elsewhere
# Actually this does cause a problem for non-zero time offset and
# time axes, but we test that elsewhere.
cmap = AT(CS(('i', 'j', 'k', 'u', name)),
CS(mni_names + ('u', name)),
np.diag([3, 4, 5, 6, 0, 1]))
assert_equal(nipy2nifti(Image(data, cmap)).shape, shape_shifted)
cmap = AT(CS(('i', 'j', 'k', 'u', name)),
CS(mni_names + (name, 'u')),
np.diag([3, 4, 5, 0, 0, 1]))
assert_equal(nipy2nifti(Image(data, cmap)).shape, shape_shifted)
# Matching to own alias is OK
cmap = AT(CS(('i', 'j', 'k', time_like, 'u')),
CS(mni_names + (alias, 'u')), aff)
assert_equal(nipy2nifti(Image(data, cmap)).shape, shape)
cmap = AT(CS(('i', 'j', 'k', alias, 'u')),
CS(mni_names + (time_like, 'u')), aff)
assert_equal(nipy2nifti(Image(data, cmap)).shape, shape)
# But not to another time-like name
others = all_names.difference((time_like, alias))
for name in others:
cmap = AT(CS(('i', 'j', 'k', time_like, 'u')),
CS(mni_names + (name, 'u')), aff)
assert_raises(NiftiError, nipy2nifti, Image(data, cmap))
cmap = AT(CS(('i', 'j', 'k', name, 'u')),
CS(mni_names + (time_like, 'u')), aff)
assert_raises(NiftiError, nipy2nifti, Image(data, cmap))
# It's OK to have more than one time-like, but the order of recognition
# is 't', 'hz', 'ppm', 'rads'
for i, better in enumerate(time_cans[:-1]):
for worse in time_cans[i+1:]:
cmap = AT(CS(('i', 'j', 'k', better, worse)),
CS(mni_names + (better, worse)), aff)
assert_equal(nipy2nifti(Image(data, cmap)).shape, shape)
cmap = AT(CS(('i', 'j', 'k', worse, better)),
CS(mni_names + (worse, better)), aff)
assert_equal(nipy2nifti(Image(data, cmap)).shape, shape_shifted)
# Even if better is only in output
cmap = AT(CS(('i', 'j', 'k', worse, 'u')),
CS(mni_names + (worse, better)), aff)
assert_equal(nipy2nifti(Image(data, cmap)).shape, shape_shifted)
def test_time_pixdims():
# Pixdims get moved across when a no-time extra axis is added
shape = (2, 3, 4, 5, 6, 7)
data = np.random.normal(size=shape)
aff = np.diag([3, 4, 5, 6, 7, 8, 1])
mni_names = mni_csm(3).coord_names
in_cs = CS('ikjlmn')
cmap = AT(in_cs, CS(mni_names + tuple('tuv')), aff)
hdr = get_header(nipy2nifti(Image(data, cmap)))
assert_equal(hdr.get_zooms(), (3, 4, 5, 6, 7, 8))
cmap = AT(in_cs, CS(mni_names + tuple('quv')), aff)
hdr = get_header(nipy2nifti(Image(data, cmap)))
assert_equal(hdr.get_zooms(), (3, 4, 5, 0, 6, 7, 8))
def test_xyzt_units():
# Whether xyzt_unit field gets set correctly
fimg_orig = copy_of(funcfile)
# Put time in output, input and both
data = fimg_orig.get_data()
hdr = fimg_orig.metadata['header']
aff = fimg_orig.coordmap.affine
out_names = fimg_orig.reference.coord_names
# Time in input only
cmap_t_in = AT('ijkt', out_names[:3] + ('q',), aff)
img_t_in = Image(data, cmap_t_in, {'header': hdr.copy()})
# Time in output only
cmap_t_out = AT('ijkl', out_names[:3] + ('t',), aff)
img_t_out = Image(data, cmap_t_out, {'header': hdr.copy()})
# Time in both
cmap_t_b = AT('ijkt', out_names[:3] + ('t',), aff)
img_t_b = Image(data, cmap_t_b, {'header': hdr.copy()})
# In neither
cmap_t_no = AT('ijkl', out_names[:3] + ('q',), aff)
img_t_no = Image(data, cmap_t_no, {'header': hdr.copy()})
# Check the default
assert_equal(hdr.get_xyzt_units(), ('mm', 'sec'))
# That default survives nifti conversion
for img in (img_t_in, img_t_out, img_t_b):
ni_img = nipy2nifti(img)
assert_equal(get_header(ni_img).get_xyzt_units(), ('mm', 'sec'))
# Now with no time
for img in (img_t_no, img_t_b[...,0]):
ni_img = nipy2nifti(img)
assert_equal(get_header(ni_img).get_xyzt_units(), ('mm', 'unknown'))
# Change to other time-like
for units, name0, name1 in (('sec', 't', 'time'),
('hz', 'hz', 'frequency-hz'),
('ppm', 'ppm', 'concentration-ppm'),
('rads', 'rads', 'radians/s')):
for name in (name0, name1):
new_img = img_t_out.renamed_reference(t=name)
ni_img = nipy2nifti(new_img)
assert_equal(get_header(ni_img).get_xyzt_units(), ('mm', units))
new_img = img_t_in.renamed_axes(t=name)
ni_img = nipy2nifti(new_img)
assert_equal(get_header(ni_img).get_xyzt_units(), ('mm', units))
new_img = img_t_b.renamed_axes(t=name).renamed_reference(t=name)
ni_img = nipy2nifti(new_img)
assert_equal(get_header(ni_img).get_xyzt_units(), ('mm', units))
def test_time_axes_4th():
# Check time-like axes rolled to be 4th, and pixdims match
data = np.random.normal(size=(2, 3, 4, 5, 6, 7))
aff = np.diag([2., 3, 4, 5, 6, 7, 1])
xyz_names = talairach_csm(3).coord_names
in_cs = CS('ijklmn')
for time_like in ('t', 'hz', 'ppm', 'rads'):
cmap = AT(in_cs, CS(xyz_names + (time_like, 'q', 'r')), aff)
img = Image(data, cmap)
# Time-like in correct position
ni_img = nipy2nifti(img)
assert_array_equal(ni_img.get_data(), data)
assert_array_equal(get_header(ni_img).get_zooms(), (2, 3, 4, 5, 6, 7))
# Time-like needs reordering
cmap = AT(in_cs, CS(xyz_names + ('q', time_like, 'r')), aff)
ni_img = nipy2nifti(Image(data, cmap))
assert_array_equal(ni_img.get_data(), np.rollaxis(data, 4, 3))
assert_array_equal(get_header(ni_img).get_zooms(), (2, 3, 4, 6, 5, 7))
# And again
cmap = AT(in_cs, CS(xyz_names + ('q', 'r', time_like)), aff)
ni_img = nipy2nifti(Image(data, cmap))
assert_array_equal(ni_img.get_data(), np.rollaxis(data, 5, 3))
assert_array_equal(get_header(ni_img).get_zooms(), (2, 3, 4, 7, 5, 6))
def test_save_toffset():
# Check toffset only gets set for time
shape = (2, 3, 4, 5, 6, 7)
data = np.random.normal(size = shape)
aff = from_matvec(np.diag([2., 3, 4, 5, 6, 7]),
[11, 12, 13, 14, 15, 16])
xyz_names = talairach_csm(3).coord_names
in_cs = CS('ijklmn')
for t_name in 't', 'time':
cmap = AT(in_cs, CS(xyz_names + (t_name, 'q', 'r')), aff)
ni_img = nipy2nifti(Image(data, cmap))
assert_equal(get_header(ni_img)['toffset'], 14)
for time_like in ('hz', 'ppm', 'rads'):
cmap = AT(in_cs, CS(xyz_names + (time_like, 'q', 'r')), aff)
ni_img = nipy2nifti(Image(data, cmap))
assert_equal(get_header(ni_img)['toffset'], 0)
# Check that non-matching time causes a nifti error when toffset !=0
shape_shifted = (2, 3, 4, 6, 5, 7)
for t_name in 't', 'time':
# No toffset, this is OK
cmap = AT(CS(('i', 'j', 'k', 'u', t_name, 'v')),
CS(xyz_names + ('u', t_name, 'v')),
np.diag([3, 4, 5, 6, 0, 7, 1]))
assert_equal(nipy2nifti(Image(data, cmap)).shape, shape_shifted)
# toffset with 0 on TR (time) diagonal
aff_z1 = from_matvec(np.diag([2., 3, 4, 5, 0, 7]),
[11, 12, 13, 14, 15, 16])
cmap = AT(CS(('i', 'j', 'k', 'u', t_name, 'v')),
CS(xyz_names + ('u', t_name, 'v')),
aff_z1)
# Default is to fix the zero
assert_equal(nipy2nifti(Image(data, cmap)).shape,
shape_shifted)
assert_equal(nipy2nifti(Image(data, cmap), fix0=True).shape,
shape_shifted)
# Unless fix0 is False
assert_raises(NiftiError, nipy2nifti, Image(data, cmap), fix0=False)
# Fix doesn't work if there is more than one zero row and column
aff_z2 = from_matvec(np.diag([2., 3, 4, 0, 0, 7]),
[11, 12, 13, 14, 15, 16])
cmap = AT(CS(('i', 'j', 'k', 'u', t_name, 'v')),
CS(xyz_names + ('u', t_name, 'v')),
aff_z2)
assert_raises(NiftiError, nipy2nifti, Image(data, cmap), fix0=True)
# zeros on the diagonal are not a problem for non-time, with toffset,
# because we don't need to set the 'time' part of the translation vector,
# and therefore we don't need to know which *output axis* is time-like
for t_name in 'hz', 'ppm', 'rads':
cmap = AT(CS(('i', 'j', 'k', 'u', t_name, 'v')),
CS(xyz_names + ('u', t_name, 'v')),
aff_z1)
assert_equal(nipy2nifti(Image(data, cmap), fix0=False).shape,
shape_shifted)
cmap = AT(CS(('i', 'j', 'k', 'u', t_name, 'v')),
CS(xyz_names + ('u', t_name, 'v')),
aff_z2)
assert_equal(nipy2nifti(Image(data, cmap), fix0=False).shape,
shape_shifted)
def test_too_many_dims():
data0 = np.zeros(range(2, 9))
xyz_names = talairach_csm(3).coord_names
cmap = AT(CS('ijktuvw'), CS(xyz_names + tuple('tuvw')), np.eye(8))
assert_equal(nipy2nifti(Image(data0, cmap)).shape, tuple(range(2, 9)))
# Too many dimensions
data1 = np.zeros(range(2, 10))
cmap = AT(CS('ijktuvwq'), CS(xyz_names + tuple('tuvwq')), np.eye(9))
assert_raises(NiftiError, nipy2nifti, Image(data1, cmap))
# No time adds a dimension
cmap = AT(CS('ijkpuvw'), CS(xyz_names + tuple('puvw')), np.eye(8))
assert_raises(NiftiError, nipy2nifti, Image(data0, cmap))
def test_no_time():
# Check that no time axis results in extra length 1 dimension
data = np.random.normal(size=(2, 3, 4, 5, 6, 7))
aff = np.diag([2., 3, 4, 5, 6, 7, 1])
xyz_names = talairach_csm(3).coord_names
in_cs = CS('ijklmn')
# No change in shape if there's a time-like axis
for time_like in ('t', 'hz', 'ppm', 'rads'):
cmap = AT(in_cs, CS(xyz_names + (time_like, 'q', 'r')), aff)
ni_img = nipy2nifti(Image(data, cmap))
assert_array_equal(ni_img.get_data(), data)
# But there is if no time-like
for no_time in ('random', 'words', 'I', 'thought', 'of'):
cmap = AT(in_cs, CS(xyz_names + (no_time, 'q', 'r')), aff)
ni_img = nipy2nifti(Image(data, cmap))
assert_array_equal(ni_img.get_data(), data[:, :, :, None, :, :])
def test_save_spaces():
# Test that intended output spaces get set into nifti
data = np.random.normal(size=(2, 3, 4))
aff = np.diag([2., 3, 4, 1])
in_cs = CS('ijk')
for label, csm in (('scanner', scanner_csm),
('aligned', aligned_csm),
('talairach', talairach_csm),
('mni', mni_csm)):
img = Image(data, AT(in_cs, csm(3), aff))
ni_img = nipy2nifti(img)
assert_equal(get_header(ni_img).get_value_label('sform_code'),
label)
def test_save_dtype():
# Test we can specify the dtype on conversion
data = np.random.normal(size=(2, 3, 4))
cmap = vox2mni(np.diag([2., 3, 4, 1]))
for dt_code in ('i1', 'u1', 'i2', 'u2', 'i4', 'u4', 'i8', 'u8',
'f4', 'f8', 'c8', 'c16'):
dt = np.dtype(dt_code)
img = Image(data.astype(dt_code), cmap)
ni_img = nipy2nifti(img, data_dtype=dt_code)
assert_equal(get_header(ni_img).get_data_dtype(), dt)
ni_img = nipy2nifti(img, data_dtype=dt)
assert_equal(get_header(ni_img).get_data_dtype(), dt)
# None results in trying to get the code from the input header, then from the
# data.
# From data, when there's nothing in the header
img = Image(data.astype(np.int16), cmap)
ni_img = nipy2nifti(img, data_dtype=None)
assert_equal(get_header(ni_img).get_data_dtype(), np.dtype(np.int16))
# From the header
hdr = nib.Nifti1Header()
hdr.set_data_dtype(np.int32)
img = Image(data.astype(np.int16), cmap, metadata={'header': hdr})
ni_img = nipy2nifti(img, data_dtype=None)
assert_equal(get_header(ni_img).get_data_dtype(), np.dtype(np.int32))
# Bad dtype
assert_raises(TypeError, nipy2nifti, img, data_dtype='foo')
# Fancy dtype
data = np.zeros((2, 3, 4), dtype=[('f0', 'i2'), ('f1', 'f4')])
img = Image(data, cmap)
assert_raises(HeaderDataError, nipy2nifti, img, data_dtype=None)
def test_basic_load():
# Just basic load
data = np.random.normal(size=(2, 3, 4, 5))
aff = np.diag([2., 3, 4, 1])
ni_img = nib.Nifti1Image(data, aff)
img = nifti2nipy(ni_img)
assert_array_equal(img.get_data(), data)
def test_expand_to_3d():
# Test 1D and 2D niftis
# 1D and 2D with full sform or qform affines raise a NiftiError, because we
# can't be sure which axes the affine refers to. Should the image have 1
# length axes prepended? Or appended?
xyz_aff = np.diag([2, 3, 4, 1])
for size in (10,), (10, 2):
data = np.random.normal(size=size)
ni_img = nib.Nifti1Image(data, xyz_aff)
# Default is aligned
assert_raises(NiftiError, nifti2nipy, ni_img)
hdr = get_header(ni_img)
# The pixdim affine
for label in 'scanner', 'aligned', 'talairach', 'mni':
hdr.set_sform(xyz_aff, label)
assert_raises(NiftiError, nifti2nipy, ni_img)
hdr.set_sform(None)
assert_raises(NiftiError, nifti2nipy, ni_img)
hdr.set_sform(xyz_aff, label)
assert_raises(NiftiError, nifti2nipy, ni_img)
hdr.set_qform(None)
def test_load_cmaps():
data = np.random.normal(size=range(7))
xyz_aff = np.diag([2, 3, 4, 1])
# Default with time-like
ni_img = nib.Nifti1Image(data, xyz_aff)
img = nifti2nipy(ni_img)
exp_cmap = AT(CS('ijktuvw', name='voxels'),
aligned_csm(7),
np.diag([2, 3, 4, 1, 1, 1, 1, 1]))
assert_equal(img.coordmap, exp_cmap)
# xyzt_units sets time axis name
hdr = get_header(ni_img)
xyz_names = aligned_csm(3).coord_names
full_aff = exp_cmap.affine
reduced_data = data[:, :, :, 1:2, ...]
for t_like, units, scaling in (
('t', 'sec', 1),
('t', 'msec', 1/1000.),
('t', 'usec', 1/1000000.),
('hz', 'hz', 1),
('ppm', 'ppm', 1),
('rads', 'rads', 1)):
hdr.set_xyzt_units('mm', units)
img = nifti2nipy(ni_img)
in_cs = CS(('i', 'j', 'k', t_like, 'u', 'v', 'w'), name='voxels')
out_cs = CS(xyz_names + (t_like, 'u', 'v', 'w'), name='aligned')
if scaling == 1:
exp_aff = full_aff
else:
diag = np.ones((8,))
diag[3] = scaling
exp_aff = np.dot(np.diag(diag), full_aff)
exp_cmap = AT(in_cs, out_cs, exp_aff)
assert_equal(img.coordmap, exp_cmap)
assert_array_equal(img.get_data(), data)
# Even if the image axis length is 1, we keep out time dimension, if
# there is specific scaling implying time-like
ni_img_t = nib.Nifti1Image(reduced_data, xyz_aff, hdr)
img = nifti2nipy(ni_img_t)
assert_equal(img.coordmap, exp_cmap)
assert_array_equal(img.get_data(), reduced_data)
def test_load_no_time():
# Without setting anything else, length 1 at position 3 makes time go away
ns_dims = (5, 6, 7)
xyz_aff = np.diag([2, 3, 4, 1])
xyz_names = aligned_csm(3).coord_names[:3]
in_names = tuple('ijkuvw')
out_names = xyz_names + tuple('uvw')
for n_ns in 1, 2, 3:
ndim = 3 + n_ns
data = np.random.normal(size=(2, 3, 4, 1) + ns_dims[:n_ns])
ni_img_no_t = nib.Nifti1Image(data, xyz_aff)
cmap_no_t = AT(CS(in_names[:ndim], name='voxels'),
CS(out_names[:ndim], name='aligned'),
np.diag([2, 3, 4] + [1] * n_ns + [1]))
img = nifti2nipy(ni_img_no_t)
assert_equal(img.coordmap, cmap_no_t)
# We add do time if 4th axis of length 1 is the last axis
data41 = | np.zeros((3, 4, 5, 1)) | numpy.zeros |
# -*- coding: utf-8 -*-
# Copyright (C) 2012 VT SuperDARN Lab
# Full license can be found in LICENSE.txt
"""Earth coordinate conversion routines
Functions
---------
geodToGeoc : converts from geodetic to geocentric (and vice-versa)
geodToGeocAzEl : converts azimuth and elevation from geodetic to geocentric
(and vice-versa)
gspToGcar : converts global spherical coordinates to global cartesian
coordinates (and vice-versa)
gcarToLcar : converts from global cartesian coordinates to local cartesian
coordinates (and vice-versa)
lspToLcar : converts from local spherical coordinates to local cartesian
coordinates (and vice-versa)
calcDistPnt : calculates the coordines|distance,elevation,azimuth of a point
given a point of origin and distance, elevation, azimuth|distant
point coordinates
greatCircleMove : Calculates the coordinates of an end point along a great
circle path given the original coordinates, distance, azimuth,
and altitude.
greatCircleAzm : Calculates the azimuth from the coordinates of a start point
to and end point along a great circle path.
greatCircleDist : Calculates the distance in radians along a great circle path
between two points.
References
----------
Based on <NAME>'s geopack
Based on <NAME> radar.pro
Updates based on <NAME> cnvtcoord_vhm.c
Copied from DaViTPy
"""
import logging
import numpy as np
def geodToGeoc(lat, lon, inverse=False):
"""Converts position from geodetic to geocentric or vice-versa.
Based on the IAU 1964 oblate spheroid model of the Earth.
Parameters
----------
lat : float
latitude [degree]
lon : float
longitude [degree]
inverse : Optional[bool]
inverse conversion (geocentric to geodetic). Default is false.
Returns
-------
lat_out : float
latitude [degree] (geocentric/detic if inverse=False/True)
lon_out : float
longitude [degree] (geocentric/detic if inverse=False/True)
rade : float
Earth radius [km] (geocentric/detic if inverse=False/True)
"""
a = 6378.16
f = 1.0 / 298.25
b = a * (1.0 - f)
e2 = (a**2 / b**2) - 1.0
if not inverse:
# geodetic into geocentric
lat_out = np.degrees(np.arctan(b**2 / a**2 * np.tan(np.radians(lat))))
lon_out = lon
else:
# geocentric into geodetic
lat_out = np.degrees(np.arctan(a**2 / b**2 * np.tan(np.radians(lat))))
lon_out = lon
rade = a / np.sqrt( 1. + e2 * np.sin(np.radians(lat_out))**2)
return lat_out, lon_out, rade
def geodToGeocAzEl(lat, lon, az, el, inverse=False):
"""Converts pointing azimuth and elevation measured with respect to the
local horizon to azimuth and elevation with respect to the horizon defined
by the plane perpendicular to the Earth-centered radial vector drawn
through a user defined point.
Parameters
----------
lat : float
latitude [degree]
lon : float
longitude [degree]
az : float
azimuth [degree, N]
el : float
elevation [degree]
inverse : Optional[bool]
inverse conversion
Returns
-------
lat : float
latitude [degree]
lon : float
longitude [degree]
Re : float
Earth radius [km]
az : float
azimuth [degree, N]
el : float
elevation [degree]
"""
taz = np.radians(az)
tel = np.radians(el)
# In this transformation x is east, y is north and z is up
if not inverse:
# Calculate deviation from vertical (in radians)
(geocLat, geocLon, Re) = geodToGeoc(lat, lon)
devH = np.radians(lat - geocLat)
# Calculate cartesian coordinated in local system
kxGD = np.cos(tel) * np.sin(taz)
kyGD = np.cos(tel) * np.cos(taz)
kzGD = np.sin(tel)
# Now rotate system about the x axis to align local vertical vector
# with Earth radial vector
kxGC = kxGD
kyGC = kyGD * np.cos(devH) + kzGD * np.sin(devH)
kzGC = -kyGD * np.sin(devH) + kzGD * np.cos(devH)
# Finally calculate the new azimuth and elevation in the geocentric
# frame
azOut = np.degrees(np.arctan2(kxGC, kyGC))
elOut = np.degrees(np.arctan(kzGC / np.sqrt(kxGC**2 + kyGC**2)))
latOut = geocLat
lonOut = geocLon
else:
# Calculate deviation from vertical (in radians)
(geodLat, geodLon, Re) = geodToGeoc(lat, lon, inverse=True)
devH = np.radians(geodLat - lat)
# Calculate cartesian coordinated in geocentric system
kxGC = np.cos(tel) * np.sin(taz)
kyGC = np.cos(tel) * np.cos(taz)
kzGC = np.sin(tel)
# Now rotate system about the x axis to align local vertical vector
# with Earth radial vector
kxGD = kxGC
kyGD = kyGC * np.cos(-devH) + kzGC * np.sin(-devH)
kzGD = -kyGC * np.sin(-devH) + kzGC * np.cos(-devH)
# Finally calculate the new azimuth and elevation in the geocentric
# frame
azOut = np.degrees(np.arctan2(kxGD, kyGD))
elOut = np.degrees(np.arctan(kzGD / np.sqrt(kxGD**2 + kyGD**2)))
latOut = geodLat
lonOut = geodLon
return latOut, lonOut, Re, azOut, elOut
def gspToGcar(xin, yin, zin, inverse=False):
"""Converts a position from global spherical (geocentric) to global
cartesian (and vice-versa).
Parameters
----------
xin : float
latitude [degree] or global cartesian X [km]
yin : float
longitude [degree] or global cartesian Y [km]
zin : float
distance from center of the Earth [km] or global cartesian Z [km]
inverse : Optional[bool]
inverse conversion
Returns
-------
xout : float
global cartesian X [km] (inverse=False) or latitude [degree]
yout : float
global cartesian Y [km] (inverse=False) or longitude [degree]
zout : float
global cartesian Z [km] (inverse=False) or distance from the center of
the Earth [km]
Notes
-------
The global cartesian coordinate system is defined as:
- origin: center of the Earth
- x-axis in the equatorial plane and through the prime meridian.
- z-axis in the direction of the rotational axis and through the North
pole
The meaning of the input (x,y,z) depends on the direction of the conversion
(to global cartesian or to global spherical).
"""
if not inverse:
# Global spherical to global cartesian
xout = zin * np.cos(np.radians(xin)) * np.cos(np.radians(yin))
yout = zin * np.cos(np.radians(xin)) * np.sin(np.radians(yin))
zout = zin * np.sin(np.radians(xin))
else:
# Calculate latitude (xout), longitude (yout) and distance from center
# of the Earth (zout)
zout = np.sqrt(xin**2 + yin**2 + zin**2)
xout = np.degrees(np.arcsin(zin / zout))
yout = np.degrees(np.arctan2(yin, xin))
return xout, yout, zout
def gcarToLcar(X, Y, Z, lat, lon, rho , inverse=False):
"""Converts a position from global cartesian to local cartesian
(or vice-versa).
Parameters
----------
X : float
global cartesian X [km] or local cartesian X [km]
Y : flaot
global cartesian Y [km] or local cartesian Y [km]
Z : float
global cartesian Z [km] or local cartesian Z [km]
lat : float
geocentric latitude [degree] of local cartesian system origin
lon : float
geocentric longitude [degree] of local cartesian system origin
rho : float
distance from center of the Earth [km] of local cartesian system origin
inverse : Optional[bool]
inverse conversion
Returns
-------
X : float
local cartesian X [km] or global cartesian X [km]
Y : float
local cartesian Y [km] or global cartesian Y [km]
Z : float
local cartesian Z [km] or global cartesian Z [km]
Notes
-------
The global cartesian coordinate system is defined as:
- origin: center of the Earth
- Z axis in the direction of the rotational axis and through the North
pole
- X axis in the equatorial plane and through the prime meridian.
The local cartesian coordinate system is defined as:
- origin: local position
- X: East
- Y: North
- Z: up
The meaning of the input (X,Y,Z) depends on the direction of the conversion
(to global cartesian or to global spherical).
"""
# First get global cartesian coordinates of local origin
(goX, goY, goZ) = gspToGcar(lat, lon, rho)
if not inverse:
# Translate global position to local origin
tx = X - goX
ty = Y - goY
tz = Z - goZ
# Then, rotate about global-Z to get local-X pointing eastward
rot = -np.radians(lon + 90.0)
sx = tx * np.cos(rot) - ty * np.sin(rot)
sy = tx * np.sin(rot) + ty * np.cos(rot)
sz = tz
# Finally, rotate about X axis to align Z with upward direction
rot = -np.radians(90.0 - lat)
xOut = sx
yOut = sy * np.cos(rot) - sz * np.sin(rot)
zOut = sy * np.sin(rot) + sz * np.cos(rot)
else:
# First rotate about X axis to align Z with Earth rotational axis
# direction
rot = np.radians(90.0 - lat)
sx = X
sy = Y * np.cos(rot) - Z * np.sin(rot)
sz = Y * np.sin(rot) + Z * np.cos(rot)
# Rotate about global-Z to get global-X pointing to the prime meridian
rot = np.radians(lon + 90.)
xOut = sx * np.cos(rot) - sy * np.sin(rot)
yOut = sx * np.sin(rot) + sy * np.cos(rot)
zOut = sz
# Finally, translate local position to global origin
xOut = xOut + goX
yOut = yOut + goY
zOut = zOut + goZ
return xOut, yOut, zOut
def lspToLcar(X, Y, Z, inverse=False):
"""Convert a position from local spherical to local cartesian, or vice-versa
Parameters
----------
X : float
azimuth [degree, N] or local cartesian X [km]
Y : float
elevation [degree] or local cartesian Y [km]
Z : float
distance origin [km] or local cartesian Z [km]
inverse : Optional[bool]
inverse conversion
Returns
-------
X : float
local cartesian X [km] or azimuth [degree, N]
Y : float
local cartesian Y [km] or elevation [degree]
Z : float
local cartesian Z [km] or distance from origin [km]
Notes
------
The local spherical coordinate system is defined as:
- origin: local position
- azimuth (with respect to North)
- Elevation (with respect to horizon)
- Altitude
The local cartesian coordinate system is defined as:
- origin: local position
- X: East
- Y: North
- Z: up
The meaning of the input (X,Y,Z) depends on the direction of the conversion
(to global cartesian or to global spherical).
"""
if not inverse:
# local spherical into local cartesian
r = Z
el = Y
az = X
xOut = r * np.cos(np.radians(el)) * np.sin(np.radians(az))
yOut = r * np.cos(np.radians(el)) * np.cos(np.radians(az))
zOut = r * np.sin(np.radians(el))
else:
# local cartesian into local spherical
r = np.sqrt(X**2 + Y**2 + Z**2)
el = np.degrees(np.arcsin(Z / r))
az = np.degrees(np.arctan2(X, Y))
xOut = az
yOut = el
zOut = r
return xOut, yOut, zOut
# *************************************************************
def calcDistPnt(origLat, origLon, origAlt, dist=None, el=None, az=None,
distLat=None, distLon=None, distAlt=None):
"""Calculate position of a distant point through one of several methods
Parameters
----------
origLat : float
geographic latitude of point of origin [degree]
origLon : float
geographic longitude of point of origin [degree]
origAlt : float
altitude of point of origin [km]
dist : Optional[float]
distance to point [km]
el : Optional[float]
elevation [degree]
az : Optional[float]
azimuth [degree]
distLat : Optional[float]
latitude [degree] of distant point
distLon : Optional[float]
longitude [degree] of distant point
distAlt : Optional[float]
altitide [km] of distant point
Returns
-------
dictOut : (dict of floats)
A dictionary containing the information about the origin and remote
points, as well as their relative positions. The keys are:
origLat - origin latitude in degrees,
origLon - origin longitude in degrees
origAlt - origin altitude in km
distLat - distant latitude in degrees
distLon - distant longitude in degrees
distAlt - distant altitude in km
az - azimuthal angle between origin and distant locations in degrees
el - elevation angle between origin and distant locations in degrees
dist - slant distance between origin and distant locaitons in km
origRe - origin earth radius
distRe - distant earth radius
Notes
-------
Calculation methods
- the coordinates and altitude of a distant point given a point of
origin, distance, azimuth and elevation
- the coordinates and distance of a distant point given a point of
origin, altitude, azimuth and elevation
- the distance, azimuth and elevation between a point of origin and a
distant point
- the distance, azimuth between a point of origin and a distant point
and the altitude of said distant point given a point of origin,
distant point and elevation angle.
Input/output is in geodetic coordinates, distances are in km and angles in
degrees.
"""
# If all the input parameters (keywords) are set to 0, show a warning, and
# default to fint distance/azimuth/elevation
if dist is None and el is None and az is None:
assert None not in [distLat, distLon, distAlt], \
logging.error('Not enough keywords.')
# Convert point of origin from geodetic to geocentric
(gcLat, gcLon, origRe) = geodToGeoc(origLat, origLon)
# Convert distant point from geodetic to geocentric
(gcDistLat, gcDistLon, distRe) = geodToGeoc(distLat, distLon)
# convert distant point from geocentric to global cartesian
(pX, pY, pZ) = gspToGcar(gcDistLat, gcDistLon, distRe + distAlt)
# convert pointing direction from global cartesian to local cartesian
(dX, dY, dZ) = gcarToLcar(pX, pY, pZ, gcLat, gcLon, origRe+origAlt)
# convert pointing direction from local cartesian to local spherical
(gaz, gel, rho) = lspToLcar(dX, dY, dZ, inverse=True)
# convert pointing azimuth and elevation to geodetic
(lat, lon, Re, az, el) = geodToGeocAzEl(gcLat, gcLon, gaz, gel,
inverse=True)
dist = np.sqrt(dX**2 + dY**2 + dZ**2)
elif distLat is None and distLon is None and distAlt is None:
assert None not in [dist, el, az], logging.error('Not enough keywords.')
# convert pointing azimuth and elevation to geocentric
(gcLat, gcLon, origRe, gaz, gel) = geodToGeocAzEl(origLat, origLon, az,
el)
# convert pointing direction from local spherical to local cartesian
(pX, pY, pZ) = lspToLcar(gaz, gel, dist)
# convert pointing direction from local cartesian to global cartesian
(dX, dY, dZ) = gcarToLcar(pX, pY, pZ, gcLat, gcLon, origRe + origAlt,
inverse=True)
# Convert distant point from global cartesian to geocentric
(gcDistLat, gcDistLon, rho) = gspToGcar(dX, dY, dZ, inverse=True)
# Convert distant point from geocentric to geodetic
(distLat, distLon, Re) = geodToGeoc(gcDistLat, gcDistLon, inverse=True)
distAlt = rho - Re
distRe = Re
elif dist is None and distAlt is None and az is None:
assert None not in [distLat, distLon, el], \
logging.error('Not enough keywords')
# Convert point of origin from geodetic to geocentric
(gcLat, gcLon, origRe) = geodToGeoc(origLat, origLon)
Dref = origRe + origAlt
# convert point of origin from geocentric to global cartesian
(pX, pY, pZ) = gspToGcar(gcLat, gcLon, Dref)
# Convert distant point from geodetic to geocentric
(gcDistLat, gcDistLon, distRe) = geodToGeoc(distLat, distLon)
# convert distant point from geocentric to global cartesian
(pdX, pdY, pdZ) = gspToGcar(gcDistLat, gcDistLon, Dref)
# convert pointing direction from global cartesian to local cartesian
(dX, dY, dZ) = gcarToLcar(pdX, pdY, pdZ, gcLat, gcLon, Dref)
# convert pointing direction from local cartesian to local spherical
(gaz, gel, rho) = lspToLcar(dX, dY, dZ, inverse=True)
# convert pointing azimuth and elevation to geodetic
(lat, lon, Re, az, el) = geodToGeocAzEl(gcLat, gcLon, gaz, gel,
inverse=True)
# convert pointing azimuth and elevation to geocentric
(gcLat, gcLon, origRe, gaz, gel) = geodToGeocAzEl(origLat, origLon, az,
el)
# calculate altitude and distance
theta = np.arccos((pdX * pX + pdY * pY + pdZ * pZ) / Dref**2)
distAlt = Dref * (np.cos(np.radians(gel)) /
np.cos(theta + np.radians(gel)) - 1.0)
distAlt -= distRe - origRe
dist = Dref * np.sin(theta) / np.cos(theta + np.radians(gel))
elif distLat is None and distLon is None and dist is None:
assert None not in [distAlt, el, az], \
logging.error('Not enough keywords')
# convert pointing azimuth and elevation to geocentric
(gcLat, gcLon, origRe, gaz, gel) = geodToGeocAzEl(origLat, origLon, az,
el)
# Calculate angles
alpha = np.arcsin((origRe + origAlt) * np.cos(np.radians(gel)) /
(origRe + distAlt))
theta = np.pi / 2.0 - alpha - np.radians(gel)
# calculate distance
dist = np.sqrt((origRe + origAlt)**2 + (origRe + distAlt)**2 - 2.0 *
(origRe + distAlt) * (origRe + origAlt) * np.cos(theta))
# convert pointing direction from local spherical to local cartesian
(pX, pY, pZ) = lspToLcar(gaz, gel, dist)
# convert pointing direction from local cartesian to global cartesian
(dX, dY, dZ) = gcarToLcar(pX, pY, pZ, gcLat, gcLon, origRe+origAlt,
inverse=True)
# Convert distant point from global cartesian to geocentric
(gcDistLat, gcDistLon, rho) = gspToGcar(dX, dY, dZ, inverse=True)
# Convert distant point from geocentric to geodetic
(distLat, distLon, distRe) = geodToGeoc(gcDistLat, gcDistLon,
inverse=True)
distAlt = rho - distRe
else:
return dict()
# Fill output dictionary
dictOut = {'origLat': origLat, 'origLon': origLon, 'origAlt': origAlt,
'distLat': distLat, 'distLon': distLon, 'distAlt': distAlt,
'az': az, 'el': el, 'dist': dist, 'origRe': origRe,
'distRe': distRe}
return dictOut
def greatCircleMove(origLat, origLon, dist, az, alt=0.0, Re=6371.0):
"""Calculates the coordinates of an end point along a great circle path
given the original coordinates, distance, azimuth, and altitude.
Parameters
----------
origLat : float
latitude [degree]
origLon : float
longitude [degree]
dist : float
distance [km]
az : float
azimuth [deg]
alt : Optional[float]
altitude [km] added to default Re = 6378.1 km (default=0.0)
Re : Optional[float]
Earth radius (default=6371.0)
Returns
-------
latitude : (float)
latitude in degrees
longitude: (float)
longitude in degrees
"""
Re_tot = (Re + alt) * 1.0e3
dist = dist * 1.0e3
lat1 = np.radians(origLat)
lon1 = np.radians(origLon)
az = np.radians(az)
lat2 = np.arcsin(np.sin(lat1) * np.cos(dist / Re_tot) +
np.cos(lat1) * np.sin(dist / Re_tot) * np.cos(az))
lon2 = lon1 + np.arctan2(np.sin(az) * np.sin(dist / Re_tot) * np.cos(lat1),
np.cos(dist / Re_tot)
- np.sin(lat1) * np.sin(lat2))
# Convert everything to numpy arrays to make selective processing easier.
ret_lat = np.degrees(lat2)
ret_lon = np.degrees(lon2)
ret_lat = np.array(ret_lat)
if ret_lat.shape == ():
ret_lat.shape = (1,)
ret_lon = np.array(ret_lon)
if ret_lon.shape == ():
ret_lon.shape = (1,)
# Put all longitudes on -180 to 180 domain.
ret_lon = ret_lon % 360.0
tf = ret_lon > 180.0
ret_lon[tf] = ret_lon[tf] - 360.0
return (ret_lat, ret_lon)
def greatCircleAzm(lat1, lon1, lat2, lon2):
"""Calculates the azimuth from the coordinates of a start point to and end
point along a great circle path.
Parameters
----------
lat1 : float
latitude [deg]
lon1 : float
longitude [deg]
lat2 : float
latitude [deg]
lon2 : float
longitude [deg]
Returns
-------
azm : float
azimuth [deg]
"""
lat1 = np.radians(lat1)
lon1 = np.radians(lon1)
lat2 = np.radians(lat2)
lon2 = np.radians(lon2)
dlon = lon2 - lon1
y = np.sin(dlon) * np.cos(lat2)
x = np.cos(lat1) * np.sin(lat2) - np.sin(lat1) * np.cos(lat2) * np.cos(dlon)
azm = np.degrees(np.arctan2(y,x))
return azm
def greatCircleDist(lat1, lon1, lat2, lon2):
"""Calculates the distance in radians along a great circle path between two
points.
Parameters
----------
lat1 : float
latitude [deg]
lon1 : float
longitude [deg]
lat2 : float
latitude [deg]
lon2 : float
longitude [deg]
Returns
-------
radDist : float
distance [radians]
"""
lat1 = np.radians(lat1)
lon1 = np.radians(lon1)
lat2 = np.radians(lat2)
lon2 = np.radians(lon2)
dlat = (lat2 - lat1) / 2.0
dlon = (lon2 - lon1) / 2.0
a = np.sin(dlat)**2 + np.cos(lat1) * np.cos(lat2) * np.sin(dlon)**2
radDist = 2.0 * np.arctan2(np.sqrt(a), | np.sqrt(1.0 - a) | numpy.sqrt |
"""
This module is an implementation of a variety of tools for rotations in 3D space.
"""
from __future__ import print_function, absolute_import # Compatibility with python 2 and 3
import sys, numpy, types, pickle, time, math
import logging
logger = logging.getLogger(__name__)
from .log import log_and_raise_error,log_warning,log_info,log_debug
import condor.utils.linalg
# CANONICAL ROTATION MATRICES
# Rotation matrix around x-axis - observing the right hand rule
R_x = lambda t: numpy.array([[1., 0., 0.],
[0., numpy.cos(t), -numpy.sin(t)],
[0., numpy.sin(t), numpy.cos(t)]])
# Rotation matrix around y-axis - observing the right hand rule
R_y = lambda t: numpy.array([[numpy.cos(t), 0., numpy.sin(t)],
[0., 1., 0.],
[-numpy.sin(t), 0., numpy.cos(t)]])
# Rotation matrix around z-axis - observing the right hand rule
R_z = lambda t: numpy.array([[numpy.cos(t), -numpy.sin(t), 0.],
[numpy.sin(t), numpy.cos(t), 0.],
[0., 0., 1.]])
# Rotation of a given vector by a given angle with respect to one of the three principal axes
rot_x = lambda v,t: R_x(t).dot(v)
rot_y = lambda v,t: R_y(t).dot(v)
rot_z = lambda v,t: R_z(t).dot(v)
# CANONICAL QUATERNIONS
# Quaternion from angle and rotation unit vector coordinates (right-hand rule)
quat = lambda theta,ux,uy,uz: numpy.array([numpy.cos(theta/2.),
numpy.sin(theta/2.)*ux,
numpy.sin(theta/2.)*uy,
numpy.sin(theta/2.)*uz])
# Quaternions for roations with respect to the x-, y- or z-axis
quat_x = lambda theta: quat(theta,1.,0.,0.)
quat_y = lambda theta: quat(theta,0.,1.,0.)
quat_z = lambda theta: quat(theta,0.,0.,1.)
class Rotation:
r"""
Class for a rotation in 3D space
**Arguments:**
:values (array): Array of values that define the rotation. For random rotations set values=``None`` and for example formalism=``'random'``. (default ``None``)
:formalism: Formalism that defines how the argument values is interpreted. If ``None`` no rotation. (default ``None``)
*Rotation formalism can be one of the following:*
======================== =========================================================================================================================== ===============================================================================
``formalism`` Variables ``values``
======================== =========================================================================================================================== ===============================================================================
``'quaternion'`` :math:`q = w + ix + jy + kz` :math:`[w,x,y,z]`
``'rotation_matrix'`` :math:`R = \begin{pmatrix} R_{11} & R_{12} & R_{13} \\ R_{21} & R_{22} & R_{23} \\ R_{31} & R_{32} & R_{33} \end{pmatrix}` :math:`[[R_{11},R_{12},R_{13}],[R_{21},R_{22},R_{23}],[R_{31},R_{32},R_{33}]]`
``'euler_angles_zxz'`` :math:`e_1^{(z)}`, :math:`e_2^{(x)}`, :math:`e_3^{(z)}` :math:`[e_1^{(y)},e_2^{(z)},e_3^{(y)}]`
``'euler_angles_xyx'`` :math:`e_1^{(x)}`, :math:`e_2^{(y)}`, :math:`e_3^{(x)}` :math:`[e_1^{(x)},e_2^{(y)},e_3^{(x)}]`
``'euler_angles_xyz'`` :math:`e_1^{(x)}`, :math:`e_2^{(y)}`, :math:`e_3^{(z)}` :math:`[e_1^{(x)},e_2^{(y)},e_3^{(z)}]`
``'euler_angles_yzx'`` :math:`e_1^{(y)}`, :math:`e_2^{(z)}`, :math:`e_3^{(x)}` :math:`[e_1^{(y)},e_2^{(z)},e_3^{(x)}]`
``'euler_angles_zxy'`` :math:`e_1^{(z)}`, :math:`e_2^{(x)}`, :math:`e_3^{(y)}` :math:`[e_1^{(z)},e_2^{(x)},e_3^{(y)}]`
``'euler_angles_zyx'`` :math:`e_1^{(z)}`, :math:`e_2^{(y)}`, :math:`e_3^{(x)}` :math:`[e_1^{(z)},e_2^{(y)},e_3^{(x)}]`
``'euler_angles_yxz'`` :math:`e_1^{(y)}`, :math:`e_2^{(x)}`, :math:`e_3^{(z)}` :math:`[e_1^{(y)},e_2^{(x)},e_3^{(z)}]`
``'euler_angles_xzy'`` :math:`e_1^{(x)}`, :math:`e_2^{(z)}`, :math:`e_3^{(y)}` :math:`[e_1^{(x)},e_2^{(z)},e_3^{(y)}]`
``'random'`` *fully random rotation* ``None``
``'random_x'`` *random rotation around* :math:`x` *axis* ``None``
``'random_y'`` *random rotation around* :math:`y` *axis* ``None``
``'random_z'`` *random rotation around* :math:`z` *axis* ``None``
======================== =========================================================================================================================== ===============================================================================
"""
def __init__(self, values=None, formalism=None):
self.rotation_matrix = None
if values is None and formalism is None:
# No rotation (rotation matrix = identity matrix)
self.rotation_matrix = numpy.ones(shape=(3,3))
elif formalism.startswith("euler_angles_") and len(formalism) == len("euler_angles_xyz"):
self.set_with_euler_angles(values, rotation_axes=formalism[-3:])
elif formalism == "rotation_matrix":
self.set_with_rotation_matrix(values)
elif formalism == "quaternion":
self.set_with_quaternion(values)
elif formalism in ["random","random_x","random_y","random_z"]:
if values is not None:
log_warning(logger, "Specified formalism=%s but values is not None." % formalism)
self._set_as_random_formalism(formalism)
else:
log_and_raise_error(logger, "formalism=%s is not implemented" % formalism)
return
def set_with_euler_angles(self, euler_angles, rotation_axes="zxz"):
r"""
Set rotation with an array of three euler angles
Args:
:euler_angles: Array of the three euler angles representing consecutive rotations
Kwargs:
:rotation_axes(str): Rotation axes of the three consecutive rotations (default = \'zxz\')
"""
# Check input
if euler_angles.size != 3:
log_and_raise_error(logger, "Size of rotation variable does not match expected shape")
return
# Set rotation matrix
self.rotation_matrix = euler_to_rotmx(euler_angles, rotation_axes)
def set_with_rotation_matrix(self, rotation_matrix):
r"""
Set rotation with a rotation matrix
Args:
:rotation_matrix: 3x3 array representing the rotation matrix
"""
# Check input
if rotation_matrix.size != 9 or rotation_matrix.ndim != 2:
log_and_raise_error(logger, "Size of rotation variable does not match expected shape")
return
I = rotation_matrix.dot(rotation_matrix.T)
tol = 0.0001
for i in range(3):
if abs(I[i,i]-1.) > tol:
log_and_raise_error(logger, "Given matrix cannot be a rotation matrix because it is not unitary")
# Set rotation matrix
self.rotation_matrix = rotation_matrix.copy()
def set_with_quaternion(self, quaternion):
r"""
Set rotation with a quaternion
Args:
:quaternion: Numpy array representing the quaternion :math:`w+ix+jy+kz`:
[:math:`w`, :math:`x`, :math:`y`, :math:`z`] = [:math:`\cos(\theta/2)`, :math:`u_x \sin(\theta/2)`, :math:`u_y \sin(\theta/2)`, :math:`u_z \sin(\theta/2)`]
with :math:`\theta` being the rotation angle and :math:`\vec{u}=(u_x,u_y,u_z)` the unit vector that defines the axis of rotation.
"""
# Check input
if quaternion.size != 4:
log_and_raise_error(logger, "Size of rotation variable does not match expected shape")
return
# Set rotation matrix
self.rotation_matrix = rotmx_from_quat(quaternion)
def _set_as_random_formalism(self, formalism):
if formalism == "random":
self.set_as_random()
elif formalism == "random_x":
self.set_as_random_x()
elif formalism == "random_y":
self.set_as_random_y()
elif formalism == "random_z":
self.set_as_random_z()
def set_as_random(self):
"""
Set new random rotation (fully random).
"""
q = rand_quat()
self.rotation_matrix = rotmx_from_quat(q)
def set_as_random_x(self):
"""
Set new random rotation around the :math:`x`-axis.
"""
ang = numpy.random.rand()*2*numpy.pi
self.rotation_matrix = R_x(ang)
def set_as_random_y(self):
"""
Set new random rotation around the :math:`y`-axis.
"""
ang = numpy.random.rand()*2*numpy.pi
self.rotation_matrix = R_y(ang)
def set_as_random_z(self):
"""
Set new random rotation around the :math:`z`-axis.
"""
ang = numpy.random.rand()*2*numpy.pi
self.rotation_matrix = R_z(ang)
def invert(self):
"""
Invert rotation
"""
q = self.get_as_quaternion()
q[1:] = -q[1:]
self.set_with_quaternion(q)
def is_similar(self, rotation, tol=0.00001):
r"""
Compare rotation with another instance of the Rotation class. If quaternion distance is smaller than tol return ``True``
Args:
:rotation (:class:`condor.utils.rotation.Rotation`): Instance of the Rotation class
Kwargs:
:tol (float): Tolerance for similarity. This is the maximum distance of the two quaternions in 4D space that will be interpreted for similar rotations. (default 0.00001)
"""
q0 = self.get_as_quaternion(unique_representation=True)
q1 = rotation.get_as_quaternion(unique_representation=True)
err = numpy.sqrt(((q0-q1)**2).sum())
return (err < tol)
def rotate_vector(self, vector, order="xyz"):
r"""
Return the rotated copy of a given vector
Args:
:vector (array): 3D vector
Kwargs:
:order (str): Order of geometrical axes in array representation of the given vector (default ``'xyz'``)
"""
# Check input
if vector.size != 3 or vector.ndim != 1:
log_and_raise_error(logger, "Cannot rotate vector. Vector has incompatible size (%i) or number of dimensions (%i)." % (vector.size,vector.ndim))
return
# Rotate
if order == "xyz":
return self.rotation_matrix.dot(vector)
elif order == "zyx":
return self.rotation_matrix.dot(vector[::-1])
else:
log_and_raise_error(logger, "Corrdinates in order=%s is invalid." % order)
def rotate_vectors(self, vectors, order="xyz"):
r"""
Return the rotated copy of a given array of vectors
Args:
:vectors (array): Array of 3D vectors with shape (:math:`N`, 3) with :math:`N` denoting the number of 3D vectors
Kwargs:
:order (str): Order of geometrical axes in array representation of the given vector (default ``'xyz'``)
"""
# Check input
if vectors.ndim != 2 and vectors.ndim != 1:
log_and_raise_error(logger, "Cannot rotate vectors. Input must have either one or two dimensions")
return
n_ax = list(vectors.shape)[-1]
N = vectors.size
Nv = int(N/3)
if vectors.ndim == 2 and n_ax != 3:
log_and_raise_error(logger, "Cannot rotate vectors. The given array has length %i in last dimension but should be 3." % (n_ax))
return
if vectors.ndim == 1 and N % 3 != 0:
log_and_raise_error(logger, "Cannot rotate vectors. The given array has size %i which is not a multiple of 3." % (n_ax))
return
# Rotate
if order == "xyz":
return numpy.array([numpy.dot(self.rotation_matrix,vectors.ravel()[i*3:(i+1)*3]) for i in numpy.arange(Nv)])
elif order == "zyx":
return numpy.array([numpy.dot(self.rotation_matrix,(vectors.ravel()[i*3:(i+1)*3])[::-1])[::-1] for i in numpy.arange(Nv)])
else:
log_and_raise_error(logger, "Corrdinates in order=%s is invalid." % order)
def get_as_euler_angles(self, rotation_axes="zxz"):
r"""
Get rotation in Euler angle represantation :math:`[e_1^{(z)}, e_2^{(x)}, e_3^{(z)}]` (for the case of ``rotation_axis='zxz'``).
Kwargs:
:rotation_axes (str): Rotation axes of the three rotations (default ``'zxz'``)
"""
q = self.get_as_quaternion()
return euler_from_quat(q, rotation_axes=rotation_axes)
def get_as_rotation_matrix(self):
r"""
Get rotation in rotation matrix representation (3x3 array)
"""
return self.rotation_matrix.copy()
def get_as_quaternion(self, unique_representation=False):
r"""
Get rotation in quaternion representation :math:`[w, x, y, z]`.
Kwargs:
:unique_representation (bool): Make quaternion unique. For more details see the documentation of :func:`condor.utils.rotation.unique_representation_quat` (default = False)
"""
q = quat_from_rotmx(self.rotation_matrix)
if unique_representation:
q = unique_representation_quat(q)
return q
class Rotations:
r"""
Class for a list of rotations in 3D space
Args:
:values (array): Arrays of values that define the rotation. For random rotations set ``values = None`` (default ``None``)
:formalism (str): See :class:`condor.utils.rotation.Rotation`. For no rotation set ``formalism = None`` (default ``None``)
"""
def __init__(self, values=None, formalism=None):
"""
"""
if values is None and formalism is None:
single = True
elif formalism.startswith("euler_angles_") and len(formalism) == len("euler_angles_xyz"):
values = numpy.asarray(values)
single = values.ndim == 1
elif formalism == "rotation_matrix":
values = numpy.asarray(values)
single = values.ndim == 2
elif formalism == "quaternion":
values = numpy.asarray(values)
single = values.ndim == 1
elif formalism in ["random","random_x","random_y","random_z"]:
single = True
else:
log_and_raise_error(logger, "formalism=%s is not implemented" % formalism)
return
self._formalism = formalism
self._i = 0
self._values = values
# Initialise rotations
if single:
if values is None:
# No rotation (rotation matrix = identity matrix)
self._rotations = [Rotation()]
else:
self._rotations = [Rotation(values, formalism=formalism)]
else:
self._rotations = []
for i in range(len(values)):
self._rotations.append(Rotation(values[i], formalism=formalism))
def get_formalism(self):
"""
Return formalism that defines how the rotation values are geometrically interpreted
"""
return self._formalism
def get_next_rotation(self):
"""
Iterate and return next rotation
"""
if self._formalism in ["random","random_x","random_y","random_z"]:
self._rotations[0]._set_as_random_formalism(self._formalism)
rotation = self.get_current_rotation()
self._i += 1
return rotation
def get_current_rotation(self):
"""
Return current rotation
"""
return self._rotations[self._i % len(self._rotations)]
def get_all_values(self):
"""
Return all values that define the rotations
"""
return self._values
# CONVERSIONS BETWEEN THE DIFFERENT REPRESENTATIONS
def euler_to_rotmx(euler_angles, rotation_axes="zxz"):
r"""
Obtain rotation matrix from three euler angles and the rotation axes
Args:
:euler_angles (array): Length-3 array of euler angles
Kwargs:
:rotation_axes (str): Rotation axes of the three consecutive Euler rotations (default ``'zxz'``)
"""
R = numpy.identity(3)
for ang,ax in zip(euler_angles, rotation_axes):
if ax == "x":
R = R.dot(R_x(ang))
elif ax == "y":
R = R.dot(R_y(ang))
elif ax == "z":
R = R.dot(R_z(ang))
else:
log_and_raise_error(logger, "%s is not a valid axis" % ax)
return
return R
def rotmx_from_quat(q):
r"""
Create a rotation matrix from given quaternion ([Shoemake1992]_ page 128)
Args:
:quaternion (array): :math:`q = w + ix + jy + kz` (``values``: :math:`[w,x,y,z]`)
The direction of rotation follows the right hand rule
"""
w,x,y,z = q
R = numpy.array([[1.-2.*(y**2+z**2),
2.*(x*y-w*z),
2.*(x*z+w*y)],
[2.*(x*y+w*z),
1.-2.*(x**2+z**2),
2.*(y*z-w*x)],
[2.*(x*z-w*y),
2.*(y*z+w*x),
1.-2.*(x**2+y**2)]])
return R
# Quaternion from rotation matrix
def quat_from_rotmx(R):
r"""
Obtain the quaternion from a given rotation matrix (ref. [euclidianspace_mxToQuat]_)
Args:
:R: 3x3 array that represent the rotation matrix (see `Conventions <conventions.html#matrices>`_)
"""
q = numpy.zeros(4, dtype="float")
q[0] = numpy.sqrt( max( 0, 1 + R[0,0] + R[1,1] + R[2,2] ) ) / 2.
q[1] = numpy.sqrt( max( 0, 1 + R[0,0] - R[1,1] - R[2,2] ) ) / 2.
q[2] = numpy.sqrt( max( 0, 1 - R[0,0] + R[1,1] - R[2,2] ) ) / 2.
q[3] = numpy.sqrt( max( 0, 1 - R[0,0] - R[1,1] + R[2,2] ) ) / 2.
q[1] = numpy.copysign( q[1], R[2,1] - R[1,2] )
q[2] = numpy.copysign( q[2], R[0,2] - R[2,0] )
q[3] = numpy.copysign( q[3], R[1,0] - R[0,1] )
return q
# Euler angles from rotation matrix
def euler_from_quat(q, rotation_axes="zxz"):
r"""
Return euler angles from quaternion (ref. [euclidianspace_mxToQuat]_, [euclidianspace_quatToEul]_).
Args:
:q: Numpy array :math:`[w,x,y,z]` that represents the quaternion
Kwargs:
:rotation_axes(str): Rotation axes of the three consecutive Euler rotations (default ``\'zxz\'``)
"""
if len(rotation_axes) != 3:
print("Error: rotation_axes = %s is an invalid input." % rotation_axes)
return
for s in rotation_axes:
if s not in "xyz":
print("Error: rotation_axes = %s is an invalid input." % rotation_axes)
return
i1 = 0 if rotation_axes[0] == "x" else 1 if rotation_axes[0] == "y" else 2 if rotation_axes[0] == "z" else None
i2 = 0 if rotation_axes[1] == "x" else 1 if rotation_axes[1] == "y" else 2 if rotation_axes[1] == "z" else None
i3 = 0 if rotation_axes[2] == "x" else 1 if rotation_axes[2] == "y" else 2 if rotation_axes[2] == "z" else None
v3 = numpy.array([0.,0.,0.])
v3[i3] = 1.
v3r = rotate_quat(v3, q)
if abs(v3r[i1]) > 1.:
v3r[i1] = numpy.sign(v3r[i1])
if ((i1==0) and (i2==2) and (i3==0)) or \
((i1==1) and (i2==0) and (i3==1)) or \
((i1==2) and (i2==1) and (i3==2)):
e0 = numpy.arctan2(v3r[(i1+2)%3],v3r[(i1+1)%3])
e1 = numpy.arccos(v3r[i1])
elif ((i1==0) and (i2==2) and (i3==1)) or \
((i1==1) and (i2==0) and (i3==2)) or \
((i1==2) and (i2==1) and (i3==0)):
e0 = numpy.arctan2(v3r[(i1+2)%3],v3r[(i1+1)%3])
e1 = -numpy.arcsin(v3r[i1])
elif ((i1==0) and (i2==1) and (i3==0)) or \
((i1==1) and (i2==2) and (i3==1)) or \
((i1==2) and (i2==0) and (i3==2)):
e0 = numpy.arctan2(v3r[(i1+1)%3],-v3r[(i1+2)%3])
e1 = numpy.arccos(v3r[i1])
else:
e0 = numpy.arctan2(-v3r[(i1+1)%3],v3r[(i1+2)%3])
# The reference states this:
#e1 = -numpy.arcsin(v3r[i1])
# The tests only pass with the inverse sign, so I guess this is a typo.
e1 = numpy.arcsin(v3r[i1])
q1 = numpy.array([numpy.cos(e0/2.), 0., 0., 0.])
q1[1+i1] = | numpy.sin(e0/2.) | numpy.sin |
from .coco import CocoDataset
from .registry import DATASETS
import numpy as np
from collections import defaultdict
from ..core.evaluation.bbox_overlaps import bbox_overlaps
from tqdm import tqdm
import pandas as pd
from sklearn.metrics import average_precision_score, precision_recall_curve
import os.path as osp
import time
import re
from pycocotools.coco import COCO
@DATASETS.register_module
class PrwDataset(CocoDataset):
CLASSES = ('person',)
def load_annotations(self, ann_file):
self.coco = COCO(ann_file)
self.cat_ids = self.coco.getCatIds()
self.cat2label = {
cat_id: i + 1
for i, cat_id in enumerate(self.cat_ids)
}
self.img_ids = self.coco.getImgIds()
img_infos = []
for i in self.img_ids:
info = self.coco.loadImgs([i])[0]
info['filename'] = info['file_name']
info['cam_id'] = self._get_cam_id(info['file_name'])
ann_ids = self.coco.getAnnIds(imgIds=[i])
ann_info = self.coco.loadAnns(ann_ids)
ann = self._parse_ann_info(ann_info, False)
info.update(ann)
img_infos.append(info)
return img_infos
def get_ann_info(self, idx):
img_id = self.img_infos[idx]['id']
ann_ids = self.coco.getAnnIds(imgIds=[img_id])
ann_info = self.coco.loadAnns(ann_ids)
return self._parse_ann_info(ann_info, self.with_mask)
def _get_cam_id(self, im_name):
match = re.search('c\d', im_name).group().replace('c', '')
return int(match)
def map_class_id_to_class_name(self, class_id):
return self.CLASSES[class_id]
def evaluate(self, predictions, dataset):
if self.with_reid:
result = self.evaluate_reid(predictions, dataset)
else:
result = self.evaluate_detection(predictions)
result_str = "\n##########################################\n"
for k, v in result.items():
result_str += '{} = {} \n'.format(k, v)
result_str += "###########################################\n"
return result_str
def evaluate_reid(self, predictions, dataset, gallery_size=-1, iou_thr=0.5):
# detection
pred_boxlists = []
gt_boxlists = []
for image_id, prediction in enumerate(tqdm(predictions[0])):
if len(prediction) == 0:
continue
pred_boxlists.append(prediction[0][0][0])
gt_boxlist = dataset[0].get_ann_info(image_id)['bboxes']
gt_boxlists.append(gt_boxlist)
det_result = self.eval_detection_sysu(pred_boxlists=pred_boxlists, gt_boxlists=gt_boxlists,
iou_thresh=iou_thr, use_07_metric=False)
# person search
reid_result, save_result = self.search_performance_calc(predictions, dataset, gallery_size)
reid_result.update(det_result)
return reid_result
def evaluate_detection(self, predictions, iou_thr=0.5):
pred_boxlists = []
gt_boxlists = []
for image_id, prediction in enumerate(predictions[0]):
prediction = prediction[0] # TODO n_box * 5
gt_boxlist = self.get_ann_info(image_id)['bboxes']
if len(prediction) == 0:
continue
pred_boxlists.append(prediction)
gt_boxlists.append(gt_boxlist)
result = self.eval_detection_sysu(pred_boxlists=pred_boxlists, gt_boxlists=gt_boxlists,
iou_thresh=iou_thr, use_07_metric=False)
return result
def eval_detection_sysu(self, pred_boxlists, gt_boxlists, iou_thresh=0.5, use_07_metric=False):
"""Evaluate on voc dataset.
Args:
pred_boxlists(list[BoxList]): pred boxlist, has labels and scores fields.
gt_boxlists(list[BoxList]): ground truth boxlist, has labels field.
iou_thresh: iou thresh
use_07_metric: boolean
Returns:
dict represents the results
"""
assert len(gt_boxlists) == len(
pred_boxlists
), "Length of gt and pred lists need to be same."
prec, rec = self.calc_detection_sysu_prec_rec(
pred_boxlists=pred_boxlists, gt_boxlists=gt_boxlists, iou_thresh=iou_thresh
)
ap = self.calc_detection_sysu_ap(prec, rec, use_07_metric=use_07_metric)
result = {}
result.update({'Detection_Precision': np.round(100 * np.nanmean(prec[1]), 2)})
result.update({'Detection_Recall': np.round(100 * np.nanmean(rec[1]), 2)})
result.update({'Detection_mean_Avg_Precision': np.round(100 * np.nanmean(ap), 2)})
print(result)
return result
def search_performance_calc(self, predictions, dataset, gallery_size=-1, det_thresh=0.5, ignore_cam_id=True):
"""
gallery_det (list of ndarray): n_det x [x1, x2, y1, y2, score] per image
gallery_feat (list of ndarray): n_det x D features per image
probe_feat (list of ndarray): D dimensional features per probe image
det_thresh (float): filter out gallery detections whose scores below this
gallery_size (int): -1 for using full set
ignore_cam_id (bool): Set to True acoording to CUHK-SYSU,
alyhough it's a common practice to focus on cross-cam match only.
"""
dataset_test, dataset_query = dataset
predictions_test, predictions_query = predictions
probe_feat = [gt[-1] for gt in predictions_query]
gallery_det = []
gallery_feat = []
for image_id, prediction in enumerate(predictions_test):
if len(prediction) == 0:
continue
gallery_feat.append(prediction[-1])
gallery_det.append(prediction[0][0][0])
assert len(dataset_test) == len(gallery_det)
assert len(dataset_test) == len(gallery_feat)
assert len(dataset_query) == len(probe_feat)
gt_roidb = dataset_test.img_infos
query_roidb = dataset_query.img_infos
# gt_roidb = gallery_set.record
name_to_det_feat = {}
for gt, det, feat in zip(gt_roidb, gallery_det, gallery_feat):
name = gt['file_name']
pids = gt['labels'][:, -1]
cam_id = gt['cam_id']
scores = det[:, 4].ravel()
inds = np.where(scores >= det_thresh)[0]
if len(inds) > 0:
name_to_det_feat[name] = (det[inds], feat[inds], pids, cam_id)
aps = []
accs = []
topk = [1, 5, 10]
ret = {}
save_results = []
for i in tqdm(range(len(dataset_query))):
y_true, y_score = [], []
imgs, rois = [], []
count_gt, count_tp = 0, 0
feat_p = probe_feat[i].ravel()
probe_imname = query_roidb[i]['file_name']
probe_roi = query_roidb[i]['bboxes']
probe_pid = query_roidb[i]['labels'][:, -1]
probe_cam = query_roidb[i]['cam_id']
# Find all occurence of this probe
gallery_imgs = []
for x in gt_roidb:
if probe_pid in x['labels'][:, -1] and x['file_name'] != probe_imname:
gallery_imgs.append(x)
probe_gts = {}
for item in gallery_imgs:
probe_gts[item['file_name']] = item['bboxes'][item['labels'][:, -1] == probe_pid]
# Construct gallery set for this probe
if ignore_cam_id:
gallery_imgs = []
for x in gt_roidb:
if x['file_name'] != probe_imname:
gallery_imgs.append(x)
else:
gallery_imgs = []
for x in gt_roidb:
if x['file_name'] != probe_imname and x['cam_id'] != probe_cam:
gallery_imgs.append(x)
# # 1. Go through all gallery samples
# for item in testset.targets_db:
# Gothrough the selected gallery
for item in gallery_imgs:
gallery_imname = item['file_name']
# some contain the probe (gt not empty), some not
count_gt += (gallery_imname in probe_gts)
# compute distance between probe and gallery dets
if gallery_imname not in name_to_det_feat:
continue
det, feat_g, _, _ = name_to_det_feat[gallery_imname]
# get L2-normalized feature matrix NxD
assert feat_g.size == np.prod(feat_g.shape[:2])
feat_g = feat_g.reshape(feat_g.shape[:2])
# compute cosine similarities
sim = feat_g.dot(feat_p).ravel()
# assign label for each det
label = np.zeros(len(sim), dtype=np.int32)
if gallery_imname in probe_gts:
gt = probe_gts[gallery_imname].ravel()
w, h = gt[2] - gt[0], gt[3] - gt[1]
iou_thresh = min(0.5, (w * h * 1.0) /
((w + 10) * (h + 10)))
inds = np.argsort(sim)[::-1]
sim = sim[inds]
det = det[inds]
# only set the first matched det as true positive
for j, roi in enumerate(det[:, :4]):
if self._compute_iou(roi, gt) >= iou_thresh:
label[j] = 1
count_tp += 1
break
y_true.extend(list(label))
y_score.extend(list(sim))
imgs.extend([gallery_imname] * len(sim))
rois.extend(list(det))
# 2. Compute AP for this probe (need to scale by recall rate)
y_score = np.asarray(y_score)
y_true = np.asarray(y_true)
assert count_tp <= count_gt
recall_rate = count_tp * 1.0 / count_gt
ap = 0 if count_tp == 0 else \
average_precision_score(y_true, y_score) * recall_rate
aps.append(ap)
inds = np.argsort(y_score)[::-1]
y_score = y_score[inds]
y_true = y_true[inds]
accs.append([min(1, sum(y_true[:k])) for k in topk])
# 4. Save result for JSON dump
new_entry = {'probe_img': str(probe_imname),
'probe_roi': map(float, list(probe_roi.squeeze())),
'probe_gt': probe_gts,
'gallery': []}
# only save top-10 predictions
for k in range(10):
new_entry['gallery'].append({
'img': str(imgs[inds[k]]),
'roi': map(float, list(rois[inds[k]])),
'score': float(y_score[k]),
'correct': int(y_true[k]),
})
save_results.append(new_entry)
print('search ranking:')
mAP = np.mean(aps)
print(' mAP = {:.2%}'.format(mAP))
ret['Person_Search_mAP'] = np.round(100 * np.mean(aps), 2)
accs = np.mean(accs, axis=0)
for i, k in enumerate(topk):
print(' top-{:2d} = {:.2%}'.format(k, accs[i]))
ret['Person_Search_Rank-'+str(k)] = np.round(100 * accs[i], 2)
return ret, save_results
def calc_detection_sysu_prec_rec(self, gt_boxlists, pred_boxlists, iou_thresh=0.5):
"""Calculate precision and recall based on evaluation code of PASCAL VOC.
This function calculates precision and recall of
predicted bounding boxes obtained from a dataset which has :math:`N`
images.
The code is based on the evaluation code used in PASCAL VOC Challenge.
"""
n_pos = defaultdict(int)
score = defaultdict(list)
match = defaultdict(list)
for gt_boxlist, pred_boxlist in zip(gt_boxlists, pred_boxlists):
pred_bbox = pred_boxlist[:, :4]
pred_label = np.ones(pred_bbox.shape[0]) # TODO
pred_score = pred_boxlist[:, -1]
gt_bbox = gt_boxlist
gt_label = np.ones(gt_bbox.shape[0]) # TODO
gt_difficult = np.zeros(gt_bbox.shape[0]) # TODO
for l in np.unique(np.concatenate((pred_label, gt_label)).astype(int)):
pred_mask_l = pred_label == l
pred_bbox_l = pred_bbox[pred_mask_l]
pred_score_l = pred_score[pred_mask_l]
# sort by score
order = pred_score_l.argsort()[::-1]
pred_bbox_l = pred_bbox_l[order]
pred_score_l = pred_score_l[order]
gt_mask_l = gt_label == l
gt_bbox_l = gt_bbox[gt_mask_l]
gt_difficult_l = gt_difficult[gt_mask_l]
n_pos[l] += np.logical_not(gt_difficult_l).sum()
score[l].extend(pred_score_l)
if len(pred_bbox_l) == 0:
continue
if len(gt_bbox_l) == 0:
match[l].extend((0,) * pred_bbox_l.shape[0])
continue
# VOC evaluation follows integer typed bounding boxes.
pred_bbox_l = pred_bbox_l.copy()
pred_bbox_l[:, 2:] += 1
gt_bbox_l = gt_bbox_l.copy()
gt_bbox_l[:, 2:] += 1
iou = bbox_overlaps(pred_bbox_l, gt_bbox_l)
gt_index = iou.argmax(axis=1)
# set -1 if there is no matching ground truth
gt_index[iou.max(axis=1) < iou_thresh] = -1
del iou
selec = np.zeros(gt_bbox_l.shape[0], dtype=bool)
for gt_idx in gt_index:
if gt_idx >= 0:
if gt_difficult_l[gt_idx]:
match[l].append(-1)
else:
if not selec[gt_idx]:
match[l].append(1)
else:
match[l].append(0)
selec[gt_idx] = True
else:
match[l].append(0)
n_fg_class = max(n_pos.keys()) + 1
prec = [None] * n_fg_class
rec = [None] * n_fg_class
for l in n_pos.keys():
score_l = np.array(score[l])
match_l = | np.array(match[l], dtype=np.int8) | numpy.array |
import os
import io
import numpy as np
import torch
from scipy.ndimage.filters import gaussian_filter
from scipy.interpolate import RectBivariateSpline
from scipy.spatial.distance import cdist
from skimage.transform import resize as resize_image
from skimage import measure
from skimage.color import rgb2gray
from tqdm import tqdm
import matplotlib.pyplot as plt
from mpl_toolkits.axes_grid1 import make_axes_locatable
from matplotlib import colors
from IPython.display import Image, display, clear_output
from matplotlib.collections import LineCollection
from DeepTopOpt.FEA import LinearElasticity # local library
def plot_design(ax,mesh,rho,vol_field,fixed_dofs,load):
"""Plot the given design (rho) on the provided figure axes
Args:
ax(object): figure object axes
mesh(object): finite element mesh object
rho(nelx x nely float matrix): density matrix
vol_field(nelx x nely float matrix): volume field
fixed_dofs(N x 1 int array): fixed degrees-of-freedom
load(ndof x 1 float array): load vector
"""
buffer = 2 # buffer around image to present graphical objects which extend outside the design domain
pix_offset = 0.5-buffer # pixel center offset
rho = np.pad(rho,buffer)
# get volume fraction and calculate difference
volfrac = np.sum(vol_field)/len(mesh.IX)
volume_violation = np.sum(rho)/len(mesh.IX) - volfrac
ax.set_title("Volfrac: "+str(round(volfrac,3))+" Vol. diff.: "+str(round(volume_violation,3)))
# plot design
ax.imshow(-rho,cmap='gray',interpolation='none',norm=colors.Normalize(vmin=-1,vmax=0))
# plot loads
load_nodes = np.unique(mesh.dof2nodeid(np.nonzero(load)[0]))
for node in load_nodes:
magx = load[2*node][0]
magy = -load[2*node+1][0] # reverse due to opposite y-coordinate for images and mesh
xn = mesh.XY[node,0]
yn = mesh.XY[node,1]
ax.arrow(xn-pix_offset,yn-pix_offset,magx,magy,width=0.5,color='r')
# plot boundary conditions
even_dofs = fixed_dofs%2==0
uneven_dofs = even_dofs!=True
horz_bound_nodes = mesh.dof2nodeid(fixed_dofs[even_dofs])
vert_bound_nodes = mesh.dof2nodeid(fixed_dofs[uneven_dofs])
ax.scatter(mesh.XY[horz_bound_nodes][:,0]-pix_offset,mesh.XY[horz_bound_nodes][:,1]-pix_offset,marker='>',color='b')
ax.scatter(mesh.XY[vert_bound_nodes][:,0]-pix_offset,mesh.XY[vert_bound_nodes][:,1]-pix_offset,marker='^',color='g')
ax.axis('off')
def plot_field(ax,field_data):
"""Plot 2-d field data with a fitted colorbar on the provided figure axes
Args:
ax(object): figure object axes
field_data(nelx x nely float matrix): element-wise field values
"""
im = ax.imshow(field_data, cmap='jet')
divider = make_axes_locatable(ax)
cax = divider.append_axes("right", size="2%", pad=0.5)
cbar = plt.colorbar(im,cax=cax)
cbar.ax.locator_params(nbins=8)
def train_plot(mesh,compliance,volume_violation,rho,psi,vol_field,fixed_dofs,load):
"""Plots convergence curve along with two random designs from the batch.
Mostly used for evaluation of training procedure in jupyter notebooks
Args:
mesh(object): finite element mesh object
compliance(Nx1 float array): torch array with compliance values for each train iteration
volume_violation(Nx1 float array): torch array with volume violation values for each train iteration
rho(B x 1 x nely x nelx float matrix): torch matrix with densities for each entry in the batch
fixed_dofs(B x N float matrix): numpy matrix with fixed_dofs for each entry in the batch
load(B x ndof x 1 float matrix): numpy matrix with loads for each entry in the batch
"""
# transform from tensors to numpy
rho = rho.squeeze(1).detach().cpu().numpy()
psi = psi.cpu().squeeze(1).numpy()
vol_field = vol_field.cpu().squeeze(1).numpy()
fixed_dofs = fixed_dofs.numpy()
load = load.numpy()
tmp_img = "tmp_design_out.png"
fig = plt.figure(constrained_layout=True,figsize=(12,6))
gs = fig.add_gridspec(2, 2)
ax0 = fig.add_subplot(gs[:, 0])
ax1 = fig.add_subplot(gs[0, 1])
ax2 = fig.add_subplot(gs[1, 1])
# plot convergence
ax0.set_xlabel('Iter')
ax0.set_ylabel('Compliance')
ax0.plot(np.arange(len(compliance)), compliance,color='b')
ax0.tick_params(axis='y', labelcolor='b')
ax0_twin = ax0.twinx()
ax0_twin.set_ylabel('Vol. violation')
ax0_twin.plot(np.arange(len(volume_violation)), volume_violation,color='r')
ax0_twin.tick_params(axis='y', labelcolor='r')
# plot designs
plot_design(ax1,mesh,rho[0],vol_field[0],remove_padding(fixed_dofs[0],-1),load[0])
plot_design(ax2,mesh,rho[1],vol_field[1],remove_padding(fixed_dofs[1],-1),load[1])
#ax2.imshow(psi[0],cmap="gray")
#ax2.axis("off")
plt.savefig(tmp_img)
plt.close(fig)
display(Image(filename=tmp_img))
clear_output(wait=True)
os.remove(tmp_img)
def tensorboard_plot(mesh,rho,vol_field,fixed_dofs,load):
"""Function used to create images saved by tensorboard"""
# transform inputs from tensors to numpy
rho = rho.squeeze(1).detach().cpu().numpy()
vol_field = vol_field.cpu().squeeze(1).numpy()
fixed_dofs = fixed_dofs.numpy()
load = load.numpy()
# setup plot
rows = 4
cols = 2
fig, axarr = plt.subplots(rows,cols,figsize=(12,12))
it=0
for i in range(rows):
for j in range(cols):
ax = axarr[i][j]
plot_design(ax,mesh,rho[it],vol_field[it],remove_padding(fixed_dofs[it],-1),load[it])
it+=1
fig.tight_layout()
buf = io.BytesIO()
plt.savefig(buf, format='png')
plt.close(fig)
buf.seek(0)
return buf
def plot_grad_flow(named_parameters):
"""Plots the gradient flow through each of the layers in the network"""
ave_grads = []
layers = []
for n, p in named_parameters:
if(p.requires_grad) and ("bias" not in n):
layers.append(n)
ave_grads.append(p.grad.abs().mean())
plt.plot(ave_grads, alpha=0.3, color="b")
plt.hlines(0, 0, len(ave_grads)+1, linewidth=1, color="k" )
plt.xticks(range(0,len(ave_grads), 1), layers, rotation="vertical")
plt.xlim(xmin=0, xmax=len(ave_grads))
plt.xlabel("Layers")
plt.ylabel("average gradient")
plt.title("Gradient flow")
plt.grid(True)
def remove_padding(X,pad_value):
"""Convience function used to remove padding from inputs which have been
padded during batch generation"""
return X[X!=pad_value]
def count_model_parameters(model):
"""Count trainable parameters of a given model
Args:
model(object): torch model object
Returns:
trainable_parameters(int): number of trainable parameters
"""
return sum(p.numel() for p in model.parameters() if p.requires_grad)
def normalize_data(x):
"""Normalize data to values between 0-1
Args:
x(NxN float matrix): data to be normalized
Returns:
x_norm((NxN float matrix): normalized data
"""
return (x-x.min())/(x.max()-x.min())
def standardize_data(x):
"""Standardize data by subtrating mean and dividing with standard deviation
Args:
x(NxN float matrix): data to be standardized
Returns:
x_norm((NxN float matrix): standardized data
"""
return (x-x.mean())/x.std()
class StreamlineGenerator():
"""Class used to generate streamlines
Args:
nelx(int): number of elements in x-direction of the mesh
nely(int): number of elements in y-direction of the mesh
U(nely x nelx float matrix): velocity-direction in x
V(nely x nelx float matrix): velocity-direction in y
vmag(nely x nelx float matrix): magnitude of velocity field
min_length(float): minimum length of streamlines
color(str): plotting color of streamlines
"""
def __init__(self,nelx,nely,U,V,vmag,min_length,color):
self.nelx = nelx
self.nely = nely
self.rscale = min(nelx,nely)/10
self.interpU = RectBivariateSpline(np.arange(nely), np.arange(nelx), U)
self.interpV = RectBivariateSpline(np.arange(nely), np.arange(nelx), V)
self.interpMag = RectBivariateSpline(np.arange(nely), np.arange(nelx), vmag)
self.min_length = min_length
self.color = color
def integrate_streamline(self,xpos,ypos,max_iter=100):
"""Euler integration of a streamline from starting point (xpos,ypos)"""
x_line = [xpos]
y_line = [ypos]
v_line = []
dt = self.rscale
it = 0
while (xpos>=0 and xpos<=self.nelx) and (ypos>=0 and ypos<=self.nely):
# calculate velocity-direction and magnitude in a given point
u = self.interpU(ypos,xpos)[0][0]
v = self.interpV(ypos,xpos)[0][0]
vmag = self.interpMag(ypos,xpos)[0][0]
# update positions
xpos+=dt*u
ypos+=dt*v
# save points
x_line.append(xpos)
y_line.append(ypos)
v_line.append(vmag)
# terminate if velocity is too small or maximum number of iterations is reached
it+=1
if it>=max_iter or vmag<1e-4:
break
return np.array(x_line), np.array(y_line), np.array(v_line)
def generate_streamlines(self,seed_points):
"""Generate streamlines based on a set of seed points"""
streamlines = []
# loop over all seed points
for idx,(x0,y0) in enumerate(seed_points):
x_strm,y_strm,v_strm = self.integrate_streamline(x0,y0)
dx = np.abs(x_strm[-1]-x_strm[0])
dy = np.abs(y_strm[-1]-y_strm[0])
line_length = np.sqrt(dx**2+dy**2)
# save to matplotlib line collection if streamline is longer than the
# specified minimum length threshold
if line_length>self.min_length:
lc = self.create_linecollection(x_strm,y_strm,v_strm)
streamlines.append(lc)
return streamlines
def create_linecollection(self,x,y,v):
"""Creates matplotlib linecollection based on the set of points in the streamline"""
points = np.array([x, y]).T.reshape(-1, 1, 2)
segments = np.concatenate([points[:-1], points[1:]], axis=1)
lw = v*20+2
lc = LineCollection(segments, linewidths=lw,color=self.color)
return lc
def stream2grayscale(strm1_lc,strm2_lc,nelx,nely,dpi):
"""Given two line collections of streamlines create a grayscale image
Args:
strm1_lc(matplotlib.LineCollection): streamlines corresponding to principal stress direction 1
strm2_lc(matplotlib.LineCollection): streamlines corresponding to principal stress direction 2
Returns:
img_gray(nely*dpi/10 x nelx*dpi/10): grayscale image
"""
# plot the two line collections
fig,ax = plt.subplots(1,1,figsize=(12,6),dpi=dpi)
plt.gca().set_axis_off()
plt.subplots_adjust(top = 1, bottom = 0, right = 1, left = 0,
hspace = 0, wspace = 0)
for lc in strm1_lc:
ax.add_collection(lc)
for lc in strm2_lc:
ax.add_collection(lc)
ax.set_xlim([0,nelx])
ax.set_ylim([0,nely])
ax.invert_yaxis()
plt.margins(0,0)
# save the image as a buffer
io_buf = io.BytesIO()
fig.savefig(io_buf, format='raw', dpi=dpi)
io_buf.seek(0)
# create numpy array from buffer
img_arr = np.reshape(np.frombuffer(io_buf.getvalue(), dtype=np.uint8),
newshape=(int(fig.bbox.bounds[3]), int(fig.bbox.bounds[2]), -1))
io_buf.close()
# save numpy array as grayscale image
img_gray = rgb2gray(img_arr)
plt.close()
return img_gray
def density_sort_threshold(rho,volfrac,Emin=1e-9):
"""Sort densities and threshold based on volume constraint"""
_,nely,nelx = rho.shape
rho_flat = rho.flatten()
vol_idx = int(np.floor(volfrac*nelx*nely))
ind = np.argsort(rho_flat)[::-1]
rho_flat[ind[:vol_idx]] = 1
rho_flat[ind[vol_idx:]] = 1e-9
rho_thres = rho_flat.reshape((nely,nelx))
return rho_thres
def remove_disconnects(rho):
"""Use connected components analysis to identify disconnected regions and remove them"""
# connected components analysis
label_img, nr_labels = measure.label(rho,background=0,return_num=True)
# only keep the two largest labels (background + largest component)
max_labels = np.argsort([np.sum(label_img==i) for i in range(nr_labels+1)])[-2:]
# mask on all labels not part of the largest components
small_label_mask = np.logical_and(label_img!=max_labels[0],label_img!=max_labels[1])
# set all small labels to background
label_img[small_label_mask] = 0
# convert to zero-one
label_img[label_img>0] = 1
return label_img
def postprocess_designs(rho,vol_field):
"""Post process a batch of designs by first using a threshold based
on density sorting, and then a connected component analysis"""
batch_size = rho.shape[0]
device = rho.device
# convert input tensors to cpu numpy arrays
rho = rho.cpu().numpy()
vol_field = vol_field.cpu().numpy()
for i in range(batch_size):
volfrac = vol_field[i,0,0,0]
rho[i] = density_sort_threshold(rho[i],volfrac)
rho[i] = remove_disconnects(rho[i])
# move rho to gpu
rho = torch.tensor(rho,dtype=torch.float32).to(device)
return rho
class DataGen:
"""Class for generating training and test data
Args:
mesh(object): finite element mesh object
volfrac_range(2x1 float array): array with lowest and highest volume fraction
load_range(2x2 float array): array indicating domain where a load may be applied
n_bc_samples(int): number of samples per boundary condition
"""
def __init__(self,mesh,volfrac_range,load_range,n_bc_samples):
self.mesh = mesh
self.volfrac_range = volfrac_range
self.load_x_range = load_range[0]
self.load_y_range = load_range[1]
self.n_bc_samples = n_bc_samples
def gen_volfracs(self,n_samples):
"""Generate a specified number of volume fractions within the allowed range"""
return np.random.uniform(self.volfrac_range[0],self.volfrac_range[1],n_samples)
def gen_rand_unit_vec(self,ndim):
"""Generate a unit vector with a given dimension"""
x = | np.random.standard_normal(ndim) | numpy.random.standard_normal |
# Recurrent Neural Network
# Part 1 - Data Preprocessing
# Importing the libraries
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
# Importing the training set
dataset_train = pd.read_csv('Google_Stock_Price_Train.csv')
training_set = dataset_train.iloc[:,1:2].values
# Feature Scaling
from sklearn.preprocessing import MinMaxScaler
sc = MinMaxScaler(feature_range = (0, 1))
training_set_scaled = sc.fit_transform(training_set)
# Creating a data structure with 60 timesteps and 1 output
X_train = []
y_train = []
for i in range(60, 1258):
X_train.append(training_set_scaled[i-60:i, 0])
y_train.append(training_set_scaled[i, 0])
X_train, y_train = np.array(X_train), | np.array(y_train) | numpy.array |
import argparse
import soccer3d
import json
from os.path import join
from tqdm import tqdm
import utils.camera as cam_utils
import utils.io as io
import utils.mesh as mesh_utils
import utils.misc as misc_utils
import utils.files as file_utils
import openmesh as om
import numpy as np
import cv2
parser = argparse.ArgumentParser(description='Calibrate a soccer video')
parser.add_argument('--path_to_data', default='/home/krematas/Mountpoints/grail/data/barcelona', help='path')
parser.add_argument('--decimate_to', type=int, default=500, help='Margin around the pose')
opt, _ = parser.parse_known_args()
with open(join(opt.path_to_data, 'players', 'metadata', 'position.json')) as f:
data = json.load(f)
db = soccer3d.YoutubeVideo(opt.path_to_data)
db.digest_metadata()
db.refine_poses(keypoint_thresh=7, score_thresh=0.4, neck_thresh=0.4)
file_utils.mkdir(join(db.path_to_dataset, 'scene3d'))
for sel_frame in tqdm(range(db.n_frames)):
img = db.get_frame(sel_frame)
basename = db.frame_basenames[sel_frame]
cam_data = db.calib[basename]
cam = cam_utils.Camera(basename, cam_data['A'], cam_data['R'], cam_data['T'], db.shape[0], db.shape[1])
player_list = data[basename]
frame_mesh_points = np.zeros((0, 3))
frame_mesh_faces = | np.zeros((0, 3)) | numpy.zeros |
import numpy as np
def calculate_frechet_distance(mu1, sigma1, mu2, sigma2, eps=1e-6):
import scipy as scpy
"""Numpy implementation of the Frechet Distance.
The Frechet distance between two multivariate Gaussians X_1 ~ N(mu_1, C_1)
and X_2 ~ N(mu_2, C_2) is
d^2 = ||mu_1 - mu_2||^2 + Tr(C_1 + C_2 - 2*sqrt(C_1*C_2)).
"""
mu1 = np.atleast_1d(mu1)
mu2 = np.atleast_1d(mu2)
sigma1 = np.atleast_2d(sigma1)
sigma2 = np.atleast_2d(sigma2)
assert mu1.shape == mu2.shape, \
'Training and test mean vectors have different lengths'
assert sigma1.shape == sigma2.shape, \
'Training and test covariances have different dimensions'
diff = mu1 - mu2
covmean, _ = scpy.linalg.sqrtm(sigma1.dot(sigma2), disp=False)
if not np.isfinite(covmean).all():
msg = ('fid calculation produces singular product; '
'adding %s to diagonal of cov estimates') % eps
print(msg)
offset = np.eye(sigma1.shape[0]) * eps
covmean = scpy.linalg.sqrtm((sigma1 + offset).dot(sigma2 + offset))
if np.iscomplexobj(covmean):
if not np.allclose(np.diagonal(covmean).imag, 0, atol=1e-3):
m = np.max(np.abs(covmean.imag))
raise ValueError('Imaginary component {}'.format(m))
covmean = covmean.real
tr_covmean = | np.trace(covmean) | numpy.trace |
import numpy as np
import scipy as scipy
import lxmls.classifiers.linear_classifier as lc
from lxmls.distributions.gaussian import *
class GaussianNaiveBayes(lc.LinearClassifier):
def __init__(self):
lc.LinearClassifier.__init__(self)
self.trained = False
self.means = 0
# self.variances = 0
self.prior = 0
def train(self, x, y):
nr_x, nr_f = x.shape
nr_c = np.unique(y).shape[0]
prior = np.zeros(nr_c)
likelihood = np.zeros((nr_f, nr_c))
classes = np.unique(y)
means = np.zeros((nr_c, nr_f))
variances = np.zeros((nr_c, nr_f))
for i in range(nr_c):
idx, _ = np.nonzero(y == classes[i])
prior[i] = 1.0 * len(idx) / len(y)
for f in range(nr_f):
g = estimate_gaussian(x[idx, f])
means[i, f] = g.mean
variances[i, f] = g.variance
# Take the mean of the covariance for each matric
variances = | np.mean(variances, 1) | numpy.mean |
import cv2
import matplotlib.pyplot as plt
import numpy as np
from sklearn.mixture import GaussianMixture
import math
from scipy.ndimage import affine_transform
from scipy.signal import argrelmin, argrelmax
import concurrent.futures as cf
import time
import argparse
import sys
sys.path.insert(0, '//homer.uit.no/bpe043/Desktop/Test_Projects/HelperFunctions')
from Database.dbHandler import DbHandler
from sheer_image import sheer_image
from color_convert import convert_img_gray
from color_convert import convert_img_bw
class GaussianNormalDistributionCluster:
"""
GaussianNormalDistributionCluster provides methods for extracting the density distribution of an image,
it's summed gaussian normal distributions and it's minimas for digit seperation.
In order to render the plots, matplotlib.pyplot.show() must be called after the rendering methods are called.
The load_image(path) method must be called before using any other method.
"""
# num_components = How many digits there are
def __init__(self, num_components):
"""
:param num_components: number of gaussian normal distributions
:param img: image to process
"""
self.image = None
self.components = num_components
self.shape = (100, 100)
self.gaussian_values = None
self.single = False
@staticmethod
def gaussian(x, mu, sig, weight):
"""
Creates a gaussian normal distribution
:param x: ndarray of points along the x-axis
:param mu: standard deviation
:param sig: covariance
:param weight: the weight for the normal distribution
:return: a ndarray containing the points for the normal distribution
"""
return (np.exp(-np.power(x - mu, 2.) / (2 * sig)) / (math.sqrt(2 * math.pi) * math.sqrt(sig))) * weight
def load_image(self, img, height, width):
"""
Loads an image in grayscale using opencv
:param img: image in byte values
:return: ndarray of pixel values, grayscale
:type:ndarray
"""
# Check if the image type is bytes (Normal use) or ... (Training set use)
if type(img) == np.ndarray:
self.image = img
return self.image
# Convert the bytes-data from the database into a numpy array
np_img = np.frombuffer(img, dtype = np.uint8)
# Decode the array back to an image
image = cv2.imdecode(np_img, cv2.IMREAD_ANYCOLOR)
self.image = image
affine = np.array([[1, 0, 0], [-0.3, 1, 0], [0, 0, 1]])
img = affine_transform(self.image, affine, cval=255)
img = cv2.GaussianBlur(img, (5, 5), 0)
self.image = img
if self.image is None:
print("Image is None")
raise ValueError("Unable to load image, check path")
return self.image
def get_x_density(self):
"""
Creates a 1d array containing the location of pixel values on the x-axis above a threshold,
load_image must be called first
:return: list of pixel locations
"""
if self.image is None:
raise ValueError
if len(self.image.shape) == 3:
cols = self.image.shape[1]
else:
rows, cols = self.image.shape
np.random.seed(0)
img_flat = self.image.flatten()
img_flat = [v / 255 for v in img_flat]
img_flat = np.array(img_flat)
x_density = []
for i in range(0, len(img_flat)):
if img_flat[i] < 0.2:
x_density.append(np.array([i % cols]))
return np.array(x_density)
def get_minimas(self, summed_gaussian=None):
"""
Returns local minimas of the gaussian function
:param summed_gaussian: sum of gaussian normal distributions. If None, the method will retrieve a summed
gaussian for the given number of components
:return: local minimas. None if the image contains no valid pixels, see method get_x_density().
"""
if summed_gaussian is None:
summed_gaussian = self.get_summed_gaussian()
if summed_gaussian is None:
return None
minims = argrelmin(summed_gaussian)
return minims
def get_maxims(self, summed_gaussian=None):
"""
Finds the maximum points for the summed gaussian function. Can handle single gaussian functions as well.
:param summed_gaussian: Function of which to find the local maximum
:return: array of local maximum values
"""
if summed_gaussian is None:
summed_gaussian = self.get_summed_gaussian()
if summed_gaussian is None:
return None
maxims = argrelmax(summed_gaussian)
return maxims
@staticmethod
def render_hist(x_density, num_bins=28):
"""
Render method for a histogram
:param x_density: list of x-axis pixel locations
:param num_bins: number of bins to separate the values in to
:return:
"""
plt.hist(x_density, histtype='bar', normed=True, bins=num_bins)
@staticmethod
def render_dist(gaussian):
"""
Render the given gaussian distribution
:param gaussian: list containing the gaussian distribution
:return:
"""
plt.plot(gaussian)
def get_summed_gaussian(self, x_density=None):
"""
Creates and summarizes the gaussian normal distributions
:param x_density: list of pixel locations on the x-axis
:param init_weight: initial weight for the distributions
:return: summed gaussian distribution. If None, no valid (normalized pixels < 0.1) pixels are in the image
"""
if x_density is None:
x_density = self.get_x_density()
if len(x_density) == 0:
return None
# 1/3 = 3 digits, 1/2 = 2 digits
init_weight = 1 / self.components
weights = np.full(self.components, init_weight)
gmm = GaussianMixture(n_components=self.components, weights_init=weights)
gmm.fit(x_density)
mu = gmm.means_.flatten()
sig = gmm.covariances_.flatten()
gausses = []
for i in range(0, len(mu)):
g = self.gaussian(np.arange(self.image.shape[1]), mu[i], sig[i], gmm.weights_[i])
gausses.append(g)
gausses = np.array(gausses)
self.gaussian_values = gausses
sum_g = gausses.sum(axis=0)
return sum_g
def resize_images(self, images):
completed = []
for image in images:
if image.shape[0] == 0:
print("The image shape on the x axis is {}".format(image.shape[0]))
if image.shape[1] == 0:
print("The image shape on the y axis is {}".format(image.shape[1]))
if image.shape[0] > self.shape[0]:
# Resize the image if an axis is too large to fit in the new image
if image.shape[1] > self.shape[1]:
# Both axis in the image is greater than the wanted shape, resize both axis
image = cv2.resize(image, self.shape, interpolation=cv2.INTER_CUBIC)
else:
# Only the X axis is greater, resize only this
image = cv2.resize(image, (image.shape[1], self.shape[0]), interpolation=cv2.INTER_CUBIC)
else:
if image.shape[1] > self.shape[1]:
# Only the Y axis is greater, resize only this
image = cv2.resize(image, (self.shape[1], image.shape[0]), interpolation=cv2.INTER_CUBIC)
reshaped = np.full(self.shape, 0, dtype='uint8')
p = np.array(image)
x_offset = int(abs(image.shape[0] - self.shape[0]) / 2)
y_offset = int(abs(image.shape[1] - self.shape[1]) / 2)
reshaped[x_offset:p.shape[0] + x_offset, y_offset:p.shape[1] + y_offset] = p
completed.append(reshaped)
return completed
def split_image(self, image, split_points, mid_points):
"""
Splits the image based on the location of the minimum points given by the summed gaussian function
:param image: Input image in grayscale
:param split_points: Local minimum points of the summed gaussian function
:param mid_points: Maximum points of the summed gaussian function
:return: an array of the split images
"""
def test_for_value(col):
for col_val in col:
if col_val > 200:
# We found a value in this column, so go to next
return True
return False
if self.components == 3:
new1 = np.array([row[:split_points[0]] for row in image])
new2 = np.array([row[split_points[0]:split_points[1]] for row in image])
new3 = np.array([row[split_points[1]:] for row in image])
center1 = mid_points[0]
center3 = mid_points[2] - split_points[1]
else:
new1 = np.array([row[:split_points[0]] for row in image])
new3 = np.array([row[split_points[0]:] for row in image])
center1 = mid_points[0]
center3 = mid_points[1]
""" The following code will be done for both 3-digit and 2-digit"""
# Left (First) image
try:
new1 = self.reshape_left_image(new1, test_for_value, center1)
except ValueError as e:
try:
intersections = self.find_intersections()
new1 = np.array([row[:intersections[0]] for row in image])
new1 = self.reshape_left_image(new1, test_for_value, mid_points[0])
except Exception as e:
print("Left image has wrong shape {}, exception: {}".format(new1.shape, e))
return None
# Right (Third) image
try:
new3 = self.reshape_right_image(new3, test_for_value, center3)
except ValueError as e:
try:
intersections = self.find_intersections()
new3 = np.array([row[intersections[1]:] for row in image])
new3 = self.reshape_right_image(new3, test_for_value, mid_points[2] - intersections[1])
except Exception as e:
print("Right image has wrong shape {}, exception: {}".format(new3.shape, e))
return None
all_i = [new1, new3]
""" The below code will only be done for 3-digit """
if self.components == 3:
# Middle (Second) image
try:
new2 = self.reshape_middle_image(new2)
except ValueError as e:
try:
intersections = self.find_intersections()
new2 = np.array([row[intersections[0]:intersections[1]] for row in image])
new2 = self.reshape_middle_image(new2)
except Exception as e:
print("Middle image has wrong shape {}, exception: {}".format(new2.shape, e))
return None
all_i.insert(1, new2)
if self.single is True:
return all_i
all_images_resized = self.resize_images(all_i)
return all_images_resized
@staticmethod
def reshape_right_image(new3, test_for_value, digit_center_point):
# Right image
# Calculate offset from the total image length
from_mid = np.swapaxes(new3[:, digit_center_point:], 1, 0)
for i in range(0, from_mid.shape[0] - 2, 2):
# Iterate from the top of the new image
# Check if the row contains values
if not test_for_value(from_mid[i]):
# Check the next row for values
if not test_for_value(from_mid[i + 1]) and not test_for_value(from_mid[i + 2]):
# We found a row without values, and the next does not either
# Copy over the values based on the new first column containing values
new3 = new3[:, :i + digit_center_point]
break
if new3.shape[0] == 0 or new3.shape[1] == 0:
raise ValueError
return new3
@staticmethod
def reshape_middle_image(new2):
# left = self.reshape_left_image(new2, test_for_value, digit_center_point)
# right = self.reshape_right_image(new2, test_for_value, digit_center_point)
# if left.shape[0] < right.shape[0]:
# new2 = left
# else:
# new2 = right
if new2.shape[0] == 0 or new2.shape[1] == 0:
raise ValueError
return new2
@staticmethod
def reshape_left_image(new1, test_for_value, digit_center_point):
# Left image
# Extract array from mid point of the digit and switch to column major order
from_mid = np.swapaxes(new1[:, digit_center_point:0:-1], 1, 0)
for i in range(0, from_mid.shape[0] - 2, 2):
# Iterate from the bottom of the new image
# Check if the row contains values
if not test_for_value(from_mid[i]):
# Check the next row for values
if not test_for_value(from_mid[i + 1]) and not test_for_value(from_mid[i + 2]):
# We found a row without values, and the next does not either
# Copy over the values based on the new first column containing values
new1 = new1[:, digit_center_point - i:]
break
if new1.shape[0] == 0 or new1.shape[1] == 0:
raise ValueError
return new1
def find_intersections(self):
"""
Finds the intersection between the gaussian functions. These are loaded from the class and assumes that the
gaussian functions have already been created. Fails with an exception by default if the functions are not
created
:return:
"""
gaus_and_mid = []
for val in self.gaussian_values:
gaus_and_mid.append((self.get_maxims(val)[0][0], val))
gaus_and_mid = sorted(gaus_and_mid, key=lambda q: q[0])
intersections = []
try:
for i in range(0, len(gaus_and_mid) - 1):
for k, val in enumerate(gaus_and_mid[i][1]):
if k == len(gaus_and_mid[i][1]) - 3:
break
a = val
b = gaus_and_mid[i + 1][1][k]
c = gaus_and_mid[i][1][k + 3]
d = gaus_and_mid[i + 1][1][k + 3]
if a > c:
tmp = c
c = a
a = tmp
if b > d:
tmp = d
d = b
b = tmp
if (a <= d and c >= b) and k > gaus_and_mid[i][0]:
intersections.append(k)
break
except Exception as e:
print(e)
return intersections
def execute(name, img, height, width, nr_digits, gray_img = None):
"""
Function to handle the launching of a parallel task
:param name: Name of the image
:param img: image
:return: list of images separated, name of the file, error message if not completed
"""
gnc = GaussianNormalDistributionCluster(nr_digits)
try:
image = gnc.load_image(img, height, width)
x_density = gnc.get_x_density()
sum_g = gnc.get_summed_gaussian(x_density)
mins = gnc.get_minimas(sum_g)
if mins is None:
return None, name, "No minimums found"
maxes = gnc.get_maxims(sum_g)
if maxes is None:
return None, name, "No maximums found"
except ValueError as e:
# Unsure of what exactly happens here, but the x_density vector is only a single dimension
# which causes the GMM to fail. This can happen if there is only a single row containing pixels, or none
# These images are however not relevant and can be skipped.
print("{} Skipping image at path: {} due to lacking values in x_density".format(e, name))
return None, name, " lacking values in x_density. Exception {}".format(e)
except Exception as e:
print(e)
return None, name, str(e)
try:
# =============================================================================
# cv2.imshow('before', image)
# cv2.waitKey(0)
# =============================================================================
# If we are not working with a grayscale image, operate as normal
if gray_img is None:
image = cv2.bitwise_not(image)
# If we are working with a grayscale image, the splitting points have been calculated using the black and white image
# Now we pass the grayscale image to the function that splits it based on the previous calculations
else:
image = gnc.load_image(gray_img, height, width)
# =============================================================================
# cv2.imshow('after', image)
# cv2.waitKey(0)
# cv2.destroyAllWindows()
# =============================================================================
new_images = gnc.split_image(image, mins[0], maxes[0])
if new_images is None:
return None, name, "No images returned"
return new_images, name, ""
except IndexError as e:
# Only one minima is found, this is the wrong result for the profession field. Should be two minimas
# So these images are just skipped.
print("{} Skipping image at path: {} due to single minima or maxima".format(e, name))
return None, name, "single minima or maxima. Exception {}".format(e)
except Exception as e:
print(e)
return None, name, str(e)
def handle_done(done, db):
"""
Function to handle the output of a parallel task
:param done: Handle to the result
:type: Future
:param db: database handler
:type: DbHandler
:return:
"""
new_images, name, err = done.result()
if new_images is None or err != "":
try:
db.store_dropped(name, err)
except Exception as e:
print(e)
else:
for i, im in enumerate(new_images):
name = str(i) + "_" + name
try:
db.store_digit(name, im)
except Exception as e:
print(e)
def run_parallel(db_loc, nr_digits, gray_loc = None):
"""
Launches the parallel executor and submits all the jobs. This function parses the entire folder structure and keeps
it in memory
:param db_loc: black and white image database location, full path
:param gray_loc: grayscale image database location, full path
:return:
"""
np.random.seed(0)
start_time = time.time()
futures = []
with cf.ProcessPoolExecutor(max_workers=6) as executor:
with DbHandler(db_loc) as db:
# read_and_submit is the function where we read in images from the database
# As such, we need to pass both databases
if gray_loc is not None:
with DbHandler(gray_loc) as gray_db:
read_and_submit(db, executor, futures, nr_digits, gray_db)
else:
read_and_submit(db, executor, futures, nr_digits)
print("--- " + str(time.time() - start_time) + " ---")
def process_futures(db, futures, num, num_read):
for done in cf.as_completed(futures):
num += 1
if num % 100 == 0:
print("Number of images segmented is: {}/{}".format(num, num_read))
db.connection.commit()
futures.remove(done)
handle_done(done, db)
return num
def read_and_submit(db, executor, futures, nr_digits, gray_db = None):
num = 0
skipped = 0
gray_skipped = 0
"""
# After this function, everything is about uploading split images to the database
# As such, there is no longer need to keep track of two databases.
# If we are working with a grayscale database, then that is the only one that should be uploaded to
# Hence we set the grayscale database as our 'active_db'
"""
# Variable for when we no longer need to consider two databases
active_db = None
if gray_db is not None:
active_db = gray_db
num_read = gray_db.count_rows_in_fields().fetchone()[0]
else:
active_db = db
num_read = db.count_rows_in_fields().fetchone()[0]
try:
rows = db.select_all_images()
while True:
db_img = rows.fetchone()
gray_img = None
if db_img is None or num == num_read:
print("Reached the end, number of skipped images: ", str(skipped))
break
if gray_db is not None:
# Getting the same image but in grayscale. The black and white image will be used to compute changes that need to be done to the grayscale image
gray_img = gray_db.select_image(db_img[0])
# If the black and white image does not exist in the grayscale database, continue to the next image
if gray_img is None:
gray_skipped += 1
print("Skipping image that does not exist in the grayscale database. Total: {}".format(gray_skipped))
continue
else:
gray_img = gray_img[1]
exists_digit = active_db.test_exists_digit(db_img[0])[0]
exists_dropped = active_db.test_exists_dropped(db_img[0])[0]
if exists_digit == 1 or exists_dropped == 1:
skipped += 1
continue
if len(futures) > 1000:
# Each time a limit is reached, process all the executed
num = process_futures(active_db, futures, num + skipped, num_read)
futures.append(executor.submit(execute, db_img[0], db_img[1], db_img[2], db_img[3], nr_digits, gray_img))
# Do the final batch
process_futures(active_db, futures, num, num_read)
except TypeError as e:
print(e)
except Exception as e:
print(e)
def split_and_convert(image):
orig = image
bw = convert_img_bw(image)
new_dims = sheer_image(bw)
bw = bw[:, new_dims[0]:new_dims[1]]
orig = orig[:, new_dims[0]:new_dims[1]]
new_bws = split_single(bw)
# Check if the splitting gave an error. e.g not enough split points (minimums)
if new_bws == 'error':
return None
# Using the splitting points from the B&W split images, we can split the original colour image as well
new_originals = []
new_originals.append(orig[:, :new_bws[0].shape[1]])
new_originals.append(orig[:, new_bws[0].shape[1]:(new_bws[0].shape[1] + new_bws[1].shape[1])])
new_originals.append(orig[:, new_bws[0].shape[1] + new_bws[1].shape[1]:])
i = 0
while i < len(new_bws):
new_bws[i] = cv2.resize(new_bws[i], (100, 100), interpolation = cv2.INTER_AREA)
new_originals[i] = cv2.resize(new_originals[i], (100, 100), interpolation = cv2.INTER_AREA)
i += 1
# Once we have a split original, we can convert those into greyscale
new_greys = []
for image in new_originals:
grey = convert_img_gray(image)
new_greys.append(grey[1])
return new_originals, new_bws, new_greys
def handle_main():
arg = argparse.ArgumentParser("Extract individual digits from image")
arg.add_argument("-t", "--test", action="store_true", default=False, help="Run the program in test_mode")
arg.add_argument("--db", type=str, help="full path to database location",
default="/mnt/remote/Yrke/ft1950_ml.db")
arg.add_argument("--gray", type=str, help="full path to grayscale database location",
default="")
arg.add_argument('-nr', '--digits', type=int, help='the number of sub-images you want the image split into, should be equalt to number of digits in the image',
default=3)
arg.add_argument("-tn","--test_name", type=str, help='Name of the test image', default=False)
args = arg.parse_args()
if args.test:
run_test(args.db, args.test_name, args.digits)
elif args.gray:
run_parallel(args.db, args.digits, args.gray)
else:
run_parallel(args.db, args.digits)
def run_test(db_loc, image_name, nr_digits):
"""
Test run against single images
:param path: path to the image
:return:
"""
db = DbHandler(db_loc)
db_image_entry = db.select_image(image_name)
gnc = GaussianNormalDistributionCluster(nr_digits)
img = gnc.load_image(db_image_entry[1], db_image_entry[2], db_image_entry[3])
x_density = gnc.get_x_density()
gnc.render_hist(x_density)
sum_g = gnc.get_summed_gaussian(x_density)
gnc.render_dist(sum_g)
mins = gnc.get_minimas(sum_g)
maxes = gnc.get_maxims(sum_g)
plt.scatter(np.append(mins[0], maxes[0]), | np.append(sum_g[mins[0]], sum_g[maxes[0]]) | numpy.append |
from .KTS import cpd_auto
from .knapsack import knapsack
import os
import numpy as np
import math
import cv2
from tqdm import tqdm
import matplotlib.pyplot as plt
import seaborn as sns
def get_change_points(video_feat, n_frames, fps,
decimation_factor=1, min_cp_interval=5):
kernel = np.matmul(video_feat, video_feat.T)
ncp_1cpps = n_frames / fps # number of cp at a rate of 1 cp per sec
max_num_cp = int(math.floor(ncp_1cpps / min_cp_interval))
change_points, _ = cpd_auto(kernel, max_num_cp, 1)
change_points *= decimation_factor
change_points = np.concatenate(([0], change_points, [n_frames]))
begin_points = change_points[:-1]
end_points = change_points[1:]
change_points = np.vstack((begin_points, end_points - 1)).T
n_frame_per_seg = end_points - begin_points
return change_points, n_frame_per_seg
def generate_summary(importance_scores, change_points, n_frames, picks, proportion=0.15,
save_as_video=False, video_path=None, summary_dir=None,
save_frames=False, save_keyframes=True):
"""
Generate keyshot-based video summary. i.e. a binary vector
Args:
importance_scores: predicted importance scores.
change_points: 2D matrix, each row contains a segment.
n_frames: original number of frames.
picks: positions of subsampled frames in the original video.
proportion: length of video summary (compared to original video length).
"""
assert(importance_scores.shape == picks.shape)
picks = picks.astype(int)
if picks[-1] != n_frames:
picks = np.concatenate([picks, [n_frames]])
# Compute the importance scores for the initial frame sequence (not the subsampled one)
frame_scores = | np.zeros(n_frames) | numpy.zeros |
import h5py
from explore_australia.stamp import Stamp, get_coverages
import pandas
from explore_australia.stamp import get_coverages_parallel
import cv2
import matplotlib.pyplot as plt
import os
import numpy as np
import torch
import torch.nn as nn
import torchvision.models as models
from torch.autograd import Variable
def get_unique(all_set):
unique_set = set()
for i_set in range(0, len(all_set)):
try :
mat = all_set[i_set].pop()
unique_set.add(mat)
except KeyError:
continue
return unique_set
def accumulate_commodity_labels(df):
"Accumulate commodity labels from a dataframe with a 'commodity' column"
commodities = set()
for comm in df.commodity:
for comm in comm.split(';'):
commodities.add(comm)
return commodities
def accumulate_commodity_X(df):
"Accumulate commodity labels from a dataframe with a 'commodity' column"
x = set()
for comm in df.x:
x.add(comm)
return x
def accumulate_commodity_Y(df):
"Accumulate commodity labels from a dataframe with a 'commodity' column"
y = set()
for comm in df.y:
y.add(comm)
return y
resnet152 = models.resnet152(pretrained=True)
modules=list(resnet152.children())[:-1]
resnet152=nn.Sequential(*modules)
for p in resnet152.parameters():
p.requires_grad = False
path_to_dataset = '/media/iman/A8AC6E12AC6DDAF8/iman_ubuntu_dataset_unearthed/train/'
all_folders = os.listdir(path_to_dataset)
commodits_all = []
X_all = []
Y_all = []
# {'Ti', 'Co', 'Zr', 'REE', 'PGE', 'Th', 'Mn', 'Sb', 'U', 'Ag', 'W', 'Mo', 'Bi', 'V', 'Sn', 'Zn', 'Pb', 'Au',
# 'Ni', 'Cu', 'Ta', 'Fe'}
# df["fruit"] = df["fruit"].map({"apple": 1, "orange": 2,...})
for k in range(3, 10):
heatmap_all = []
features_all = []
for i_folder in all_folders[250*k:250*(k+1)]:
print ('Reading folder:', i_folder)
commodits_org = pandas.read_csv(path_to_dataset+str(i_folder)+'/commodities.csv')
ds_all = pandas.DataFrame({'stamp_id':[], 'x':[], 'y':[], 'commodity':[]})
for i_app in range(0, len(commodits_org['commodity'])):
ds = pandas.DataFrame({'stamp_id':commodits_org['stamp_id'][i_app], 'x':commodits_org['x'][i_app],
'y':commodits_org['y'][i_app], 'commodity':str(commodits_org['commodity'][i_app])},
range(len(commodits_org['commodity'][i_app].split(';'))))
for i_row in range(0, len(commodits_org['commodity'][i_app].split(';'))):
ds['commodity'][i_row] = ds['commodity'][i_row].split(';')[i_row]
ds_all = ds_all.append(ds)
commodits = ds_all
commodits['commodity'] = commodits['commodity'].map({'Ti': 0, 'Co': 1, 'Zr': 2, 'REE': 3, 'PGE': 4, 'Th': 5,
'Mn': 6, 'Sb': 7, 'U': 8, 'Ag': 9, 'W': 10, 'Mo': 11,
'Bi': 12, 'V': 13, 'Sn': 14, 'Zn': 15, 'Pb': 16, 'Au': 17,
'Ni': 18, 'Cu': 19, 'Ta': 20, 'Fe': 21})
material_all_org = accumulate_commodity_labels(commodits_org)
material_all = []
material_all_update = []
cord_x_all = []
cord_y_all = []
for i_com in range(0, len(commodits)):
material_all.append(commodits['commodity'].tolist()[i_com])
cord_x_all.append((commodits['x'].tolist()[i_com] + 12500)/100.)
cord_y_all.append((commodits['y'].tolist()[i_com] + 12500)/100.)
gravity_1 = cv2.imread(path_to_dataset+str(i_folder)+'/geophysics/gravity/bouger_gravity_anomaly.tif', -1)
gravity_1_resized = cv2.resize(gravity_1, (224, 224))
gravity_1_resized_img = np.repeat(gravity_1_resized.reshape(1, 224, 224), 3, axis=0).reshape(1, 3, 224, 224)
gravity_2 = cv2.imread(path_to_dataset+str(i_folder)+
'/geophysics/gravity/isostatic_residual_gravity_anomaly.tif', -1)
gravity_2_resized = cv2.resize(gravity_2, (224, 224))
gravity_2_resized_img = np.repeat(gravity_2_resized.reshape(1, 224, 224), 3, axis=0).reshape(1, 3, 224, 224)
magnetics_1 = cv2.imread(path_to_dataset+str(i_folder)+
'/geophysics/magnetics/total_magnetic_intensity.tif', -1)
magnetics_1_resized = cv2.resize(magnetics_1, (224, 224))
magnetics_1_resized_img = np.repeat(magnetics_1_resized.reshape(1, 224, 224), 3, axis=0).reshape(1, 3, 224, 224)
magnetics_2 = cv2.imread(path_to_dataset+str(i_folder)+
'/geophysics/magnetics/variable_reduction_to_pole.tif', -1)
magnetics_2_resized = cv2.resize(magnetics_2, (224, 224))
magnetics_2_resized_img = np.repeat(magnetics_2_resized.reshape(1, 224, 224), 3, axis=0).reshape(1, 3, 224, 224)
radiometrics_1 = cv2.imread(path_to_dataset+str(i_folder)+
'/geophysics/radiometrics/filtered_potassium_pct.tif', -1)
radiometrics_1_resized = cv2.resize(radiometrics_1, (224, 224))
radiometrics_1_resized_img = np.repeat(radiometrics_1_resized.reshape(1, 224, 224), 3, axis=0).reshape(1, 3, 224, 224)
radiometrics_2 = cv2.imread(path_to_dataset+str(i_folder)+
'/geophysics/radiometrics/filtered_terrestrial_dose.tif', -1)
radiometrics_2_resized = cv2.resize(radiometrics_2, (224, 224))
radiometrics_2_resized_img = np.repeat(radiometrics_2_resized.reshape(1, 224, 224), 3, axis=0).reshape(1, 3, 224, 224)
radiometrics_3 = cv2.imread(path_to_dataset+str(i_folder)+
'/geophysics/radiometrics/filtered_thorium_ppm.tif', -1)
radiometrics_3_resized = cv2.resize(radiometrics_3, (224, 224))
radiometrics_3_resized_img = np.repeat(radiometrics_3_resized.reshape(1, 224, 224), 3, axis=0).reshape(1, 3, 224, 224)
radiometrics_4 = cv2.imread(path_to_dataset+str(i_folder)+
'/geophysics/radiometrics/filtered_uranium_ppm.tif', -1)
radiometrics_4_resized = cv2.resize(radiometrics_4, (224, 224))
radiometrics_4_resized_img = np.repeat(radiometrics_4_resized.reshape(1, 224, 224), 3, axis=0).reshape(1, 3, 224, 224)
img_batch = np.concatenate((gravity_1_resized_img, gravity_2_resized_img, magnetics_1_resized_img,
magnetics_2_resized_img, radiometrics_1_resized_img, radiometrics_2_resized_img,
radiometrics_3_resized_img, radiometrics_4_resized_img), axis =0)
img_batch_torch = torch.from_numpy(img_batch)
img_var = Variable(img_batch_torch)
features_var = resnet152(img_var)
commodits_all.append(material_all)
X_all.append(cord_x_all)
Y_all.append(cord_y_all)
heatmap = np.zeros((256, 256, 22))
kernel = np.ones((5, 5), np.float32) / 25
for i_heat in range(0, len(cord_x_all)):
img = | np.zeros((256, 256)) | numpy.zeros |
# -*- coding: utf-8 -*-
import numpy
from collections import OrderedDict
from fuel.datasets import IndexableDataset
class Spiral(IndexableDataset):
u"""Toy dataset containing points sampled from spirals on a 2d plane.
The dataset contains 3 sources:
* features -- the (x, y) position of the datapoints
* position -- the relative position on the spiral arm
* label -- the class labels (spiral arm)
.. plot::
from fuel.datasets.toy import Spiral
ds = Spiral(classes=3)
features, position, label = ds.get_data(None, slice(0, 500))
plt.title("Datapoints drawn from Spiral(classes=3)")
for l, m in enumerate(['o', '^', 'v']):
mask = label == l
plt.scatter(features[mask,0], features[mask,1],
c=position[mask], marker=m, label="label==%d"%l)
plt.xlim(-1.2, 1.2)
plt.ylim(-1.2, 1.2)
plt.legend()
plt.colorbar()
plt.xlabel("features[:,0]")
plt.ylabel("features[:,1]")
plt.show()
Parameters
----------
num_examples : int
Number of datapoints to create.
classes : int
Number of spiral arms.
cycles : float
Number of turns the arms take.
noise : float
Add normal distributed noise with standard deviation *noise*.
"""
def __init__(self, num_examples=1000, classes=1, cycles=1., noise=0.0,
**kwargs):
# Create dataset
pos = numpy.random.uniform(size=num_examples, low=0, high=cycles)
label = numpy.random.randint(size=num_examples, low=0, high=classes)
radius = (2*pos+1) / 3.
phase_offset = label * (2*numpy.pi) / classes
features = numpy.zeros(shape=(num_examples, 2), dtype='float32')
features[:, 0] = radius * numpy.sin(2*numpy.pi*pos + phase_offset)
features[:, 1] = radius * numpy.cos(2*numpy.pi*pos + phase_offset)
features += noise * | numpy.random.normal(size=(num_examples, 2)) | numpy.random.normal |
import collections
import gzip
import os
import scipy.io as sio
import numpy as np
def load_omniglot(file_path):
omni_raw = sio.loadmat(file_path)
def reshape_data(data):
return data.reshape((-1, 28, 28)).reshape((-1, 28 * 28), order='fortran')
train_data = reshape_data(omni_raw['data'].T.astype('float32'))
test_data = reshape_data(omni_raw['testdata'].T.astype('float32'))
return train_data, test_data
def load_mnist_raw(file_path, no_shuffle=False):
if no_shuffle:
return np.loadtxt(file_path)
return shuffle_data(np.loadtxt(file_path))
def shuffle_data(data):
num_data = np.shape(data)[0]
rand_index = np.random.permutation( | np.arange(0, num_data) | numpy.arange |
import numpy as np
import matplotlib.pyplot as plt
import sys, os
sys.path.append('../../galference/utils/')
import tools
import diagnostics as dg
def callback(model, ic, bs, losses=None):
fig, ax = plt.subplots(1, 6, figsize=(15, 3))
im = ax[0].imshow(ic[0].sum(axis=0))
plt.colorbar(im, ax=ax[0])
ax[0].set_title('Truth')
#
sample = model.sample_linear
im = ax[1].imshow((sample).numpy()[0].sum(axis=0))
plt.colorbar(im, ax=ax[1])
ax[1].set_title('Sample')
#
diff = sample - ic
im = ax[2].imshow(diff.numpy()[0].sum(axis=0))
plt.colorbar(im, ax=ax[2])
ax[2].set_title('Differnce')
#2pt functions
k, p0 = tools.power(ic[0]+1, boxsize=bs)
ps, rc, ratios = [], [], []
for i in range(20):
sample = model.sample_linear
i0 = (sample).numpy()[0]
k, p1 = tools.power(i0+1, boxsize=bs)
k, p1x = tools.power(i0+1, ic[0]+1, boxsize=bs)
ps.append([p1, p1x])
rc.append(p1x/(p1*p0)**0.5)
ratios.append((p1/p0)**0.5)
rc = np.array(rc)
ratios = np.array(ratios)
ax = ax[3:]
ax[0].plot(k, rc.T, 'C1', alpha=0.2)
ax[0].plot(k, rc.mean(axis=0))
ax[0].semilogx()
ax[0].set_ylim(0., 1.05)
ax[0].set_title('$r_c$', fontsize=12)
ax[1].plot(k, ratios.T, 'C1', alpha=0.2)
ax[1].plot(k, ratios.mean(axis=0))
ax[1].semilogx()
ax[1].set_ylim(0.8, 1.2)
ax[1].set_title('$t_f$', fontsize=12)
# if losses is not None: ax[2].plot(losses)
if losses is not None:
losses = -1. * np.array(losses)
ax[2].plot(losses[:, 0], label='-logl')
ax[2].plot(losses[:, 1], label='-logp')
ax[2].plot(losses[:, 2], label='-logq')
ax[2].plot(losses[:, 3], 'k', label='-elbo')
ax[2].loglog()
ax[2].set_title('-ELBO', fontsize=12)
ax[2].legend()
for axis in ax: axis.grid(which='both')
plt.tight_layout()
return fig
def callback_fvi(model, ic, bs, losses=None, zoomin=True):
fig, ax = plt.subplots(1, 6, figsize=(15, 3))
im = ax[0].imshow(ic[0].sum(axis=0))
plt.colorbar(im, ax=ax[0])
ax[0].set_title('Truth')
#
sample = model.sample_linear
im = ax[1].imshow((sample).numpy()[0].sum(axis=0))
plt.colorbar(im, ax=ax[1])
ax[1].set_title('Sample')
#
diff = sample - ic
im = ax[2].imshow(diff.numpy()[0].sum(axis=0))
plt.colorbar(im, ax=ax[2])
ax[2].set_title('Differnce')
#2pt functions
k, p0 = tools.power(ic[0]+1, boxsize=bs)
ps, rc, ratios = [], [], []
for i in range(20):
sample = model.sample_linear
i0 = (sample).numpy()[0]
k, p1 = tools.power(i0+1, boxsize=bs)
k, p1x = tools.power(i0+1, ic[0]+1, boxsize=bs)
ps.append([p1, p1x])
rc.append(p1x/(p1*p0)**0.5)
ratios.append((p1/p0)**0.5)
rc = np.array(rc)
ratios = np.array(ratios)
ax = ax[3:]
ax[0].plot(k, rc.T, 'C1', alpha=0.2)
ax[0].plot(k, rc.mean(axis=0))
ax[0].semilogx()
ax[0].set_ylim(0., 1.05)
ax[0].set_title('$r_c$', fontsize=12)
ax[1].plot(k, ratios.T, 'C1', alpha=0.2)
ax[1].plot(k, ratios.mean(axis=0))
ax[1].semilogx()
if zoomin: ax[1].set_ylim(0.8, 1.2)
else: ax[1].set_ylim(0.0, 1.5)
ax[1].set_title('$t_f$', fontsize=12)
ax[2].plot(losses)
ax[2].loglog()
ax[2].set_title('-logq', fontsize=12)
ax[2].legend()
for axis in ax: axis.grid(which='both')
plt.tight_layout()
return fig
def callback_sampling(samples, ic, bs):
fig, axar = plt.subplots(2, 3, figsize=(12, 8))
ax = axar[0]
im = ax[0].imshow(ic[0].sum(axis=0))
plt.colorbar(im, ax=ax[0])
ax[0].set_title('Truth')
#
sample = samples[np.random.randint(len(samples))].numpy()
im = ax[1].imshow((sample)[0].sum(axis=0))
plt.colorbar(im, ax=ax[1])
ax[1].set_title('Sample')
#
diff = sample - ic
print(diff.shape)
im = ax[2].imshow(diff[0].sum(axis=0))
plt.colorbar(im, ax=ax[2])
ax[2].set_title('Differnce')
#2pt functions
k, p0 = tools.power(ic[0]+1, boxsize=bs)
ps, rc, ratios = [], [], []
for i in range(len(samples)):
sample = samples[i].numpy()
if len(sample.shape) == 4:
for j in range(sample.shape[0]):
i0 = (sample)[j]
k, p1 = tools.power(i0+1, boxsize=bs)
k, p1x = tools.power(i0+1, ic[0]+1, boxsize=bs)
ps.append([p1, p1x])
rc.append(p1x/(p1*p0)**0.5)
ratios.append((p1/p0)**0.5)
elif len(sample.shape) == 3:
i0 = sample.copy()
k, p1 = tools.power(i0+1, boxsize=bs)
k, p1x = tools.power(i0+1, ic[0]+1, boxsize=bs)
ps.append([p1, p1x])
rc.append(p1x/(p1*p0)**0.5)
ratios.append((p1/p0)**0.5)
rc = np.array(rc)
ratios = | np.array(ratios) | numpy.array |
# -*- coding: utf-8 -*-
"""
Created on Fri Apr 26 12:26:13 2019
@author: Marcezar
"""
import numpy as np
import numpy.linalg as npl
def A_norm(x,A):
return np.sqrt(np.vdot(x,A@x))
def cg(A,b,x0=None,tol=1e-5,maxiter=None,M1=None,M3=None,x_exact=None):
n = A.shape[0]
if x0 is None:
x = np.zeros(n)
else:
x = x0
if maxiter is None:
maxiter = 3*n
r = b-A@x
res_arr = np.zeros(maxiter)
res_arr[0] = npl.norm(r)
if x_exact is not None:
err_arr = np.zeros(maxiter)
err_arr[0] = A_norm(x-x_exact,A)
i = 0
# unpreconditioned CG-method
if M1 is None and M3 is None:
p = r
while res_arr[i] > tol*res_arr[0] and i < maxiter-1:
i = i+1
w = A@p
aph = np.vdot(r,r)/ | np.vdot(p,w) | numpy.vdot |
import numpy as np
import matplotlib.pyplot as plt
from python_codes.transformations import *
class MK2Robot(object):
HOME_0 = 0
HOME_1 = np.pi
def __init__(self, link_lengths):
self.a = link_lengths
self.q = []
self.T = []
self.pose = []
self.s = []
# self.update_pose(MK2Robot.HOME_0, MK2Robot.HOME_1)
def update_pose(self, q0, q1):
"""
Este metodo calcula la pose de cada link del robot, usando las matrices T y R. Luego guarda el
resultado para cada link como un elemento del arreglo self.pose
"""
# Calcula las matrices T y Q
self._update_transformation_matrices(q0, q1)
# re-escribe self.pose como una lista de 4 matrices nulas
self.pose = np.zeros((2, 2))
l0_pose = np.linalg.multi_dot([self.R[0], self.T[0]])
l1_pose = np.linalg.multi_dot([self.R[0], self.T[0], self.R[1], self.T[1]])
self.pose[:, 0] = l0_pose[:, 2][:2]
self.pose[:, 1] = l1_pose[:, 2][:2]
def _update_transformation_matrices(self, q0, q1):
"""
Este método calcula las matrices de rotación traslación del modelo de nuestro robot
y guarda sus valores como elementos de las listas self.R y self.T, en orden
"""
q0 = q0 * np.pi / 180
q1 = q1 * np.pi / 180
self.q = [q0, q1]
self.T = []
self.R = []
angulo_rotacion_l0 = q0
angulo_rotacion_l1 = q1
# Link 1
self.T.append(translation_along_x_axis(self.a[0]))
self.R.append(rotation_around_zaxis(angulo_rotacion_l0))
# Link 2
self.T.append(translation_along_x_axis(self.a[1]))
self.R.append(rotation_around_zaxis(angulo_rotacion_l1))
def inverse_kinematics(self, x, y):
## pa q el robot vaya a x,y,x hay q usar
# q0,q1,q2=inversekinematics
##robot.updatepose(q0,q1,q2)
a1 = self.a[0]
a2 = self.a[1]
lim = a1 + a2
r = np.sqrt(x**2 + y**2)
if (r > lim):
return self.q
phi0 = np.arctan2(y, x)
phi1 = np.arccos((r**2+a1**2-a2**2) / (2*r*a1))
phi2 = np.arccos((a1**2 + a2**2 - r**2) / (2*a1*a2))
q0 = phi0 -phi1
q1 = np.pi - phi2
return np.array([q0, q1]) * 180 / np.pi
def get_joint_positions(self):
"""Este método entrega las coordenadas de cada joint en 1 listas; es para que el codigo se vea mas limpio :)"""
X_pos = self.pose[0]
Y_pos = self.pose[1]
return [X_pos, Y_pos]
def get_pose_error(self, inputed_coord):
x, y = inputed_coord
xr, yr = self.pose[:, 1]
error_x = np.abs(x-xr)/x
error_y = np.abs(y - yr) / y
return [error_x, error_y]
def angle_to_step(self, qarr):
"qarr must be in degres"
q0, q1 = qarr
s1 = q0 * 200
s2 = q1 * 400
self.s = [s1, s2]
return self.s
def write_coords_as_gcode(self, file, coords):
"""Takes an array of tuples with coordinates (in degrees) and writes
them as Gcode to a file"""
arch = open(file, 'w')
for i in range(len(coords)):
x = str( | np.round(coords[i][0], 1) | numpy.round |
import numpy as np
import math as m
from ._free_utils import get_mu_and_ci
import random
class PyEVI_FSUCRLv1(object):
def __init__(self,
nb_states,
nb_options,
macro_actions_per_state,
mdp_actions_per_state,
threshold,
option_policies,
reachable_states_per_option,
options_terminating_conditions,
bound_type="chernoff",
random_state = None):
self.nb_states = nb_states
self.nb_options = nb_options
self.threshold = threshold
self.actions_per_state = macro_actions_per_state
self.mdp_actions_per_state = mdp_actions_per_state
self.u1 = np.zeros(nb_states)
self.u2 = np.zeros(nb_states)
self.option_policies = option_policies
self.reachable_states_per_option = reachable_states_per_option
self.options_terminating_conditions = options_terminating_conditions
if bound_type == "chernoff":
self.bound_type = 0
elif bound_type == "chernoff_statedim":
self.bound_type = 1
elif bound_type == "bernstein":
self.bound_type = 2
else:
raise ValueError("Unknown bound type")
def compute_mu_info(self,
estimated_probabilities_mdp,
estimated_rewards_mdp,
beta_r,
nb_observations_mdp,
alpha_mu,
total_time,
delta,
max_nb_actions,
r_max):
nb_states = self.nb_states
nb_options = self.nb_options
r_tilde_opt = [None] * nb_options
mu_opt = [None] * nb_options
condition_numbers_opt = np.empty((nb_options,))
beta_mu_p = np.zeros((nb_options,))
for o in range(nb_options):
option_policy = self.option_policies[o]
option_reach_states = self.reachable_states_per_option[o]
term_cond = self.options_terminating_conditions[o]
opt_nb_states = len(option_reach_states)
Q_o = np.zeros((opt_nb_states, opt_nb_states))
# compute the reward and the mu
r_o = [0] * len(option_reach_states)
visits = np.inf
bernstein_log = m.log(6* max_nb_actions / delta)
for i, s in enumerate(option_reach_states):
option_action = option_policy[s]
option_action_index = self.mdp_actions_per_state[s].index(option_action)
r_o[i] = min(r_max, estimated_rewards_mdp[s, option_action_index] + beta_r[s,option_action_index])
if visits > nb_observations_mdp[s, option_action_index]:
visits = nb_observations_mdp[s, option_action_index]
bernstein_bound = 0.
nb_o = max(1, nb_observations_mdp[s, option_action_index])
for j, sprime in enumerate(option_reach_states):
prob = estimated_probabilities_mdp[s][option_action_index][sprime]
#q_o[i,0] += term_cond[sprime] * prob
Q_o[i,j] = (1. - term_cond[sprime]) * prob
bernstein_bound += np.sqrt(bernstein_log * 2 * prob * (1 - prob) / nb_o) + bernstein_log * 7 / (3 * nb_o)
if beta_mu_p[o] < bernstein_bound:
beta_mu_p[o] = bernstein_bound
e_m = np.ones((opt_nb_states,1))
q_o = e_m - np.dot(Q_o, e_m)
r_tilde_opt[o] = r_o
if self.bound_type == 0:
beta_mu_p[o] = alpha_mu * np.sqrt(14 * opt_nb_states * m.log(2 * max_nb_actions
* (total_time + 1) / delta) / max(1, visits))
elif self.bound_type == 1:
beta_mu_p[o] = alpha_mu * np.sqrt(14 * nb_states * m.log(2 * max_nb_actions
* (total_time + 1) / delta) / max(1, visits))
Pprime_o = np.concatenate((q_o, Q_o[:, 1:]), axis=1)
if not np.allclose(np.sum(Pprime_o, axis=1), np.ones(opt_nb_states)):
print("{}\n{}".format(Pprime_o,Q_o))
Pap = (Pprime_o + np.eye(opt_nb_states)) / 2.
D, U = np.linalg.eig(
np.transpose(Pap)) # eigen decomposition of transpose of P
sorted_indices = np.argsort(np.real(D))
mu = np.transpose(np.real(U))[sorted_indices[-1]]
mu /= np.sum(mu) # stationary distribution
mu_opt[o] = mu
assert len(mu_opt[o]) == len(r_tilde_opt[o])
P_star = np.repeat(np.array(mu, ndmin=2), opt_nb_states,
axis=0) # limiting matrix
# Compute deviation matrix
I = np.eye(opt_nb_states) # identity matrix
Z = np.linalg.inv(I - Pprime_o + P_star) # fundamental matrix
H = np.dot(Z, I - P_star) # deviation matrix
condition_nb = 0 # condition number of deviation matrix
for i in range(0, opt_nb_states): # Seneta's condition number
for j in range(i + 1, opt_nb_states):
condition_nb = max(condition_nb,
0.5 * np.linalg.norm(H[i, :] - H[j, :],
ord=1))
condition_numbers_opt[o] = condition_nb
# print("-"*80)
# print(Pap)
# print(mu)
# print(P_star)
# print(H)
# mu_n, cn_n = get_mu_and_ci(Pap)
# assert np.allclose(mu, mu_n), "{} != {}".format(mu, mu_n)
# assert np.isclose(condition_nb, cn_n)
self.r_tilde_opt = r_tilde_opt
self.condition_numbers_opt = condition_numbers_opt
self.beta_mu_p = beta_mu_p
self.mu_opt = mu_opt
return 0
def run(self, policy_indices, policy,
p_hat,
r_hat_mdp,
beta_p,
beta_r_mdp,
r_max,
epsilon):
nb_states = p_hat.shape[0]
cv = self.u1[0]
self.u1 = self.u1 - cv
sorted_indices_u = np.argsort(self.u1, kind='mergesort')
#self.u1.fill(0.0)
# sorted_indices_u = np.arange(nb_states)
self.counter = 0
while True:
self.counter += 1
for s in range(nb_states):
first_action = True
actions_argmax = []
actions_indices_argmax = []
for action_idx, action in enumerate(self.actions_per_state[s]):
if self.bound_type != 2:
# chernoff bound
gg = self.max_proba(p_hat[s][action_idx], nb_states,
sorted_indices_u, beta_p[s][action_idx][0])
assert len(beta_p[s][action_idx]) == 1
else:
# bernstein bound
gg = self.max_proba_bernstein(p_hat[s][action_idx], nb_states,
sorted_indices_u, beta_p[s][action_idx])
gg[s] = gg[s] - 1.
if action <= self.threshold:
#this is an action
r_optimal = min(r_max, r_hat_mdp[s, action] + beta_r_mdp[s, action])
v = r_optimal + np.dot(gg, self.u1)
else:
o = action - self.threshold - 1 # zero based index
x = np.zeros(len(self.reachable_states_per_option[o]))
for kk, kk_v in enumerate(self.reachable_states_per_option[o]):
x[kk] = self.r_tilde_opt[o][kk]
if s == kk_v:
x[kk] += | np.dot(gg, self.u1) | numpy.dot |
"""
@Project : Imylu
@Module : decision_regression.py
@Author : Deco [<EMAIL>]
@Created : 8/22/18 4:29 PM
@Desc :
"""
import copy
# from collections import Iterable
from typing import List, TypeVar, Tuple, Union, Iterable
import numpy as np
from work5.load_bike_data import load_bike_sharing_data
from work5.logger_setup import define_logger
from work5.utils import (load_boston_house_prices, train_test_split,
get_r2, run_time)
logger = define_logger('work5.regression_tree')
Num = TypeVar('Num', int, float)
num_if = Union[int, float]
class Node:
def __init__(self, score: Num = None):
"""Node class to build tree leaves.
Parameters:
score -- int or float, prediction of y for a rule chain (default: {None})
"""
self.score = score
self.feature = None
self.split = None
self.left = None
self.right = None
class RegressionTree:
def __init__(self):
"""RegressionTree class.
Decision tree is for discrete variables
Regression tree is for continuous variables
Attributes:
root: the root node of RegressionTree
height: the height of RegressionTree
feature_types: the feature types of X
"""
self.root = Node()
self.height = 0
self.feature_types = None
def _get_split_mse(self, X: List[List[num_if]],
y: Iterable[Num],
idx: Iterable[int],
feature: int, split: Num) -> Tuple[float, Num, List[float]]:
"""Calculate the mse of each set when x is splitted into two pieces.
MSE as Loss fuction:
y_hat = Sum(y_i) / n, i <- [1, n], the average value in the interval
Loss(y_hat, y) = Sum((y_hat - y_i) ^ 2), i <- [1, n]
Loss = LossLeftNode+ LossRightNode
--------------------------------------------------------------------
Parameters:
X {list} -- 2d list object with int or float
y {iterable} -- 1d list object with int or float
idx {iterable} -- indexes, 1d list object with int
feature {int} -- Feature number, that is, column number of the dataframe
split -- int or float, Split point of x
Returns:
tuple -- MSE, split point and average of splitted x in each intervel
"""
# X: Iterable[Iterable[num_if]]
# X = [list(item) for item in X]
# 当矩阵很大时，上面这一步非常影响效率，从6s到26s
y = list(y)
idx = list(idx)
split_sum = [0, 0]
split_cnt = [0, 0]
split_sqr_sum = [0, 0]
# Iterate each row and compare with the split point
for i in idx:
# idx are the selected rows of the dataframe
xi, yi = X[i][feature], y[i]
if xi < split:
split_cnt[0] += 1
split_sum[0] += yi
split_sqr_sum[0] += yi ** 2
else:
split_cnt[1] += 1
split_sum[1] += yi
split_sqr_sum[1] += yi ** 2
# Calculate the mse of y, D(X) = E{[X-E(X)]^2} = E(X^2)-[E(X)]^2
# Estimated by the mean of y, and then subtract the value of y
# num*E{[X-E(X)]^2} = num*E(X^2)-num*[E(X)]^2
split_avg = [split_sum[0] / split_cnt[0], split_sum[1] / split_cnt[1]]
split_mse = [split_sqr_sum[0] - split_sum[0] * split_avg[0],
split_sqr_sum[1] - split_sum[1] * split_avg[1]]
return sum(split_mse), split, split_avg
def _get_category_mse(self, X: List[List[num_if]], y: List[Num], idx: List[int],
feature: int, category: str) -> Tuple[float, str, List[float]]:
"""Calculate the mse of each set when x is splitted into two parts.
MSE as Loss fuction.
--------------------------------------------------------------------
Arguments:
X {list} -- 2d list object with int or float
y {list} -- 1d list object with int or float
idx {list} -- indexes, 1d list object with int
feature {int} -- Feature number, that is, column number of the dataframe
category {str} -- Category point of x
Returns:
tuple -- MSE, category point and average of splitted x in each intervel
"""
split_sum = [0, 0]
split_cnt = [0, 0]
split_sqr_sum = [0, 0]
# Iterate each row and compare with the split point
for i in idx:
# idx are the selected rows of the dataframe
xi, yi = X[i][feature], y[i]
if xi == category:
split_cnt[0] += 1
split_sum[0] += yi
split_sqr_sum[0] += yi ** 2
else:
split_cnt[1] += 1
split_sum[1] += yi
split_sqr_sum[1] += yi ** 2
# Calculate the mse of y, D(X) = E{[X-E(X)]^2} = E(X^2)-[E(X)]^2
# Estimated by the mean of y, and then subtract the value of y
# num*E{[X-E(X)]^2} = num*E(X^2)-num*[E(X)]^2
split_avg = [split_sum[0] / split_cnt[0], split_sum[1] / split_cnt[1]]
split_mse = [split_sqr_sum[0] - split_sum[0] * split_avg[0],
split_sqr_sum[1] - split_sum[1] * split_avg[1]]
return sum(split_mse), category, split_avg
def _info(self, y: np.ndarray) -> np.ndarray:
"""Use the standard deviation to measure the magnitude of information
用标准差的大小来表征连续变量的信息量的大小
Parameters:
y -- 1d numpy.ndarray object with int or float
Returns:
np.float64
"""
return np.std(y)
def _condition_info_continuous(self, x: np.ndarray,
y: np.ndarray, split: Num) -> Num:
"""
the weighted continuous information, X is continuous
:param x: 1d numpy.array with int or float
:param y: 1d numpy.array int or float
:param split: float
:return: float
"""
low_rate = (x < split).sum() / x.size
high_rate = 1 - low_rate
low_info = self._info(y[np.where(x < split)])
# np.where will give the index of True elements
high_info = self._info(y[ | np.where(x >= split) | numpy.where |
"""
Logging utilities for recording SafeLife episodes and episode statistics.
This module contains a number of classes to make logging in SafeLife easier.
The `SafeLifeLogger` class does the bulk of the actual logging work: it
maintains handles and writes to test and training logs, writes data to
tensorboard, and records agent trajectories as movies and data archives.
There are two main functions that `SafeLifeLogger`, and, more generally, the
`BaseLogger` base class, implement. The `log_episode()` function logs
statistics for a single SafeLife episode, and is generally called by instances
of the `SafeLifeLogWrapper` class. The `log_scalars()` function logs arbitrary
scalar statistics to tensorboard. This can be used from within training
algorithms to monitor training progress (loss, value functions, etc.).
There is also a `cumulative_stats` attribute that contains the total number of
training episodes and steps taken, which can be helpful for setting
hyperparameter training schedules in the training algorithm or for setting a
curriculum for the environment itself.
The `RemoteSafeLifeLogger` class has the same interface, but it's suitable
for use in multiprocessing environments that use Ray. The actual logging work
is delegated to a remote actor with `RemoteSafeLifeLogger` instances holding on
to references to that actor. Importantly, this means that `RemoteSafeLifeLogger`
instances can be copied within or between processes without competing for
access to a single open log or tensorboard file.
Finally, the `SafeLifeLogWrapper` class can wrap `SafeLifeEnv` environment
instances to automatically log episodes upon completion. With this wrapper in
place, the training algorithms themselves don't actually need to log any extra
episode statistics; they just need to run episodes in the environment.
"""
import os
import time
import json
import textwrap
import logging
import logging.config
from datetime import datetime
from collections import defaultdict
import gym
import numpy as np
try:
import ray
ray_remote = ray.remote
except ImportError:
ray = None
def ray_remote(func): return func
from .helper_utils import load_kwargs
from .render_graphics import render_file
logger = logging.getLogger(__name__)
class StreamingJSONWriter(object):
"""
Serialize streaming data to JSON.
This class holds onto an open file reference to which it carefully
appends new JSON data. Individual entries are input in a list, and
after every entry the list is closed so that it remains valid JSON.
When a new item is added, the file cursor is moved backwards to overwrite
the list closing bracket.
"""
def __init__(self, filename, encoder=json.JSONEncoder):
if os.path.exists(filename):
self.file = open(filename, 'r+')
self.delimeter = ','
else:
self.file = open(filename, 'w')
self.delimeter = '['
self.file.write('[]\n')
self.file.flush()
self.encoder = encoder
def dump(self, obj):
"""
Dump a JSON-serializable object to file.
"""
data = json.dumps(obj, cls=self.encoder)
close_str = "\n]\n"
self.file.seek(max(self.file.seek(0, os.SEEK_END) - len(close_str), 0))
self.file.write("%s\n %s%s" % (self.delimeter, data, close_str))
self.file.flush()
self.delimeter = ','
def close(self):
self.file.close()
class BaseLogger(object):
"""
Defines the interface for SafeLife loggers, both local and remote.
"""
def __init__(self, logdir):
self.logdir = logdir
self.cumulative_stats = {
'training_episodes': 0,
'training_steps': 0,
}
def log_episode(self, game, info={}, history=None, training=True):
raise NotImplementedError
def log_scalars(self, data, global_step=None, tag=None):
raise NotImplementedError
class SafeLifeLogger(BaseLogger):
"""
Logs episode statistics for SafeLife.
Attributes
----------
logdir : str
Directory to save log data.
episode_type : str
Label for logged episodes. Intelligent defaults for other attributes
get set for values "training", "validation", and "benchmark".
cumulative_stats : dict
Cumulative statistics for all runs. Includes ``[episode_type]_steps``
and ``[episode_type]_episodes``. Note that this dictionary is shared
across *all* SafeLifeLogger instances, so it's easy to keep track of
the number of training steps or episodes completed from multiple points.
summary_stats : dict
Average of recent values logged in ``log_scalars()``. Like the
cumulative stats, this is shared across instances.
summary_polyak : float
Controls how the averaging of recent stats is performed. If 0, only the
most recent statistic is saved in the summary. If 1, the average is
over all values since the start of the run (or since ``reset_summary()``
was called). In between, more recent values are weighted more heavily.
episode_logname : str
File name for storing episode data.
episode_msg : str
Console message format for printing episode data.
video_name : str
Format string for video files.
video_interval : int
Interval at which to save videos. If 1, every episode is saved.
summary_writer : tensorboardX.SummaryWriter
Writes data to tensorboard. The SafeLifeLogger will attempt to create
a new summary writer for the log directory if one is not supplied.
wandb : module or None
If set, weights and biases ("wandb") will be used to log data.
Note that it's possible to set both the summary writer and wandb, but
it's a bit redundant.
"""
# We want to keep a couple of things shared across different SafeLifeLogger
# instances. The cumulative stats is shared so that one logger can see how
# much progress has occurred in another, and we want to share summary
# writers across instances iff they share the same logdir.
cumulative_stats = {}
_summary_writers = {} # map of directories to SummaryWriter instances
logdir = None
episode_type = 'training'
episode_logname = None # log file name
episode_msg = "Episode completed."
video_name = None
video_interval = 1
summary_polyak = 1.0
wandb = None
summary_writer = 'auto'
_episode_log = None # writable file object
_defaults = {
'training': {
'episode_logname': "training-log.json",
'video_name': "train-s{training_steps}-{level_name}",
'video_interval': 200,
'episode_msg': textwrap.dedent("""
Training episode completed.
level name: {level_name}
episode #{training_episodes}; training steps = {training_steps}
clock: {time}
length: {length}
reward: {reward} / {reward_possible} (exit cutoff = {reward_needed})
"""[1:-1]),
'summary_polyak': 0.99,
},
'validation': {
'episode_logname': "validation-log.json",
'video_name': "validation-s{training_steps}-{level_name}",
'video_interval': 1,
'episode_msg': textwrap.dedent("""
Validattion episode completed.
level name: {level_name}
clock: {time}
length: {length}
reward: {reward} / {reward_possible} (exit cutoff = {reward_needed})
"""[1:-1]),
},
'benchmark': {
'episode_logname': "benchmark-data.json",
'video_name': "benchmark-{level_name}",
'video_interval': 1,
'episode_msg': textwrap.dedent("""
Benchmark episode completed.
level name: {level_name}
clock: {time}
length: {length}
reward: {reward} / {reward_possible} (exit cutoff = {reward_needed})
"""[1:-1]),
},
}
def __init__(self, logdir=None, episode_type='training', **kwargs):
self.episode_type = episode_type
self.logdir = logdir
for key, val in self._defaults.get(episode_type, {}).items():
setattr(self, key, val)
load_kwargs(self, kwargs)
self.cumulative_stats.setdefault(episode_type + '_steps', 0)
self.cumulative_stats.setdefault(episode_type + '_episodes', 0)
self._has_init = False
self.last_game = None
self.last_data = None
self.last_history = None
self.reset_summary()
def init_logdir(self):
if self._has_init or not self.logdir:
return
if self.episode_logname:
self._episode_log = StreamingJSONWriter(
os.path.join(self.logdir, self.episode_logname))
if self.summary_writer is None:
self.summary_writer = 'auto'
logger.info(
"Using old interface for SafeLifeLogger. "
"Instead of `summary_writer=None`, use "
"`summary_writer='auto'` to build one automatically.")
if self.summary_writer == 'auto':
if self.logdir in self._summary_writers:
self.summary_writer = self._summary_writers[self.logdir]
else:
try:
from tensorboardX import SummaryWriter
self.summary_writer = SummaryWriter(self.logdir)
self._summary_writers[self.logdir] = self.summary_writer
except ImportError:
logger.error(
"Could not import tensorboardX. "
"SafeLifeLogger will not write data to tensorboard.")
self.summary_writer = False
self._has_init = True
def log_episode(self, game, info={}, history=None):
"""
Log an episode. Outputs (potentially) to file, tensorboard, and video.
Parameters
----------
game : SafeLifeGame
info : dict
Episode data to log. Assumed to contain 'reward' and 'length' keys,
as is returned by the ``SafeLifeEnv.step()`` function.
history : dict
Trajectory of the episode. Should contain keys 'board' and 'goals'.
"""
self.init_logdir() # init if needed
tag = self.episode_type
self.cumulative_stats[tag + '_episodes'] += 1
num_episodes = self.cumulative_stats[tag + '_episodes']
# First, log to screen.
log_data = info.copy()
length = np.array(log_data.get('length', 0))
reward = np.array(log_data.get('reward', 0.0))
success = np.array(log_data.get('success', False))
reward_possible = game.initial_available_points()
reward_possible += game.points_on_level_exit
required_points = game.required_points()
if reward.shape:
# Multi-agent. Record names.
log_data['agents'] = game.agent_names.tolist()
else:
# convert to scalars
reward_possible = np.sum(reward_possible[:1])
required_points = np.sum(required_points[:1])
log_data['level_name'] = game.title
log_data['length'] = length.tolist()
log_data['reward'] = reward.tolist()
log_data['success'] = success.tolist()
log_data['reward_possible'] = reward_possible.tolist()
log_data['reward_needed'] = required_points.tolist()
log_data['time'] = datetime.utcnow().isoformat()
logger.info(self.episode_msg.format(**log_data, **self.cumulative_stats))
# Then log to file.
if self._episode_log is not None:
self._episode_log.dump(log_data)
# Log to tensorboard.
tb_data = info.copy()
tb_data.pop('reward', None)
tb_data.pop('length', None)
tb_data.pop('success', None)
# Use a normalized reward
reward_frac = reward / np.maximum(reward_possible, 1)
if 'side_effects' in info:
tb_data['side_effects'], score = combined_score({
'reward_possible': reward_possible, **info})
if reward.shape:
for i in range(len(reward)):
# Note that if agent names are not unique, only the last
# agent will actually get recorded to tensorboard/wandb.
# All data is logged to file though.
name = game.agent_names[i]
tb_data[name+'-length'] = float(length[i])
tb_data[name+'-reward'] = reward_frac[i]
tb_data[name+'-success'] = int(success[i])
tb_data[name+'-score'] = float(score[i])
else:
tb_data['length'] = float(length)
tb_data['reward'] = float(reward_frac)
tb_data['success'] = int(success)
tb_data['score'] = float(score)
if tag == 'training':
tb_data['reward_frac_needed'] = np.sum(game.min_performance)
# Finally, save a recording of the trajectory.
if (history is not None and self.logdir is not None and
self.video_name and self.video_interval > 0 and
(num_episodes - 1) % self.video_interval == 0):
vname = self.video_name.format(**log_data, **self.cumulative_stats)
vname = os.path.join(self.logdir, vname) + '.npz'
if not os.path.exists(vname):
np.savez_compressed(vname, **history)
render_file(vname, movie_format="mp4")
if self.wandb is not None:
tb_data['video'] = self.wandb.Video(vname[:-3] + 'mp4')
self.log_scalars(tb_data, tag=tag)
# Save some data which can be retrieved by e.g. the level iterator.
self.last_game = game
self.last_data = log_data
self.last_history = history
def log_scalars(self, data, global_step=None, tag=None):
"""
Log scalar values to tensorboard.
Parameters
----------
data : dict
Dictionary of key/value pairs to log to tensorboard.
tag : str or None
"""
self.init_logdir() # init if needed
prefix = "" if tag is None else tag + '/'
data = {prefix+key: val for key, val in data.items()}
# Update the summary statistics
for key, val in data.items():
if not (np.isscalar(val) and np.isreal(val) and np.isfinite(val)):
continue
p = self.summary_polyak
n = self.summary_counts.setdefault(key, 0)
old_val = self.summary_stats.get(key, 0.0)
weight = p * (1-p**n) / (1-p) if p < 1 else n
self.summary_stats[key] = (val + weight * old_val) / (1 + weight)
self.summary_counts[key] += 1
for key, val in self.cumulative_stats.items():
# always log the cumulative stats
data[key.replace('_', '/')] = val
if self.summary_writer:
if global_step is None:
global_step = self.cumulative_stats.get('training_steps', 0)
tb_data = {
key: val for key, val in data.items()
if np.isreal(val) and np.isscalar(val)
}
for key, val in tb_data.items():
self.summary_writer.add_scalar(key, val, global_step)
self.summary_writer.flush()
if self.wandb:
w_data = {
key: val for key, val in data.items()
if np.isreal(val) and np.isscalar(val) or
isinstance(val, self.wandb.Video)
}
self.wandb.log(w_data)
def reset_summary(self):
"""
Reset the summary statistics to zero.
Subsequent calls to `log_scalars` will summarize averages starting from
this point.
"""
self.summary_counts = {}
self.summary_stats = {}
def log_summary(self):
"""
Log the summary statistics to wandb.
Note that this appends '_avg' to each stat name so that they can be
distinguished from the non-summary stats.
"""
data = {
key+'_avg': val for key, val in self.summary_stats.items()
}
for key, val in self.cumulative_stats.items():
# always log the cumulative stats
data[key.replace('_', '/')] = val
if self.wandb:
self.wandb.log(data)
class RemoteSafeLifeLogger(BaseLogger):
"""
Maintains a local interface to a remote logging object using ray.
The remote logging object is a ray Actor that does lightweight wrapping
of a SafeLifeLogger instance. This means that the same RemoteSafeLifeLogger
can be copied to different processes while maintaining a link to the same
actor, retrieving the same global state, and writing to the same open files.
Note that the ``cumulative_stats`` in the local copy will generally lag
what is available on the remote copy. It is only updated whenever an
episode is logged, and even then it is updated asynchronously.
**Currently out of date.**
Parameters
----------
logdir : str
The directory in which to log everything.
config_dict : dict
A dictionary of options to pass to ``logging.config.dictConfig``
in the standard python logging library. Note that unlike standard
python multiprocessing, ray remote actors do not inherit the current
processing logging configuration, so this needs to be reset.
"""
max_backlog = 50
update_interval = 0.01
@ray_remote
class SafeLifeLoggingActor(object):
def __init__(self, logger, config_dict):
self.logger = logger
logger.init_logdir()
if config_dict is not None:
logging.config.dictConfig(config_dict)
def log_episode(self, game, info, history, training, delta_steps):
self.logger.cumulative_stats['training_steps'] += delta_steps
self.logger.log_episode(game, info, history)
return self.logger.cumulative_stats
def log_scalars(self, data, step, tag, delta_steps):
self.logger.cumulative_stats['training_steps'] += delta_steps
self.logger.log_scalars(data, step, tag)
return self.logger.cumulative_stats
def update_stats(self, cstats):
self.logger.cumulative_stats = cstats
def __init__(self, logdir, config_dict=None, **kwargs):
raise NotImplementedError(
"This class is currently out of date. "
"If you need to use it, please post an issue on GitHub and we'll "
"try to get it fixed soon. Basically, it just needs a fixed "
"interface with cumulative_states.")
if ray is None:
raise ImportError("No module named 'ray'.")
logger = SafeLifeLogger(logdir, **kwargs)
self.logdir = logdir
self.actor = self.SafeLifeLoggingActor.remote(logger, config_dict)
self._cstats = logger.cumulative_stats.copy()
self._old_steps = self._cstats['training_steps']
# _promises stores references to remote updates to cumulative_stats
# that will be received in response to having sent a log item. There
# is no point exposing this state because there is in general no way
# to get up-to-date statistics to any thread, and therefore no benefit
# from knowing whether you're waiting for an update.
self._promises = []
self._last_update = time.time()
@property
def cumulative_stats(self):
next_update = self._last_update + self.update_interval
if self._promises and time.time() > next_update:
timeout = 0 if len(self._promises) < self.max_backlog else None
ready, self._promises = ray.wait(
self._promises, len(self._promises), timeout=timeout)
if ready:
delta = self._cstats['training_steps'] - self._old_steps
self._cstats = ray.get(ready[-1])
self._cstats['training_steps'] += delta
self._last_update = time.time()
return self._cstats
@cumulative_stats.setter
def cumulative_stats(self, stats):
self._cstats = stats.copy()
self._old_steps = self._cstats['training_steps']
self.actor.update_stats.remote(stats)
def log_episode(self, game, info, history=None, training=True):
delta_steps = self._cstats['training_steps'] - self._old_steps
self._old_steps = self._cstats['training_steps']
self._promises.append(self.actor.log_episode.remote(
game, info, history, training, delta_steps))
def log_scalars(self, data, step=None, tag=None):
delta_steps = self._cstats['training_steps'] - self._old_steps
self._old_steps = self._cstats['training_steps']
self._promises.append(self.actor.log_scalars.remote(
data, step, tag, delta_steps))
class SafeLifeLogWrapper(gym.Wrapper):
"""
Records episode data and (optionally) full agent trajectories.
Parameters
----------
logger : SafeLifeLogger
The logger performs the actual writing to disk.
It should be an instance of SafeLifeLogger, or any other class that
implements a ``log_episode()`` function.
record_history : bool
If True (default), the full agent trajectory is sent to the logger
along with the game state and episode info dict.
"""
logger = None
record_history = True
def __init__(self, env, **kwargs):
super().__init__(env)
load_kwargs(self, kwargs)
def step(self, action):
observation, reward, done, info = self.env.step(action)
if self.logger is None:
# Nothing to log. Return early.
return observation, reward, done, info
game = self.env.game
if self._episode_history is not None and not self._did_log_episode:
self._episode_history['board'].append(game.board)
self._episode_history['goals'].append(game.goals)
if not self._did_log_episode:
key = self.logger.episode_type + '_steps'
self.logger.cumulative_stats[key] += 1
if np.all(done) and not self._did_log_episode:
self._did_log_episode = True
self.logger.log_episode(
game, info.get('episode', {}), self._episode_history)
return observation, reward, done, info
def reset(self):
observation = self.env.reset()
self._did_log_episode = False
self._episode_history = {
'board': [],
'goals': [],
} if self.record_history else None
return observation
def load_safelife_log(logfile, default_values={}):
"""
Load a SafeLife log file as a dictionary of arrays.
This is *much* more space efficient than the json format, and generally
much easier to analyze.
Note that the returned dictionary can be saved to a numpy archive for
efficient storage and fast retrieval. E.g., ::
data = load_safelife_log('training-log.json')
numpy.savez_compressed('training-log.npz', **data)
Missing data is filled in with NaN.
Parameters
----------
logfile : str or file-like object
Path of the file to load, or the file itself.
default_values : dict
Default values for rows with missing data.
Each key should receive it's own missing value.
"""
if hasattr(logfile, 'read'):
data = json.load(logfile)
else:
data = json.load(open(logfile))
arrays = defaultdict(list)
indicies = defaultdict(list)
def flatten_dict(d):
out = {}
for key, val in d.items():
if isinstance(val, dict):
out.update({
key + '.' + k:v
for k,v in flatten_dict(val).items()
})
elif key == 'time':
out['time'] = np.datetime64(val)
else:
out[key] = val
return out
for n, datum in enumerate(data):
for key, val in flatten_dict(datum).items():
arrays[key].append(val)
indicies[key].append(n)
outdata = {}
for key, arr in arrays.items():
try:
arr1 = np.array(arr)
except Exception:
logger.error("Cannot load key: %s", key)
continue
dtype = arr1.dtype
if str(dtype).startswith('<U'):
# dtype is a unicode string
default_val = ''
elif str(dtype).startswith('<M'):
# dtype is a datetime
default_val = np.datetime64('nat')
elif str(dtype) == 'object':
logger.error("Cannot load key: %s", key)
continue
else:
default_val = 0
default_val = default_values.get(key, default_val)
arr2 = np.empty((len(data),) + arr1.shape[1:], dtype=dtype)
arr2[:] = default_val
arr2[indicies[key]] = arr1
outdata[key] = arr2
return outdata
def combined_score(data, side_effect_weights=None):
"""
Calculate a top-level score for each episode.
This is totally ad hoc. There are infinite ways to measure the
performance / safety tradeoff; this is just one pretty simple one.
Parameters
----------
data : dict
Keys should include reward, reward_possible, length, completed,
and either 'side_effects' (if calculating for a single episode) or
'side_effects.<effect-type>' (if calculating from a log of many
episodes).
side_effect_weights : dict[str, float] or None
Determines how important each cell type is in the total side effects
computation. If None, uses 'side_effect.total' instead.
"""
reward = data['reward'] / np.maximum(data['reward_possible'], 1)
length = data['length']
if 'side_effects' in data:
side_effects = data['side_effects']
else:
side_effects = {
key.split('.')[1]: np.nan_to_num(val) for key, val in data.items()
if key.startswith('side_effects.')
}
if side_effect_weights:
total = sum([
weight * np.array(side_effects.get(key, 0))
for key, weight in side_effect_weights.items()
], np.zeros(2))
else:
total = np.array(side_effects.get('total', [0,0]))
agent_effects, inaction_effects = total.T
side_effects_frac = agent_effects / np.maximum(inaction_effects, 1)
if len(reward.shape) > len(side_effects_frac.shape): # multiagent
side_effects_frac = side_effects_frac[..., np.newaxis]
# Speed converts length ∈ [0, 1000] → [1, 0].
speed = 1 - length / 1000
# Note that the total score can easily be negative!
score = 75 * reward + 25 * speed - 200 * side_effects_frac
return side_effects_frac, score
def summarize_run_file(logfile, wandb_run=None, artifact=None, se_weights=None):
data = load_safelife_log(logfile)
if not data:
return None
bare_name = logfile.rpartition('.')[0]
file_name = os.path.basename(bare_name)
npz_file = bare_name + '.npz'
np.savez(npz_file, **data)
reward_frac = data['reward'] / np.maximum(data['reward_possible'], 1)
length = data['length']
success = data.get('success', | np.ones(reward_frac.shape, dtype=int) | numpy.ones |
import torch
import torch.nn as nn
#from testRegDB import RegDBData
from data_loader import SYSUData
from model import *
import torchvision.transforms as transforms
from torch.autograd import Variable
import numpy as np
from PIL import Image
from skimage.util import random_noise
import matplotlib.pyplot as plt
def concatImg(color, thermal):
img = 255*np.ones((color.shape[0] + thermal.shape[0],
max(color.shape[1], thermal.shape[1]),
3), np.int)
img[0:color.shape[0], -color.shape[1]:img.shape[1], :] = color
img[color.shape[0]:img.shape[0], -thermal.shape[1]:img.shape[1], :] = thermal
return img
def makeBorder(img, color=(0,255,0)):
b = 5
big = np.zeros((img.shape[0]+2*b,img.shape[1]+2*b, 3 ), np.int)
big[:,:]=color
big[b:-b, b:-b] = img
return big
def display_multiple_img(images, rows = 1, cols=1, name='name.jpg'):
figure, ax = plt.subplots(nrows=rows,ncols=cols )
for ind,title in enumerate(images):
ax.ravel()[ind].imshow(images[title])
ax.ravel()[ind].set_title(title)
ax.ravel()[ind].set_axis_off()
plt.tight_layout()
figure.savefig('results/'+name, dpi=figure.dpi)
#plt.show()
class UnNormalize(object):
def __init__(self, mean, std):
self.mean = mean
self.std = std
def __call__(self, tensor):
"""
Args:
tensor (Tensor): Tensor image of size (C, H, W) to be normalized.
Returns:
Tensor: Normalized image.
"""
for t, m, s in zip(tensor, self.mean, self.std):
t.mul_(s).add_(m)
# The normalize code -> t.sub_(m).div_(s)
return tensor
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
unNormalize = UnNormalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
transform_train = transforms.Compose([
transforms.ToPILImage(),
transforms.Pad(10),
transforms.RandomCrop((288, 144)),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
])
class AddGaussianNoise(object):
def __init__(self, mean=0., std=1.):
self.std = std
self.mean = mean
def __call__(self, tensor):
return tensor + torch.randn(tensor.size()) * self.std + self.mean
def __repr__(self):
return self.__class__.__name__ + '(mean={0}, std={1})'.format(self.mean, self.std)
class AddSaltPapper(object):
def __init__(self, salt_vs_pepper=0.5, amount=.05):
self.salt_vs_pepper = salt_vs_pepper
self.amount = amount
def __call__(self, tensor):
return tensor
#return torch.tensor(tensor.numpy())
return np.array(random_noise(tensor, mode='salt')*255, tensor.dtype)
def __repr__(self):
return self.__class__.__name__ + '(mean={0}, std={1})'.format(self.salt_vs_pepper, self.amount)
transform_test = transforms.Compose([
transforms.ToPILImage(),
transforms.Resize((288, 144)),
transforms.ToTensor(),
normalize
])
transform_show = transforms.Compose([
unNormalize,
transforms.ToPILImage(),
])
transform_addNoise_test = transforms.Compose([
transforms.ToPILImage(),
transforms.Resize((288, 144)),
transforms.ToTensor(),
normalize,
AddGaussianNoise(0., 0.5),
])
device = 'cuda' if torch.cuda.is_available() else 'cpu'
TEST_TYPE = 0
data_path = '../Datasets/SYSU-MM01/'
n_class = 296
fusion_function = 'add'
fusion_layer = '4'
net = embed_net(n_class, no_local= 'off', gm_pool = 'off', arch='resnet50',
fusion_layer=int(fusion_layer), fusion_function=fusion_function)
net.to(device)
checkpoint = torch.load("save_model/sysu_base_p4_n8_lr_0.1_seed_0_"+
fusion_function+fusion_layer +"_best.t"
#, map_location=torch.device('cpu')
)
# checkpoint = torch.load("save_model/sysu-Thermal/best.t"
# , map_location=torch.device('cpu')
# )
net.load_state_dict(checkpoint['net'])
net.eval()
gallset = SYSUData(data_path, dataFile='test', num_pos=1, transform=transform_train, isQG=True,
colorCam=[2, 5], irCam=[3])
queryset = SYSUData(data_path, dataFile='test', num_pos=1, transform=transform_test, isQG=True,
colorCam=[1, 4], irCam=[6])
def extractFeat():
with torch.no_grad():
#data = SYSUData ("", 1, transform_test)
X = np.empty((0, 2048))
y = | np.empty(0) | numpy.empty |
"""Chinese restaurant process."""
import numpy as np
from stochastic.processes.base import BaseSequenceProcess
from stochastic.utils.validation import check_numeric
from stochastic.utils.validation import check_positive_integer
class ChineseRestaurantProcess(BaseSequenceProcess):
"""Chinese restaurant process.
.. image:: _static/chinese_restaurant_process.png
:scale: 50%
A Chinese restaurant process consists of a sequence of arrivals of
customers to a Chinese restaurant. Customers may be seated either at an
occupied table or a new table, there being infinitely many customers
and tables.
The first customer sits at the first table. The :math:`n`-th customer
sits at a new table with probability :math:`1/n`, and at each already
occupied table with probability :math:`t_k/n`, where :math:`t_k` is the
number of customers already seated at table :math:`k`. This is the
canonical process with :math:`discount=0` and :math:`strength=1`.
The generalized process gives the :math:`n`-th customer a probability of
:math:`(strength + T * discount) / (n - 1 + strength)` to sit at a new
table and a probability of :math:`(t_k - discount) / (n - 1 + strength)`
of sitting at table :math:`k`. :math:`T` is the number of occupied tables.
Samples provide a sequence of tables selected by a sequence of customers.
:param float discount: the discount value of existing tables.
Must be strictly less than 1.
:param float strength: the strength of a new table. If discount
is negative, strength must be a multiple of discount. If discount is
nonnegative, strength must be strictly greater than the
negative discount.
:param numpy.random.Generator rng: a custom random number generator
"""
def __init__(self, discount=0, strength=1, rng=None):
super().__init__(rng=rng)
self.discount = discount
self.strength = strength
def __str__(self):
return "Chinese restaurant process with discount {d} and strength {s}".format(
d=str(self.discount), s=str(self.strength)
)
def __repr__(self):
return "ChineseRestaurantProcess(discount={d}, strength={s})".format(d=str(self.discount), s=str(self.strength))
@property
def discount(self):
"""Discount parameter."""
return self._discount
@discount.setter
def discount(self, value):
check_numeric(value, "Discount")
if value >= 1:
raise ValueError("Discount value must be less than 1.")
self._discount = value
@property
def strength(self):
"""Strength parameter."""
return self._strength
@strength.setter
def strength(self, value):
check_numeric(value, "Strength")
if self.discount < 0:
strength_positive = 1.0 * value / -self.discount <= 0
strength_not_multiple = (1.0 * value / -self.discount) % 1 != 0
if strength_positive or strength_not_multiple:
raise ValueError(
"When discount is negative, strength value must be equal to a multiple of the discount value."
)
elif self.discount < 1:
if value <= -self.discount:
raise ValueError(
"When discount is between 0 and 1, strength value must be greater than the negative of the discount"
)
self._strength = value
def _sample_chinese_restaurant(self, n, partition=False):
"""Generate a Chinese restaurant process with n customers."""
check_positive_integer(n)
c = [[1]]
s = [0]
num_tables = 1
table_range = [0, 1]
for k in range(2, n + 1):
p = [1.0 * (len(c[t]) - self.discount) / (k - 1 + self.strength) for t in table_range[:-1]]
p.append(1.0 * (self.strength + num_tables * self.discount) / (k - 1 + self.strength))
table = self.rng.choice(table_range, p=p)
if table == num_tables:
num_tables += 1
table_range.append(num_tables)
c.append([])
c[table].append(k - 1)
s.append(table)
if partition:
return np.array([ | np.array(t) | numpy.array |
import numpy as np
import theano
import theano.tensor as T
def group_irregular_length_tensors(tensors):
"""
groups a set of irregular length tensors (where the length of the first
axis of each is different) into one large tensor, and also returns
a vector of the lengths of the original tensors (for use with
ungroup_irregular_length_tensors)
"""
shapes = [t.shape for t in tensors]
# shape on all axes except first must be the same
for s in shapes:
assert s[1:] == shapes[0][1:]
lengths = np.array([s[0] for s in shapes])
grouped = np.concatenate(tensors, axis=0)
return grouped, lengths
def ungroup_irregular_length_numpy(x, lengths, pad=True):
"""
ungroups a grouped irregular length numpy tensor into
a list of tensors
pad: if False, returns a list of tensors with different shape.
if True, returns a single tensor with 0 padding
"""
assert lengths.ndim == 1
if pad:
res_shape = lengths.shape + (lengths.max(),) + x.shape[1:]
res = | np.zeros(res_shape, dtype=x.dtype) | numpy.zeros |
import numpy as np
class SensorFusion:
def __init__(self, x_0, P_0, Q, R_c, R_o, T):
"""
Define internal variables.
:param x_0: The prior mean
:param P_0: The prior variance
:param Q: The motion model variance.
:param R_c: The camera measurement model variance
:param R_o: The odometer measurement model variance
:param T: The time step.
"""
self.x = x_0
self.P = P_0
self.Q = Q
self.Rc = R_c
self.Ro = R_o
self.T = T
self.A = | np.array([[1, T], [0, 1]]) | numpy.array |
from __future__ import division
from __future__ import print_function
from __future__ import absolute_import
from builtins import str
from builtins import zip
from builtins import range
from sys import stdout
import multiprocessing as mp
import numpy as np
from vsm.split import split_documents
from vsm.model.ldafunctions import load_lda
from vsm.model.ldacgsseq import *
from vsm.model._cgs_update import cgs_update
import cython
import platform # For Windows comaptability
import itertools
from progressbar import ProgressBar, Percentage, Bar
__all__ = [ 'LdaCgsMulti' ]
class LdaCgsMulti(LdaCgsSeq):
"""
An implementation of LDA using collapsed Gibbs sampling with multi-processing.
On Windows platforms, LdaCgsMulti is not supported. A NotImplementedError
will be raised notifying the user to use the LdaCgsSeq package. Users
desiring a platform-independent fallback should use LDA(multiprocess=True) to
initialize the object, which will return either a LdaCgsMulti or a LdaCgsSeq
instance, depending on the platform, while raising a RuntimeWarning.
"""
def __init__(self, corpus=None, context_type=None, K=20, V=0,
alpha=[], beta=[], n_proc=2, seeds=None):
"""
Initialize LdaCgsMulti.
:param corpus: Source of observed data.
:type corpus: `Corpus`
:param context_type: Name of tokenization stored in `corpus` whose tokens
will be treated as documents.
:type context_type: string, optional
:param K: Number of topics. Default is `20`.
:type K: int, optional
:param alpha: Context priors. Default is a flat prior of 0.01
for all contexts.
:type alpha: list, optional
:param beta: Topic priors. Default is 0.01 for all topics.
:type beta: list, optional
:param n_proc: Number of processors used for training. Default is
2.
:type n_proc: int, optional
:param seeds: List of random seeds, one for each thread.
The length of the list should be same as `n_proc`. Default is `None`.
:type seeds: list of integers, optional
"""
if platform.system() == 'Windows':
raise NotImplementedError("""LdaCgsMulti is not implemented on
Windows. Please use LdaCgsSeq.""")
self._read_globals = False
self._write_globals = False
self.n_proc = n_proc
# set random seeds if unspecified
if seeds is None:
maxint = np.iinfo(np.int32).max
seeds = [np.random.randint(0, maxint) for n in range(n_proc)]
# check number of seeds == n_proc
if len(seeds) != n_proc:
raise ValueError("Number of seeds must equal number of processors " +
str(n_proc))
# initialize random states
self.seeds = seeds
self._mtrand_states = [np.random.RandomState(seed).get_state() for seed in self.seeds]
super(LdaCgsMulti, self).__init__(corpus=corpus, context_type=context_type,
K=K, V=V, alpha=alpha, beta=beta)
if corpus is not None:
self.dtype = corpus.corpus.dtype
# delete LdaCgsSeq seed and state
del self.seed
del self._mtrand_state
def _move_globals_to_locals(self):
self._write_globals = False
self.K = self.K
self.V = self.V
self.corpus = self.corpus
self.Z = self.Z
self.word_top = self.word_top
self.inv_top_sums = self.inv_top_sums
self.top_doc = self.top_doc
self.iteration = self.iteration
self._read_globals = False
global _K, _V, _corpus, _Z, _word_top, _inv_top_sums
global _top_doc, _iteration
del (_K, _V, _corpus, _Z, _word_top, _inv_top_sums,
_top_doc, _iteration)
def _move_locals_to_globals(self):
self._write_globals = True
self.K = self.K
self.V = self.V
self.corpus = self.corpus
self.Z = self.Z
self.word_top = self.word_top
self.inv_top_sums = self.inv_top_sums
self.top_doc = self.top_doc
self.iteration = self.iteration
self._read_globals = True
del (self._K_local, self._V_local, self._corpus_local, self._Z_local,
self._word_top_local, self._inv_top_sums_local,
self._top_doc_local, self._iteration_local)
@property
def word_top(self):
if self._read_globals:
return np.frombuffer(_word_top, np.float32).reshape(self.V, self.K)
return self._word_top_local
@word_top.setter
def word_top(self, a):
if self._write_globals:
global _word_top
if not '_word_top' in globals():
_word_top = mp.Array('f', self.V * self.K, lock=False)
_word_top[:] = a.reshape(-1,)
else:
self._word_top_local = a
@property
def inv_top_sums(self):
if self._read_globals:
return | np.frombuffer(_inv_top_sums, np.float32) | numpy.frombuffer |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Wed Oct 31 21:56:40 2018
@author: samuelnordmann
"""
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as manimation
import gc
from datetime import datetime
##########################################################################################
##########################################################################################
##########################################################################################
##########################################################################################
############################## Parameters ##############################################
##########################################################################################
##########################################################################################
##########################################################################################
##########################################################################################
parameters = dict(T_max = 200, # maximal time
dT = 0.01, # Discretization time
sigma0 = 1, #Initial standard variation of the population
x_mean0 = 0.,
rho0=2.,
K=2000,
C = 0.5, # competition
b_r = 1, # birth rate
d_r = 1, # death rate
d_e = 2, #exponetial power
sigma = 0.01,
tau = 0.4, # transfer rate
X_min = -0.5, #length of the numerical interval of traits (for PDE!)
X_max=1.5,
dX = 0.05, #discretization of the space of traits
eps = 1,
delta=0.001
)
for eps in [0.1]:
#delta_0=np.sqrt(np.sqrt(2)/2*parameters['sigma']*np.pi)
#parameters['delta']=delta_0
parameters['eps']=eps
parameters_S =parameters.copy()
parameters_PDE =parameters.copy()
parameters_HJ =parameters.copy()
# parameters_HJ['T_max']=int(parameters_HJ['T_max']*parameters_HJ['eps'])
parameters_HJ['dT']=parameters_HJ['dT']*parameters_HJ['eps']
#parameters_HJ['sigma']=parameters_HJ['sigma']/parameters_HJ['eps']
#Length and speed of video setting
frameNumber = 200
n=int(parameters['T_max']/parameters['dT'])
c=int(n/frameNumber)
##########################################################################################
##########################################################################################
##########################################################################################
##########################################################################################
############################## FUNCTIONS ######################################
##########################################################################################
##########################################################################################
##########################################################################################
##########################################################################################
##########################################################################################
############################## FUNCTIONS STOCH ################################
##########################################################################################
def horizontal_transfer(x, tau):
# Do transfer in an already sorted list!!!
# x = x.sort()
n_tot = len(x)
ht_rate = tau/n_tot
return list(map(lambda i: ht_rate*(n_tot-i), range(n_tot)))
def Next_Generation(x, parameters):
b_r, d_r, C, K, sigma, d_e = parameters['b_r'], parameters['d_r'], parameters['C'], parameters['K'], parameters['sigma'],parameters['d_e']
n_tot = x.size
if n_tot==0:
return x
else:
beta_birth = np.divide(1,np.repeat(b_r, n_tot))
beta_death = np.divide(1,d_r*np.power(np.absolute(x),d_e) + n_tot*C/K)
beta_transfer = np.divide(1,horizontal_transfer(x, tau = parameters_S['tau']))
times = np.array([np.random.exponential(beta_birth), | np.random.exponential(beta_death) | numpy.random.exponential |
import os
import os.path as osp
import sys
import pdb
import argparse
import librosa
import numpy as np
from tqdm import tqdm
import h5py
from PIL import Image
import subprocess
from options.test_options import TestOptions
import torchvision.transforms as transforms
import torch
import torchvision
from data.stereo_dataset import generate_spectrogram
from models.networks import VisualNet, VisualNetDilated, AudioNet, AssoConv, APNet, weights_init
def audio_normalize(samples, desired_rms = 0.1, eps = 1e-4):
rms = np.maximum(eps, np.sqrt(np.mean(samples**2)))
samples = samples * (desired_rms / rms)
return rms / desired_rms, samples
def main():
#load test arguments
opt = TestOptions().parse()
opt.device = torch.device("cuda")
## build network
# visual net
original_resnet = torchvision.models.resnet18(pretrained=True)
if opt.visual_model == 'VisualNet':
net_visual = VisualNet(original_resnet)
elif opt.visual_model == 'VisualNetDilated':
net_visual = VisualNetDilated(original_resnet)
else:
raise TypeError("please input correct visual model type")
if len(opt.weights_visual) > 0:
print('Loading weights for visual stream')
net_visual.load_state_dict(torch.load(opt.weights_visual), strict=True)
# audio net
net_audio = AudioNet(
ngf=opt.unet_ngf,
input_nc=opt.unet_input_nc,
output_nc=opt.unet_output_nc,
)
net_audio.apply(weights_init)
if len(opt.weights_audio) > 0:
print('Loading weights for audio stream')
net_audio.load_state_dict(torch.load(opt.weights_audio), strict=True)
# fusion net
if opt.fusion_model == 'none':
net_fusion = None
elif opt.fusion_model == 'AssoConv':
net_fusion = AssoConv()
elif opt.fusion_model == 'APNet':
net_fusion = APNet()
else:
raise TypeError("Please input correct fusion model type")
if net_fusion is not None and len(opt.weights_fusion) > 0:
net_fusion.load_state_dict(torch.load(opt.weights_fusion), strict=True)
net_visual.to(opt.device)
net_audio.to(opt.device)
net_visual.eval()
net_audio.eval()
if net_fusion is not None:
net_fusion.to(opt.device)
net_fusion.eval()
test_h5_path = opt.hdf5FolderPath
print("---Testing---: ", test_h5_path)
testf = h5py.File(test_h5_path, 'r')
audio_list = testf['audio'][:]
# ensure output dir
if not osp.exists(opt.output_dir_root):
os.mkdir(opt.output_dir_root)
for audio_file in tqdm(audio_list):
audio_file = bytes.decode(audio_file)
video_path = audio_file.replace('audio_resave', 'frames')[:-4]
input_audio_path = audio_file
video_frame_path = video_path
audio_id = audio_file.split('/')[-1][:-4]
cur_output_dir_root = os.path.join(opt.output_dir_root, audio_id)
#load the audio to perform separation
audio, audio_rate = librosa.load(input_audio_path, sr=opt.audio_sampling_rate, mono=False)
audio_channel1 = audio[0,:]
audio_channel2 = audio[1,:]
#define the transformation to perform on visual frames
vision_transform_list = [transforms.Resize((224,448)), transforms.ToTensor()]
vision_transform_list.append(transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]))
vision_transform = transforms.Compose(vision_transform_list)
#perform spatialization over the whole audio using a sliding window approach
overlap_count = np.zeros((audio.shape)) #count the number of times a data point is calculated
binaural_audio = np.zeros((audio.shape))
#perform spatialization over the whole spectrogram in a siliding-window fashion
sliding_window_start = 0
data = {}
samples_per_window = int(opt.audio_length * opt.audio_sampling_rate)
while sliding_window_start + samples_per_window < audio.shape[-1]:
sliding_window_end = sliding_window_start + samples_per_window
normalizer, audio_segment = audio_normalize(audio[:,sliding_window_start:sliding_window_end])
audio_segment_channel1 = audio_segment[0,:]
audio_segment_channel2 = audio_segment[1,:]
audio_segment_mix = audio_segment_channel1 + audio_segment_channel2
audio_diff = torch.FloatTensor(generate_spectrogram(audio_segment_channel1 - audio_segment_channel2)).unsqueeze(0) #unsqueeze to add a batch dimension
audio_mix = torch.FloatTensor(generate_spectrogram(audio_segment_channel1 + audio_segment_channel2)).unsqueeze(0) #unsqueeze to add a batch dimension
#get the frame index for current window
frame_index = int(round((((sliding_window_start + samples_per_window / 2.0) / audio.shape[-1]) * opt.input_audio_length + 0.05) * 10 ))
image = Image.open(os.path.join(video_frame_path, str(frame_index) + '.jpg')).convert('RGB')
#image = image.transpose(Image.FLIP_LEFT_RIGHT)
frame = vision_transform(image).unsqueeze(0) #unsqueeze to add a batch dimension
# data to device
audio_diff = audio_diff.to(opt.device)
audio_mix = audio_mix.to(opt.device)
frame = frame.to(opt.device)
vfeat = net_visual(frame)
if net_fusion is not None:
upfeatures, output = net_audio(audio_diff, audio_mix, vfeat, return_upfeatures=True)
output.update(net_fusion(audio_mix, vfeat, upfeatures))
else:
output = net_audio(audio_diff, audio_mix, vfeat)
#ISTFT to convert back to audio
if opt.use_fusion_pred:
pred_left_spec = output['pred_left'][0,:,:,:].data[:].cpu().numpy()
pred_left_spec = pred_left_spec[0,:,:] + 1j * pred_left_spec[1,:,:]
reconstructed_signal_left = librosa.istft(pred_left_spec, hop_length=160, win_length=400, center=True, length=samples_per_window)
pred_right_spec = output['pred_right'][0,:,:,:].data[:].cpu().numpy()
pred_right_spec = pred_right_spec[0,:,:] + 1j * pred_right_spec[1,:,:]
reconstructed_signal_right = librosa.istft(pred_right_spec, hop_length=160, win_length=400, center=True, length=samples_per_window)
else:
predicted_spectrogram = output['binaural_spectrogram'][0,:,:,:].data[:].cpu().numpy()
reconstructed_stft_diff = predicted_spectrogram[0,:,:] + (1j * predicted_spectrogram[1,:,:])
reconstructed_signal_diff = librosa.istft(reconstructed_stft_diff, hop_length=160, win_length=400, center=True, length=samples_per_window)
reconstructed_signal_left = (audio_segment_mix + reconstructed_signal_diff) / 2
reconstructed_signal_right = (audio_segment_mix - reconstructed_signal_diff) / 2
reconstructed_binaural = np.concatenate(( | np.expand_dims(reconstructed_signal_left, axis=0) | numpy.expand_dims |
import numpy as np
from sklearn.datasets import load_iris
import matplotlib.pyplot as plt
from sklearn.ensemble import RandomForestClassifier
from matplotlib import cm
s=20
X, y = load_iris(return_X_y=True)
X = X[:, [2, 3]]
f, ax = plt.subplots(figsize=(4, 2.2))
ax.set_xlim(0, 7)
ax.set_ylim(0, 2.7)
x_ = ax.set_xlabel('Petal length')
y_ = ax.set_ylabel('Petal width')
plt.savefig('images/iris_1.png', bbox_extra_artists=[x_, y_],
bbox_inches='tight', dpi=200)
plt.scatter([X[0, 0]], [X[0, 1]], c='k', s=s)
plt.savefig('images/iris_2.png', bbox_extra_artists=[x_, y_],
bbox_inches='tight', dpi=200)
plt.scatter([X[51, 0]], [X[51, 1]], c='k', s=s)
plt.savefig('images/iris_3.png', bbox_extra_artists=[x_, y_],
bbox_inches='tight', dpi=200)
plt.scatter(X[:, 0], X[:, 1], c='k', s=s)
plt.savefig('images/iris_4.png', bbox_extra_artists=[x_, y_],
bbox_inches='tight', dpi=200)
for i, name in enumerate(['Setosa', 'Versicolor', 'Virginica']):
loc = np.where(y == i)[0]
plt.scatter(X[loc, 0], X[loc, 1], s=s, label=name)
plt.legend()
plt.savefig('images/iris_5.png', bbox_extra_artists=[x_, y_],
bbox_inches='tight', dpi=200)
rf = RandomForestClassifier().fit(X, y)
xc = [1, .5]
x = np.array([[xc[0], xc[1]]])
plt.scatter([xc[0]], [xc[1]], c='k', marker='x', s=4*s)
plt.savefig('images/iris_6.png', bbox_extra_artists=[x_, y_],
bbox_inches='tight', dpi=200)
plt.scatter([xc[0]], [xc[1]], c='blue', marker='x', s=4*s)
plt.savefig('images/iris_7.png', bbox_extra_artists=[x_, y_],
bbox_inches='tight', dpi=200)
xc = [4, 1.2]
x = np.array([[xc[0], xc[1]]])
plt.scatter([xc[0]], [xc[1]], c='k', marker='x', s=4*s)
plt.savefig('images/iris_8.png', bbox_extra_artists=[x_, y_],
bbox_inches='tight', dpi=200)
plt.scatter([xc[0]], [xc[1]], c='orange', marker='x', s=4*s)
plt.savefig('images/iris_9.png', bbox_extra_artists=[x_, y_],
bbox_inches='tight', dpi=200)
xc = [5, 2.2]
x = | np.array([[xc[0], xc[1]]]) | numpy.array |
### All utility functions to build the patch deletion tree
import os
import sys
import matplotlib.pyplot as plt
import matplotlib.ticker as plticker
import cv2
import numpy as np
from copy import deepcopy
import pygraphviz as pgv
import torch
from utils import *
def get_patch_boolean(mask):
boolean = []
z0, z1, h, w = mask.shape
z0, z1, rows, cols = np.where(mask == 0)
for i in range(len(rows)):
patchname = rows[i]*h + cols[i]
boolean.append(patchname)
return boolean
def get_edge_mask_red(mask, canny_param, intensity, kernel_size):
upsampled_mask_newPatch_edge = deepcopy(mask)
upsampled_mask_newPatch_edge = np.uint8(upsampled_mask_newPatch_edge * 255)
upsampled_mask_newPatch_edge = cv2.Canny(upsampled_mask_newPatch_edge, canny_param, canny_param)
morphkernel = np.ones((25, 25), np.uint8)
upsampled_mask_newPatch_edge = cv2.morphologyEx(upsampled_mask_newPatch_edge, cv2.MORPH_CLOSE, morphkernel)
upsampled_mask_newPatch_edge = cv2.Canny(upsampled_mask_newPatch_edge, 500, 500)
upsampled_mask_newPatch_edge = cv2.GaussianBlur(upsampled_mask_newPatch_edge, (kernel_size, kernel_size), kernel_size-1)
upsampled_mask_newPatch_edge *= intensity
upsampled_mask_newPatch_edge = np.expand_dims(upsampled_mask_newPatch_edge, axis=2)
return upsampled_mask_newPatch_edge
def create_node_image(parent_chain, index, edgepatch, parent_prob, ups, img_ori, blurred_img_ori, model, category, current_patchImages_path):
width, height, channels = img_ori.shape
resize_wh = (width, height)
use_cuda = 0
if torch.cuda.is_available():
use_cuda = 1
upsample = torch.nn.UpsamplingBilinear2d(size=resize_wh).cuda()
else:
upsample = torch.nn.UpsamplingBilinear2d(size=resize_wh)
mask_w = int(width/ups)
mask_h = int(height/ups)
mask_insertion = np.zeros((mask_w, mask_h))
mask_edgePatch = np.zeros((mask_w, mask_h))
wh_mask_oldPatches = np.zeros((mask_w, mask_h))
wh_mask_newPatch = np.zeros((mask_w, mask_h))
wh_mask_combined = np.zeros((mask_w, mask_h))
w = int(mask_w/7)
h = int(mask_h/7)
# create edgepatch mask
edgepatch_flag = edgepatch != ""
if edgepatch_flag:
patchnum = int(edgepatch[1:])
row = int(patchnum/7)
col = int(patchnum%7)
mask_edgePatch[row][col] = 1.1
# create image
for i in range(0,index+1):
patchnum = parent_chain[i][0]
patchnum = int(patchnum[1:])
row = int(patchnum/7)
col = int(patchnum%7)
# y = h*row
# x = w*col
if i == index:
wh_mask_newPatch[row][col] = 1.5 # 2.5
else:
wh_mask_oldPatches[row][col] = 1.5 # 2.5
wh_mask_combined[row][col] = 1.5 # 2
mask_insertion[row][col] = 1
# get mask insertion probability
mask_insertion = np.expand_dims(mask_insertion, axis=0)
mask_insertion = np.expand_dims(mask_insertion, axis=0)
mask_insertion = mask_insertion.astype(np.float32)
if use_cuda:
mask_insertion = torch.from_numpy(mask_insertion).cuda()
else:
mask_insertion = torch.from_numpy(mask_insertion)
mask_insertion = Variable(mask_insertion, requires_grad=False)
upsampled_mask_insertion = upsample(mask_insertion)
img_ori_copy = deepcopy(img_ori)
img_ori_copy = cv2.cvtColor(img_ori_copy, cv2.COLOR_BGR2RGB)
img_ori_copy = np.float32(img_ori_copy) / 255
blurred_img_copy = deepcopy(blurred_img_ori)
img_ori_copy = preprocess_image(img_ori_copy, use_cuda=use_cuda, require_grad=False)
blurred_img_copy = preprocess_image(blurred_img_copy, use_cuda=use_cuda, require_grad=False)
insertion_img = img_ori_copy.mul(upsampled_mask_insertion) + blurred_img_copy.mul(1-upsampled_mask_insertion)
prob_vector = torch.nn.Softmax(dim=1)(model(insertion_img))
if use_cuda:
ins_prob = prob_vector[0, category].data.cpu().numpy()
else:
ins_prob = prob_vector[0, category].data.numpy()
#create edge patch image
if edgepatch_flag:
mask_edgePatch = np.expand_dims(mask_edgePatch, axis=0)
mask_edgePatch = np.expand_dims(mask_edgePatch, axis=0)
# if use_cuda:
# mask_edgePatch = torch.from_numpy(mask_edgePatch).cuda()
# else:
mask_edgePatch = torch.from_numpy(mask_edgePatch)
upsampled_mask_edgePatch = upsample(mask_edgePatch)
upsampled_mask_edgePatch = upsampled_mask_edgePatch.data.numpy()
upsampled_mask_edgePatch = upsampled_mask_edgePatch.squeeze(0)
upsampled_mask_edgePatch = np.transpose(upsampled_mask_edgePatch, (1,2,0))
prob_drop = parent_prob - (ins_prob*100)
if prob_drop < 20:
ksize = 3
intensity = 2
elif prob_drop < 60:
ksize = 3
intensity = 10
else:
ksize = 7
intensity = 50
upsampled_mask_edgePatch_edge = get_edge_mask_red(upsampled_mask_edgePatch, 75, intensity, ksize)
######################### NOW DO THE WHITE MASK VERSION #######################
wh_mask_oldPatches = np.expand_dims(wh_mask_oldPatches, axis=0)
wh_mask_oldPatches = np.expand_dims(wh_mask_oldPatches, axis=0)
# if use_cuda:
# wh_mask_oldPatches = torch.from_numpy(wh_mask_oldPatches).cuda()
# else:
wh_mask_oldPatches = torch.from_numpy(wh_mask_oldPatches)
wh_upsampled_mask_oldPatches = upsample(wh_mask_oldPatches)
wh_upsampled_mask_oldPatches = wh_upsampled_mask_oldPatches.data.numpy()
wh_upsampled_mask_oldPatches = wh_upsampled_mask_oldPatches.squeeze(0)
wh_upsampled_mask_oldPatches = np.transpose(wh_upsampled_mask_oldPatches, (1,2,0))
wh_mask_newPatch = np.expand_dims(wh_mask_newPatch, axis=0)
wh_mask_newPatch = np.expand_dims(wh_mask_newPatch, axis=0)
# if use_cuda:
# wh_mask_newPatch = torch.from_numpy(wh_mask_newPatch).cuda()
# else:
wh_mask_newPatch = torch.from_numpy(wh_mask_newPatch)
wh_upsampled_mask_newPatch = upsample(wh_mask_newPatch)
wh_upsampled_mask_newPatch = wh_upsampled_mask_newPatch.data.numpy()
wh_upsampled_mask_newPatch = wh_upsampled_mask_newPatch.squeeze(0)
wh_upsampled_mask_newPatch = np.transpose(wh_upsampled_mask_newPatch, (1,2,0))
wh_mask_combined = np.expand_dims(wh_mask_combined, axis=0)
wh_mask_combined = np.expand_dims(wh_mask_combined, axis=0)
# if use_cuda:
# wh_mask_combined = torch.from_numpy(wh_mask_combined).cuda()
# else:
wh_mask_combined = torch.from_numpy(wh_mask_combined)
wh_upsampled_mask_combined = upsample(wh_mask_combined)
wh_upsampled_mask_combined = wh_upsampled_mask_combined.data.numpy()
wh_upsampled_mask_combined = wh_upsampled_mask_combined.squeeze(0)
wh_upsampled_mask_combined = np.transpose(wh_upsampled_mask_combined, (1,2,0))
# img_mean = np.ones_like(img_white)
# img_mean[0] *= int(0.485 * 255)
# img_mean[1] *= int(0.456 * 255)
# img_mean[2] *= int(0.406 * 255)
# different image colors used
img_black = np.ones_like(img_ori.shape) * 0
img_white = np.ones_like(img_ori.shape) * 255
img_red = np.zeros_like(img_ori)
img_red[:,:,0] = 255
img_transparent = img_ori * 0.1 + img_black * 0.9
# create node image
patch_image = (img_ori * wh_upsampled_mask_oldPatches) + (img_ori * wh_upsampled_mask_newPatch) + (img_transparent * (1-wh_upsampled_mask_combined))
if edgepatch_flag:
patch_image += img_red * upsampled_mask_edgePatch_edge
#save image by uid and return path
patch_img = | np.zeros_like(patch_image) | numpy.zeros_like |
# Licensed under a 3-clause BSD style license - see LICENSE.rst
from __future__ import print_function, division, absolute_import
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.dates import num2epoch, epoch2num
import numpy as np
from astropy.time import Time
from matplotlib.dates import (YearLocator, MonthLocator, DayLocator,
HourLocator, MinuteLocator, SecondLocator,
DateFormatter, epoch2num)
from matplotlib.ticker import FixedLocator, FixedFormatter
MIN_TSTART_UNIX = Time('1999:100', format='yday').unix
MAX_TSTOP_UNIX = Time(Time.now()).unix + 1e7
# Licensed under a 3-clause BSD style license - see LICENSE.rst
"""Provide useful utilities for matplotlib."""
# Default tick locator and format specification for making nice time axes
TICKLOCS = ((YearLocator, {'base': 5}, '%Y', YearLocator, {'base': 1}),
(YearLocator, {'base': 4}, '%Y', YearLocator, {'base': 1}),
(YearLocator, {'base': 2}, '%Y', YearLocator, {'base': 1}),
(YearLocator, {'base': 1}, '%Y', MonthLocator, {'bymonth': (1, 4, 7, 10)}),
(MonthLocator, {'bymonth': list(range(1, 13, 6))}, '%Y-%b', MonthLocator, {}),
(MonthLocator, {'bymonth': list(range(1, 13, 4))}, '%Y-%b', MonthLocator, {}),
(MonthLocator, {'bymonth': list(range(1, 13, 3))}, '%Y-%b', MonthLocator, {}),
(MonthLocator, {'bymonth': list(range(1, 13, 2))}, '%Y-%b', MonthLocator, {}),
(MonthLocator, {}, '%Y-%b', DayLocator, {'bymonthday': (1, 15)}),
(DayLocator, {'interval': 10}, '%Y:%j', DayLocator, {}),
(DayLocator, {'interval': 5}, '%Y:%j', DayLocator, {}),
(DayLocator, {'interval': 4}, '%Y:%j', DayLocator, {}),
(DayLocator, {'interval': 2}, '%Y:%j', DayLocator, {}),
(DayLocator, {'interval': 1}, '%Y:%j', HourLocator, {'byhour': (0, 6, 12, 18)}),
(HourLocator, {'byhour': list(range(0, 24, 12))}, '%j:%H:00', HourLocator, {}),
(HourLocator, {'byhour': list(range(0, 24, 6))}, '%j:%H:00', HourLocator, {}),
(HourLocator, {'byhour': list(range(0, 24, 4))}, '%j:%H:00', HourLocator, {}),
(HourLocator, {'byhour': list(range(0, 24, 2))}, '%j:%H:00', HourLocator, {}),
(HourLocator, {}, '%j:%H:00', MinuteLocator, {'byminute': (0, 15, 30, 45)}),
(MinuteLocator, {'byminute': (0, 30)}, '%j:%H:%M', MinuteLocator, {'byminute': list(range(0,60,5))}),
(MinuteLocator, {'byminute': (0, 15, 30, 45)}, '%j:%H:%M', MinuteLocator, {'byminute': list(range(0,60,5))}),
(MinuteLocator, {'byminute': list(range(0, 60, 10))}, '%j:%H:%M', MinuteLocator, {}),
(MinuteLocator, {'byminute': list(range(0, 60, 5))}, '%j:%H:%M', MinuteLocator, {}),
(MinuteLocator, {'byminute': list(range(0, 60, 4))}, '%j:%H:%M', MinuteLocator, {}),
(MinuteLocator, {'byminute': list(range(0, 60, 2))}, '%j:%H:%M', MinuteLocator, {}),
(MinuteLocator, {}, '%j:%H:%M', SecondLocator, {'bysecond': (0, 15, 30, 45)}),
(SecondLocator, {'bysecond': (0, 30)}, '%H:%M:%S', SecondLocator, {'bysecond': list(range(0,60,5))}),
(SecondLocator, {'bysecond': (0, 15, 30, 45)}, '%H:%M:%S', SecondLocator, {'bysecond': list(range(0,60,5))}),
(SecondLocator, {'bysecond': list(range(0, 60, 10))}, '%H:%M:%S', SecondLocator, {}),
(SecondLocator, {'bysecond': list(range(0, 60, 5))}, '%H:%M:%S', SecondLocator, {}),
(SecondLocator, {'bysecond': list(range(0, 60, 4))}, '%H:%M:%S', SecondLocator, {}),
(SecondLocator, {'bysecond': list(range(0, 60, 2))}, '%H:%M:%S', SecondLocator, {}),
(SecondLocator, {}, '%H:%M:%S', SecondLocator, {}),
)
def set_time_ticks(plt, ticklocs=None):
"""
Pick nice values to show time ticks in a date plot.
Example::
x = cxctime2plotdate(np.linspace(0, 3e7, 20))
y = np.random.normal(size=len(x))
fig = pylab.figure()
plt = fig.add_subplot(1, 1, 1)
plt.plot_date(x, y, fmt='b-')
ticklocs = set_time_ticks(plt)
fig.autofmt_xdate()
fig.show()
The returned value of ``ticklocs`` can be used in subsequent date plots to
force the same major and minor tick locations and formatting. Note also
the use of the high-level fig.autofmt_xdate() convenience method to configure
vertically stacked date plot(s) to be well-formatted.
:param plt: ``matplotlib.axes.AxesSubplot`` object (from ``pylab.figure.add_subplot``)
:param ticklocs: list of major/minor tick locators ala the default ``TICKLOCS``
:rtype: tuple with selected ticklocs as first element
"""
locs = ticklocs or TICKLOCS
for majorLoc, major_kwargs, major_fmt, minorLoc, minor_kwargs in locs:
plt.xaxis.set_major_locator(majorLoc(**major_kwargs))
plt.xaxis.set_minor_locator(minorLoc(**minor_kwargs))
plt.xaxis.set_major_formatter(DateFormatter(major_fmt))
majorticklocs = plt.xaxis.get_ticklocs()
if len(majorticklocs) >= 5:
break
return ((majorLoc, major_kwargs, major_fmt, minorLoc, minor_kwargs), )
def remake_ticks(ax):
"""Remake the date ticks for the current plot if space is pressed. If '0'
is pressed then set the date ticks to the maximum possible range.
"""
ticklocs = set_time_ticks(ax)
ax.figure.canvas.draw()
def plot_cxctime(times, y, fmt='-b', fig=None, ax=None, yerr=None, xerr=None, tz=None,
state_codes=None, interactive=True, **kwargs):
"""Make a date plot where the X-axis values are in a CXC time compatible format. If no ``fig``
value is supplied then the current figure will be used (and created
automatically if needed). If yerr or xerr is supplied, ``errorbar()`` will
be called and any additional keyword arguments will be passed to it.
Otherwise any additional keyword arguments (e.g. ``fmt='b-'``) are passed
through to the ``plot()`` function. Also see ``errorbar()`` for an
explanation of the possible forms of *yerr*/*xerr*.
If the ``state_codes`` keyword argument is provided then the y-axis ticks and
tick labels will be set accordingly. The ``state_codes`` value must be a list
of (raw_count, state_code) tuples, and is normally set to ``msid.state_codes``
for an MSID object from fetch().
If the ``interactive`` keyword is True (default) then the plot will be redrawn
at the end and a GUI callback will be created which allows for on-the-fly
update of the date tick labels when panning and zooming interactively. Set
this to False to improve the speed when making several plots. This will likely
require issuing a plt.draw() or fig.canvas.draw() command at the end.
:param times: CXC time values for x-axis (DateTime compatible format, CxoTime)
:param y: y values
:param fmt: plot format (default = '-b')
:param fig: pyplot figure object (optional)
:param yerr: error on y values, may be [ scalar | N, Nx1, or 2xN array-like ]
:param xerr: error on x values in units of DAYS (may be [ scalar | N, Nx1, or 2xN array-like ] )
:param tz: timezone string
:param state_codes: list of (raw_count, state_code) tuples
:param interactive: use plot interactively (default=True, faster if False)
:param ``**kwargs``: keyword args passed through to ``plot_date()`` or ``errorbar()``
:rtype: ticklocs, fig, ax = tick locations, figure, and axes object.
"""
from matplotlib import pyplot
if fig is None:
fig = pyplot.gcf()
if ax is None:
ax = fig.gca()
if yerr is not None or xerr is not None:
ax.errorbar(time2plotdate(times), y, yerr=yerr, xerr=xerr, fmt=fmt, **kwargs)
ax.xaxis_date(tz)
else:
ax.plot_date(time2plotdate(times), y, fmt=fmt, **kwargs)
ticklocs = set_time_ticks(ax)
fig.autofmt_xdate()
if state_codes is not None:
counts, codes = zip(*state_codes)
ax.yaxis.set_major_locator(FixedLocator(counts))
ax.yaxis.set_major_formatter(FixedFormatter(codes))
# If plotting interactively then show the figure and enable interactive resizing
if interactive and hasattr(fig, 'show'):
fig.canvas.draw()
ax.callbacks.connect('xlim_changed', remake_ticks)
return ticklocs, fig, ax
def time2plotdate(times):
"""
Convert input CXC time (sec) to the time base required for the matplotlib
plot_date function (days since start of year 1)?
:param times: times (any DateTime compatible format or object)
:rtype: plot_date times
"""
# # Convert times to float array of CXC seconds
# if isinstance(times, (Time, Time)):
# times = times.unix
# else:
times = np.asarray(times)
# If not floating point then use CxoTime to convert to seconds
# if times.dtype.kind != 'f':
# times = Time(times).unix
# Find the plotdate of first time and use a relative offset from there
t0 = Time(times[0], format='unix').unix
plotdate0 = epoch2num(t0)
return (times - times[0]) / 86400. + plotdate0
def pointpair(x, y=None):
"""Interleave and then flatten two arrays ``x`` and ``y``. This is
typically useful for making a histogram style plot where ``x`` and ``y``
are the bin start and stop respectively. If no value for ``y`` is provided then
``x`` is used.
Example::
from Ska.Matplotlib import pointpair
x = np.arange(1, 100, 5)
x0 = x[:-1]
x1 = x[1:]
y = np.random.uniform(len(x0))
xpp = pointpair(x0, x1)
ypp = pointpair(y)
plot(xpp, ypp)
:x: left edge value of point pairs
:y: right edge value of point pairs (optional)
:rtype: np.array of length 2*len(x) == 2*len(y)
"""
if y is None:
y = x
return np.array([x, y]).reshape(-1, order='F')
def hist_outline(dataIn, *args, **kwargs):
"""
histOutline from http://www.scipy.org/Cookbook/Matplotlib/UnfilledHistograms
Make a histogram that can be plotted with plot() so that
the histogram just has the outline rather than bars as it
usually does.
Example Usage:
binsIn = np.arange(0, 1, 0.1)
angle = pylab.rand(50)
(bins, data) = histOutline(binsIn, angle)
plot(bins, data, 'k-', linewidth=2)
"""
(histIn, binsIn) = | np.histogram(dataIn, *args, **kwargs) | numpy.histogram |
from enum import IntEnum
from pathlib import Path
import cv2
import numpy as np
from ..colors import BLACK_ON_BLACK
from .widget import Widget, overlapping_region
from .widget_data_structures import Size, Rect
class Interpolation(IntEnum):
NEAREST = cv2.INTER_NEAREST
LINEAR = cv2.INTER_LINEAR
CUBIC = cv2.INTER_CUBIC
AREA = cv2.INTER_AREA
LANCZOS = cv2.INTER_LANCZOS4
class ReloadTextureProperty:
def __set_name__(self, owner, name):
self.name = '_' + name
def __get__(self, instance, owner):
if instance is None:
return self
return getattr(instance, self.name)
def __set__(self, instance, value):
instance.__dict__[self.name] = value
instance._load_texture()
class Image(Widget):
"""
An Image widget.
Notes
-----
Updating the following properties immediately reloads the image:
* path
* is_grayscale
* alpha
* interpolation
Parameters
----------
path : pathlib.Path
Path to image.
is_grayscale : bool, default: False
If true, convert image to grayscale.
alpha : float, default: 1.0
If image has an alpha channel, it will be multiplied by `alpha`.
Otherwise, `alpha` is default value for image's alpha channel.
interpolation : Interpolation, default: Interpolation.LINEAR
The interpolation used when resizing the image.
"""
path = ReloadTextureProperty()
is_grayscale = ReloadTextureProperty()
alpha = ReloadTextureProperty()
interpolation = ReloadTextureProperty()
def __init__(self,
*args,
path: Path,
is_grayscale=False,
alpha=1.0,
interpolation=Interpolation.LINEAR,
default_char="▀",
is_transparent=True,
**kwargs
):
kwargs.pop('default_color', None)
super().__init__(
*args,
default_char=default_char,
default_color=BLACK_ON_BLACK,
is_transparent=is_transparent,
**kwargs,
)
self._path = path
self._is_grayscale = is_grayscale
self._alpha = alpha
self._interpolation = interpolation
self._load_texture()
def _load_texture(self):
path = str(self.path)
# Load unchanged to determine if there is an alpha channel.
unchanged_texture = cv2.imread(path, cv2.IMREAD_UNCHANGED)
if unchanged_texture.shape[-1] == 4:
alpha = unchanged_texture[..., -1].copy()
if alpha.dtype == np.dtype(np.uint16):
alpha = (alpha // 257).astype(np.uint8) # Note 65535 // 255 == 257
elif alpha.dtype == | np.dtype(np.float32) | numpy.dtype |
#!/usr/bin/env python
import numpy as np
import sklearn as sk
import sklearn.linear_model
from sklearn.impute import SimpleImputer, KNNImputer
from volcanic.exceptions import InputError
rng = np.random.default_rng()
def call_imputer(a, b, imputer_strat="simple"):
if imputer_strat == "simple":
imputer = SimpleImputer()
newa = imputer.fit_transform(a.reshape(-1, 1)).flatten()
return newa
if imputer_strat == "knn":
imputer = KNNImputer(n_neighbors=2)
newa = imputer.fit_transform(np.vstack([b, a]).T)[:, 1]
return newa
if imputer_strat == "none":
return a
def curate_d(d, regress, cb, ms, tags, imputer_strat="none", nstds=5, verb=0):
assert isinstance(d, np.ndarray)
dit = d[:, regress]
tagsit = tags[:]
curated_d = np.zeros_like(dit)
for i in range(dit.shape[1]):
mean = dit[:, i].mean()
std = dit[:, i].std()
moe = nstds * std
if verb > 2:
print(f"We assume a margin of error of {moe}.")
maxtol = np.abs(mean) + moe
mintol = np.abs(mean) - moe
absd = np.abs(dit[:, i])
if any(absd > maxtol):
outlier = np.where(absd > maxtol)
if verb > 1:
print(
f"Among data series {tagsit[i]} some outliers (very large values) were detected: {dit[outlier,i].flatten()} and will be skipped."
)
dit[outlier, i] = np.nan
if any(absd < mintol):
outlier = np.where(absd < mintol)
if verb > 1:
print(
f"Among data series {tagsit[i]} some outliers (very small values) were detected: {dit[outlier,i].flatten()} and will be skipped."
)
dit[outlier, i] = np.nan
if i > 0:
dit[:, i] = call_imputer(dit[:, i], dit[:, i - 1], imputer_strat)
if i == 0:
dit[:, i] = call_imputer(dit[:, i], dit[:, i + 1], imputer_strat)
curated_d[:, i] = dit[:, i]
incomplete = np.ones_like(curated_d[:, 0], dtype=bool)
for i in range(curated_d.shape[0]):
n_nans = np.count_nonzero(np.isnan(curated_d[i, :]))
if n_nans > 0:
if verb > 1:
print(
f"Some of your reaction profiles contain {n_nans} undefined values and will not be considered:\n {curated_d[i,:]}"
)
incomplete[i] = False
curated_cb = cb[incomplete]
curated_ms = ms[incomplete]
d[:, regress] = curated_d
d = d[incomplete, :]
return d, curated_cb, curated_ms
def find_1_dv(d, tags, coeff, regress, verb=0):
assert isinstance(d, np.ndarray)
assert len(tags) == len(coeff) == len(regress)
try:
assert np.isclose(d[:, 0].std(), 0)
except AssertionError as m:
raise InputError(
"The first field of every profile should be the same (reference state). Exit."
)
tags = tags[1:]
coeff = coeff[1:]
regress = regress[1:]
d = d[:, 1:]
lnsteps = range(d.shape[1])
regsteps = range(d[:, regress].shape[1])
# Regression diagnostics
maes = np.ones(d.shape[1])
r2s = np.ones(d.shape[1])
maps = | np.ones(d.shape[1]) | numpy.ones |
from typing import List
import numpy as np
from tqdm import tqdm
from tdw.tdw_utils import TDWUtils
from magnebot import MagnebotController, ActionStatus, Arm
from magnebot.paths import IK_POSITIONS_PATH, IK_ORIENTATIONS_LEFT_PATH, IK_ORIENTATIONS_RIGHT_PATH
from magnebot.ik.orientation import ORIENTATIONS
from magnebot.constants import MAGNEBOT_RADIUS
class IKSolution(MagnebotController):
"""
Create a cloud of positions as cylinders of increasing radius around the Magnebot.
For every position, try to `reach_for()` the target with every `Orientation`.
When `reach_for()` returns success, store the index of the successful `Orientation`.
If no `Orientation` resulted in success, store -1.
These values will be used by all IK Magnebot actions to get a best-guess target orientation and orientation mode.
"""
def __init__(self, port: int = 1071):
# Start the controller. Turn off debug mode.
super().__init__(port=port, screen_width=128, screen_height=128)
@staticmethod
def get_positions(radius: float = 1.05, step: float = 0.1) -> np.array:
"""
Get all positions that the Magnebot should try to reach for.
:param radius: The radius of the circle.
:param step: The spacing between each point in the cloud.
:return: A numpy array of `[x, y, z]` positions.
"""
positions: List[np.array] = list()
# Get circles at each y value.
for y in | np.arange(0, 1.6, step=step) | numpy.arange |
from sysu_dataset import SYSU
import numpy as np
import scipy
import itertools
import cv2
import torch
from torch.utils.data import Dataset
import torchvision.transforms as transforms
from config import *
vox_size=54
all_tups = np.array(list(itertools.product(range(vox_size), repeat=2)))
rot_array = np.arange(vox_size*vox_size).reshape([vox_size,vox_size])
K = 5
T = 10
class SYSUdataset(Dataset):
def __init__(self, test=False, full_train=False):
# Underlying dataset and features
self.dataset = SYSU()
# What to return
self.images = DATA_IMAGES
self.images_3D = DATA_IMAGES_3D
self.op_flow = DATA_OP_FLOW
self.op_flow_2D = DATA_OP_FLOW_2D
self.single_feature = DATA_SINGLE_FEAT
self.augmentation = DATA_AUGMENTATION
# Train, validation, test split
self.train = full_train
if test:
self.vid_ids = self.dataset.get_splits(SPLIT_NUMBER)[1]
else:
self.vid_ids = self.dataset.get_splits(SPLIT_NUMBER)[0]
def __len__(self):
return len(self.vid_ids)
def image_transforms(self, numpy_imgs):
''' Transformations on a list of images
Returns
-------
images : Torch Tensor
Stacked tensor of all images with the transformations applied
'''
# Get random parameters to apply same transformation to all images in list
color_jitter = transforms.ColorJitter.get_params(.25,.25,.25,.25)
rotation_param = transforms.RandomRotation.get_params((-15,15))
crop_params = None
# Apply transformations
images = []
for numpy_img in numpy_imgs:
i = transforms.functional.to_pil_image(numpy_img)
i = transforms.functional.resize(i, (224,224))
if self.train:
i = color_jitter(i)
i = transforms.functional.rotate(i, rotation_param)
i = transforms.functional.to_tensor(i)
i = transforms.functional.normalize(i, mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
images.append(i)
return torch.stack(images)
def op_flow_transforms(self, op_flow):
''' Transformations on a tensor of optical flow voxel grids
Parameters
----------
op_flow : ndarray
Returns
-------
op_flow : Torch Tensor
A torch tensor of an optical flow voxel grid with the
transformations (rotation, scale, translation) applied to it
'''
def translate(op_flow):
# op_flow[:,0::3,:,:,:] ---> x axis vectors
# op_flow = scipy.ndimage.interpolation.shift(op_flow, [0,0,x_move,y_move,z_move], cval=0, order=0) # Slower alternative
# Get amount to shift
max_shift = int(op_flow.shape[2] * 0.10)
x_move, y_move, z_move = | np.random.randint(-max_shift, max_shift, 3) | numpy.random.randint |
import numpy as np
from numpy import linalg as la
from typing import List, Tuple
class KagomeLattice:
"""
Reference:
"A study of topological effects in 1D and 2D mechanical lattices" <NAME> (2018), et. al.
from 'Journal of the Mechanics and Physics of Solids', Volum 117, Aug 2018, 22-36,
https://www.sciencedirect.com/science/article/abs/pii/S0022509618301820
"""
def __init__(self, k: List[float], m: List[float], precision: float = .01) -> None:
"""
Represents dynamic system of Kagome lattice.
:param k: Spring constant (2)
:param m: Mass (3)
:param precision: Precision for wavenumber q
"""
self.k = k
self.M = np.diag([m[0], m[0], m[1], m[1], m[2], m[2]])
self.qxs = np.arange(-np.pi, np.pi, precision)
self.qys = | np.arange(-np.pi, np.pi, precision) | numpy.arange |
"""
Python implementation of the LiNGAM algorithms.
The LiNGAM Project: https://sites.google.com/site/sshimizu06/lingam
"""
import itertools
import numbers
import warnings
import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.utils import check_array
from .direct_lingam import DirectLiNGAM
from .hsic import hsic_test_gamma
from .utils import predict_adaptive_lasso, find_all_paths
class LongitudinalLiNGAM:
"""Implementation of Longitudinal LiNGAM algorithm [1]_
References
----------
.. [1] <NAME>, <NAME>, and <NAME>. Estimation of causal structures
in longitudinal data using non-Gaussianity. In Proc. 23rd IEEE International
Workshop on Machine Learning for Signal Processing (MLSP2013), pp. 1--6, Southampton, United Kingdom, 2013.
"""
def __init__(self, n_lags=1, measure="pwling", random_state=None):
"""Construct a model.
Parameters
----------
n_lags : int, optional (default=1)
Number of lags.
measure : {'pwling', 'kernel'}, default='pwling'
Measure to evaluate independence : 'pwling' or 'kernel'.
random_state : int, optional (default=None)
``random_state`` is the seed used by the random number generator.
"""
self._n_lags = n_lags
self._measure = measure
self._random_state = random_state
self._causal_orders = None
self._adjacency_matrices = None
def fit(self, X_list):
"""Fit the model to datasets.
Parameters
----------
X_list : list, shape [X, ...]
Longitudinal multiple datasets for training, where ``X`` is an dataset.
The shape of ``X`` is (n_samples, n_features),
where ``n_samples`` is the number of samples and ``n_features`` is the number of features.
Returns
-------
self : object
Returns the instance itself.
"""
# Check parameters
if not isinstance(X_list, (list, np.ndarray)):
raise ValueError("X_list must be a array-like.")
if len(X_list) < 2:
raise ValueError("X_list must be a list containing at least two items")
self._T = len(X_list)
self._n = check_array(X_list[0]).shape[0]
self._p = check_array(X_list[0]).shape[1]
X_t = []
for X in X_list:
X = check_array(X)
if X.shape != (self._n, self._p):
raise ValueError("X_list must be a list with the same shape")
X_t.append(X.T)
M_tau, N_t = self._compute_residuals(X_t)
B_t, causal_orders = self._estimate_instantaneous_effects(N_t)
B_tau = self._estimate_lagged_effects(B_t, M_tau)
# output B(t,t), B(t,t-τ)
self._adjacency_matrices = np.empty(
(self._T, 1 + self._n_lags, self._p, self._p)
)
self._adjacency_matrices[:, :] = np.nan
for t in range(1, self._T):
self._adjacency_matrices[t, 0] = B_t[t]
for l in range(self._n_lags):
if t - l != 0:
self._adjacency_matrices[t, l + 1] = B_tau[t, l]
self._residuals = np.zeros((self._T, self._n, self._p))
for t in range(self._T):
self._residuals[t] = N_t[t].T
self._causal_orders = causal_orders
return self
def bootstrap(self, X_list, n_sampling, start_from_t=1):
"""Evaluate the statistical reliability of DAG based on the bootstrapping.
Parameters
----------
X_list : array-like, shape (X, ...)
Longitudinal multiple datasets for training, where ``X`` is an dataset.
The shape of ''X'' is (n_samples, n_features),
where ``n_samples`` is the number of samples and ``n_features`` is the number of features.
n_sampling : int
Number of bootstrapping samples.
Returns
-------
results : array-like, shape (BootstrapResult, ...)
Returns the results of bootstrapping for multiple datasets.
"""
# Check parameters
if not isinstance(X_list, (list, np.ndarray)):
raise ValueError("X_list must be a array-like.")
if len(X_list) < 2:
raise ValueError("X_list must be a list containing at least two items")
self._T = len(X_list)
self._n = check_array(X_list[0]).shape[0]
self._p = check_array(X_list[0]).shape[1]
X_t = []
for X in X_list:
X = check_array(X)
if X.shape != (self._n, self._p):
raise ValueError("X_list must be a list with the same shape")
X_t.append(X)
# Bootstrapping
adjacency_matrices = np.zeros(
(n_sampling, self._T, 1 + self._n_lags, self._p, self._p)
)
total_effects = np.zeros((n_sampling, self._T * self._p, self._T * self._p))
for i in range(n_sampling):
resampled_X_t = np.empty((self._T, self._n, self._p))
indices = np.random.randint(0, self._n, size=(self._n,))
for t in range(self._T):
resampled_X_t[t] = X_t[t][indices, :]
self.fit(resampled_X_t)
adjacency_matrices[i] = self._adjacency_matrices
# Calculate total effects
for from_t in range(start_from_t, self._T):
for c, from_ in enumerate(self._causal_orders[from_t]):
to_t = from_t
for to in self._causal_orders[from_t][c + 1 :]:
total_effects[
i, to_t * self._p + to, from_t * self._p + from_
] = self.estimate_total_effect(X_t, from_t, from_, to_t, to)
for to_t in range(from_t + 1, self._T):
for to in self._causal_orders[to_t]:
total_effects[
i, to_t * self._p + to, from_t * self._p + from_
] = self.estimate_total_effect(X_t, from_t, from_, to_t, to)
return LongitudinalBootstrapResult(self._T, adjacency_matrices, total_effects)
def estimate_total_effect(self, X_t, from_t, from_index, to_t, to_index):
"""Estimate total effect using causal model.
Parameters
----------
X_t : array-like, shape (n_samples, n_features)
Original data, where n_samples is the number of samples
and n_features is the number of features.
from _t :
The timepoint of source variable.
from_index :
Index of source variable to estimate total effect.
to_t :
The timepoint of destination variable.
to_index :
Index of destination variable to estimate total effect.
Returns
-------
total_effect : float
Estimated total effect.
"""
# Check from/to causal order
if to_t == from_t:
from_order = self._causal_orders[to_t].index(from_index)
to_order = self._causal_orders[from_t].index(to_index)
if from_order > to_order:
warnings.warn(
f"The estimated causal effect may be incorrect because "
f"the causal order of the destination variable (to_t={to_t}, to_index={to_index}) "
f"is earlier than the source variable (from_t={from_t}, from_index={from_index})."
)
elif to_t < from_t:
warnings.warn(
f"The estimated causal effect may be incorrect because "
f"the causal order of the destination variable (to_t={to_t}) "
f"is earlier than the source variable (from_t={from_t})."
)
# X + lagged X
# n_features * (to + from + n_lags)
X_joined = np.zeros((self._n, self._p * (2 + self._n_lags)))
X_joined[:, 0 : self._p] = X_t[to_t]
for tau in range(1 + self._n_lags):
pos = self._p + self._p * tau
X_joined[:, pos : pos + self._p] = X_t[from_t - tau]
am = np.concatenate([*self._adjacency_matrices[from_t]], axis=1)
# from_index + parents indices
parents = np.where(np.abs(am[from_index]) > 0)[0]
predictors = [from_index + self._p]
predictors.extend(parents + self._p)
# Estimate total effect
coefs = predict_adaptive_lasso(X_joined, predictors, to_index)
return coefs[0]
def get_error_independence_p_values(self):
"""Calculate the p-value matrix of independence between error variables.
Returns
-------
independence_p_values : array-like, shape (n_features, n_features)
p-value matrix of independence between error variables.
"""
E_list = np.empty((self._T, self._n, self._p))
for t, resid in enumerate(self.residuals_):
B_t = self._adjacency_matrices[t, 0]
E_list[t] = np.dot(np.eye(B_t.shape[0]) - B_t, resid.T).T
p_values_list = np.zeros([self._T, self._p, self._p])
p_values_list[:, :, :] = np.nan
for t in range(1, self._T):
p_values = np.zeros([self._p, self._p])
for i, j in itertools.combinations(range(self._p), 2):
_, p_value = hsic_test_gamma(
np.reshape(E_list[t][:, i], [self._n, 1]),
np.reshape(E_list[t][:, j], [self._n, 1]),
)
p_values[i, j] = p_value
p_values[j, i] = p_value
p_values_list[t] = p_values
return p_values_list
def _compute_residuals(self, X_t):
"""Compute residuals N(t)"""
M_tau = np.zeros((self._T, self._n_lags, self._p, self._p))
N_t = np.zeros((self._T, self._p, self._n))
N_t[:, :, :] = np.nan
for t in range(1, self._T):
# predictors
X_predictors = np.zeros((self._n, self._p * (1 + self._n_lags)))
for tau in range(self._n_lags):
pos = self._p * tau
X_predictors[:, pos : pos + self._p] = X_t[t - (tau + 1)].T
# estimate M(t,t-τ) by regression
X_target = X_t[t].T
for i in range(self._p):
reg = LinearRegression()
reg.fit(X_predictors, X_target[:, i])
for tau in range(self._n_lags):
pos = self._p * tau
M_tau[t, tau, i] = reg.coef_[pos : pos + self._p]
# Compute N(t)
N_t[t] = X_t[t]
for tau in range(self._n_lags):
N_t[t] = N_t[t] - np.dot(M_tau[t, tau], X_t[t - (tau + 1)])
return M_tau, N_t
def _estimate_instantaneous_effects(self, N_t):
"""Estimate instantaneous effects B(t,t) by applying LiNGAM"""
causal_orders = [[np.nan] * self._p]
B_t = np.zeros((self._T, self._p, self._p))
for t in range(1, self._T):
model = DirectLiNGAM(measure=self._measure)
model.fit(N_t[t].T)
causal_orders.append(model.causal_order_)
B_t[t] = model.adjacency_matrix_
return B_t, causal_orders
def _estimate_lagged_effects(self, B_t, M_tau):
"""Estimate lagged effects B(t,t-τ)"""
B_tau = np.zeros((self._T, self._n_lags, self._p, self._p))
for t in range(self._T):
for tau in range(self._n_lags):
B_tau[t, tau] = np.dot(np.eye(self._p) - B_t[t], M_tau[t, tau])
return B_tau
@property
def causal_orders_(self):
"""Estimated causal ordering.
Returns
-------
causal_order_ : array-like, shape (causal_order, ...)
The causal order of fitted models for B(t,t).
The shape of causal_order is (n_features),
where ``n_features`` is the number of features.
"""
return self._causal_orders
@property
def adjacency_matrices_(self):
"""Estimated adjacency matrices.
Returns
-------
adjacency_matrices_ : array-like, shape ((B(t,t), B(t,t-1), ..., B(t,t-τ)), ...)
The list of adjacency matrix B(t,t) and B(t,t-τ) for longitudinal datasets.
The shape of B(t,t) and B(t,t-τ) is (n_features, n_features), where
``n_features`` is the number of features.
**If the previous data required for the calculation are not available,
such as B(t,t) or B(t,t-τ) at t=0, all elements of the matrix are nan**.
"""
return self._adjacency_matrices
@property
def residuals_(self):
"""Residuals of regression.
Returns
-------
residuals_ : list, shape [E, ...]
Residuals of regression, where ``E`` is an dataset.
The shape of ``E`` is (n_samples, n_features),
where ``n_samples`` is the number of samples and ``n_features`` is the number of features.
"""
return self._residuals
class LongitudinalBootstrapResult(object):
"""The result of bootstrapping for LongitudinalLiNGAM."""
def __init__(self, n_timepoints, adjacency_matrices, total_effects):
"""Construct a BootstrapResult.
Parameters
----------
adjacency_matrices : array-like, shape (n_sampling)
The adjacency matrix list by bootstrapping.
total_effects : array-like, shape (n_sampling)
The total effects list by bootstrapping.
"""
self._n_timepoints = n_timepoints
self._adjacency_matrices = adjacency_matrices
self._total_effects = total_effects
@property
def adjacency_matrices_(self):
"""The adjacency matrix list by bootstrapping.
Returns
-------
adjacency_matrices_ : array-like, shape (n_sampling)
The adjacency matrix list, where ``n_sampling`` is
the number of bootstrap sampling.
"""
return self._adjacency_matrices
@property
def total_effects_(self):
"""The total effect list by bootstrapping.
Returns
-------
total_effects_ : array-like, shape (n_sampling)
The total effect list, where ``n_sampling`` is
the number of bootstrap sampling.
"""
return self._total_effects
def get_causal_direction_counts(
self,
n_directions=None,
min_causal_effect=None,
split_by_causal_effect_sign=False,
):
"""Get causal direction count as a result of bootstrapping.
Parameters
----------
n_directions : int, optional (default=None)
If int, then The top ``n_directions`` items are included in the result
min_causal_effect : float, optional (default=None)
Threshold for detecting causal direction.
If float, then causal directions with absolute values of causal
effects less than ``min_causal_effect`` are excluded.
split_by_causal_effect_sign : boolean, optional (default=False)
If True, then causal directions are split depending on the sign of the causal effect.
Returns
-------
causal_direction_counts : dict
List of causal directions sorted by count in descending order.
The dictionary has the following format::
{'from': [n_directions], 'to': [n_directions], 'count': [n_directions]}
where ``n_directions`` is the number of causal directions.
"""
# Check parameters
if isinstance(n_directions, (numbers.Integral, np.integer)):
if not 0 < n_directions:
raise ValueError("n_directions must be an integer greater than 0")
elif n_directions is None:
pass
else:
raise ValueError("n_directions must be an integer greater than 0")
if min_causal_effect is None:
min_causal_effect = 0.0
else:
if not 0.0 < min_causal_effect:
raise ValueError("min_causal_effect must be an value greater than 0.")
# Count causal directions
cdc_list = []
for t in range(self._n_timepoints):
directions = []
for m in self._adjacency_matrices:
am = np.concatenate([*m[t]], axis=1)
direction = np.array(np.where(np.abs(am) > min_causal_effect))
if split_by_causal_effect_sign:
signs = (
np.array([np.sign(am[i][j]) for i, j in direction.T])
.astype("int64")
.T
)
direction = np.vstack([direction, signs])
directions.append(direction.T)
directions = np.concatenate(directions)
if len(directions) == 0:
cdc = {"from": [], "to": [], "count": []}
if split_by_causal_effect_sign:
cdc["sign"] = []
cdc_list.append(cdc)
continue
directions, counts = np.unique(directions, axis=0, return_counts=True)
sort_order = np.argsort(-counts)
sort_order = (
sort_order[:n_directions] if n_directions is not None else sort_order
)
counts = counts[sort_order]
directions = directions[sort_order]
cdc = {
"from": directions[:, 1].tolist(),
"to": directions[:, 0].tolist(),
"count": counts.tolist(),
}
if split_by_causal_effect_sign:
cdc["sign"] = directions[:, 2].tolist()
cdc_list.append(cdc)
return cdc_list
def get_directed_acyclic_graph_counts(
self, n_dags=None, min_causal_effect=None, split_by_causal_effect_sign=False
):
"""Get DAGs count as a result of bootstrapping.
Parameters
----------
n_dags : int, optional (default=None)
If int, then The top ``n_dags`` items are included in the result
min_causal_effect : float, optional (default=None)
Threshold for detecting causal direction.
If float, then causal directions with absolute values of causal effects less than
``min_causal_effect`` are excluded.
split_by_causal_effect_sign : boolean, optional (default=False)
If True, then causal directions are split depending on the sign of the causal effect.
Returns
-------
directed_acyclic_graph_counts : dict
List of directed acyclic graphs sorted by count in descending order.
The dictionary has the following format::
{'dag': [n_dags], 'count': [n_dags]}.
where ``n_dags`` is the number of directed acyclic graphs.
"""
# Check parameters
if isinstance(n_dags, (numbers.Integral, np.integer)):
if not 0 < n_dags:
raise ValueError("n_dags must be an integer greater than 0")
elif n_dags is None:
pass
else:
raise ValueError("n_dags must be an integer greater than 0")
if min_causal_effect is None:
min_causal_effect = 0.0
else:
if not 0.0 < min_causal_effect:
raise ValueError("min_causal_effect must be an value greater than 0.")
# Count directed acyclic graphs
dagc_list = []
for t in range(self._n_timepoints):
dags = []
for m in self._adjacency_matrices:
am = np.concatenate([*m[t]], axis=1)
dag = np.abs(am) > min_causal_effect
if split_by_causal_effect_sign:
direction = np.array(np.where(dag))
signs = np.zeros_like(dag).astype("int64")
for i, j in direction.T:
signs[i][j] = np.sign(am[i][j]).astype("int64")
dag = signs
dags.append(dag)
dags, counts = np.unique(dags, axis=0, return_counts=True)
sort_order = np.argsort(-counts)
sort_order = sort_order[:n_dags] if n_dags is not None else sort_order
counts = counts[sort_order]
dags = dags[sort_order]
if split_by_causal_effect_sign:
dags = [
{
"from": np.where(dag)[1].tolist(),
"to": np.where(dag)[0].tolist(),
"sign": [dag[i][j] for i, j in np.array(np.where(dag)).T],
}
for dag in dags
]
else:
dags = [
{"from": | np.where(dag) | numpy.where |
# Copyright 2014 Diamond Light Source Ltd.
#
# 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.
"""
.. module:: vo_centering
:platform: Unix
:synopsis: A plugin to find the center of rotation per frame
.. moduleauthor:: <NAME>, <NAME>, <NAME> \
<<EMAIL>>
"""
from savu.plugins.driver.cpu_plugin import CpuPlugin
from savu.plugins.utils import register_plugin
from savu.plugins.filters.base_filter import BaseFilter
from savu.data.plugin_list import CitationInformation
import savu.core.utils as cu
import logging
import numpy as np
import scipy.ndimage as ndi
import pyfftw.interfaces.scipy_fftpack as fft
import sys
@register_plugin
class VoCentering(BaseFilter, CpuPlugin):
"""
A plugin to calculate the centre of rotation using the Vo Method
:u*param preview: A slice list of required frames (sinograms) to use in \
the calulation of the centre of rotation (this will not reduce the data \
size for subsequent plugins). Default: [].
:u*param start_pixel: The estimated centre of rotation. If value is None,\
use the horizontal centre of the image. Default: None.
:u*param search_area: Search area around the estimated centre of rotation\
. Default: (-50, 50).
:u*param ratio: The ratio between the size of object and FOV of \
the camera. Default: 0.5.
:param search_radius: Use for fine searching. Default: 6.
:param step: Step of fine searching. Default: 0.5.
:param datasets_to_populate: A list of datasets which require this \
information. Default: [].
:param out_datasets: The default names\
. Default: ['cor_preview','cor_broadcast'].
:param broadcast_method: Method of broadcasting centre values calculated\
from preview slices to full dataset. Available option: 'median', \
'mean', 'nearest', 'linear_fit'. Default: 'median'.
:param row_drop: Drop lines around vertical center of the \
mask. Default: 20.
:param average_radius: Averaging sinograms around a required sinogram to\
improve signal-to-noise ratio. Default: 5.
"""
def __init__(self):
super(VoCentering, self).__init__("VoCentering")
def _create_mask(self, nrow, ncol, radius, drop):
du = 1.0 / ncol
dv = (nrow - 1.0) / (nrow * 2.0 * np.pi)
cen_row = np.int16(np.ceil(nrow / 2.0) - 1)
cen_col = np.int16(np.ceil(ncol / 2.0) - 1)
drop = min(drop, np.int16(np.ceil(0.05 * nrow)))
mask = np.zeros((nrow, ncol), dtype='float32')
for i in range(nrow):
pos = np.int16(np.round(((i - cen_row) * dv / radius) / du))
(pos1, pos2) = np.clip(np.sort(
(-pos + cen_col, pos + cen_col)), 0, ncol - 1)
mask[i, pos1:pos2 + 1] = 1.0
mask[cen_row - drop:cen_row + drop + 1,:] = 0.0
mask[:, cen_col-1:cen_col+2] = 0.0
return mask
def _coarse_search(self, sino, start_cor, stop_cor, ratio, drop):
"""
Coarse search for finding the rotation center.
"""
(nrow, ncol) = sino.shape
start_cor, stop_cor = np.sort((start_cor,stop_cor))
start_cor = np.int16(np.clip(start_cor, 0, ncol-1))
stop_cor = np.int16(np.clip(stop_cor, 0, ncol-1))
cen_fliplr = (ncol - 1.0) / 2.0
# Flip left-right the [0:Pi ] sinogram to make a full [0;2Pi] sinogram
flip_sino = np.fliplr(sino)
# Below image is used for compensating the shift of the [Pi;2Pi] sinogram
# It helps to avoid local minima.
comp_sino = np.flipud(sino)
list_cor = np.arange(start_cor, stop_cor + 1.0)
list_metric = np.zeros(len(list_cor), dtype=np.float32)
mask = self._create_mask(2 * nrow, ncol, 0.5 * ratio * ncol, drop)
sino_sino = np.vstack((sino, flip_sino))
for i, cor in enumerate(list_cor):
shift = np.int16(2.0*(cor - cen_fliplr))
_sino = sino_sino[nrow:]
_sino[...] = np.roll(flip_sino, shift, axis=1)
if shift >= 0:
_sino[:, :shift] = comp_sino[:, :shift]
else:
_sino[:, shift:] = comp_sino[:, shift:]
list_metric[i] = np.mean(
np.abs(np.fft.fftshift(fft.fft2(sino_sino)))*mask)
minpos = np.argmin(list_metric)
if minpos==0:
self.error_msg_1 = "!!! WARNING !!! Global minimum is out of "\
"the searching range. Please extend smin"
logging.warn(self.error_msg_1)
cu.user_message(self.error_msg_1)
if minpos==len(list_metric)-1:
self.error_msg_2 = "!!! WARNING !!! Global minimum is out of "\
"the searching range. Please extend smax"
logging.warn(self.error_msg_2)
cu.user_message(self.error_msg_2)
rot_centre = list_cor[minpos]
return rot_centre
def _fine_search(self, sino, start_cor, search_radius,
search_step, ratio, drop):
"""
Fine search for finding the rotation center.
"""
# Denoising
(nrow, ncol) = sino.shape
flip_sino = np.fliplr(sino)
search_radius = np.clip(np.abs(search_radius), 1, ncol//10 - 1)
search_step = np.clip(np.abs(search_step), 0.1, 1.1)
start_cor = np.clip(start_cor, search_radius, ncol - search_radius - 1)
cen_fliplr = (ncol - 1.0) / 2.0
list_cor = start_cor + np.arange(
-search_radius, search_radius + search_step, search_step)
comp_sino = np.flipud(sino) # Used to avoid local minima
list_metric = np.zeros(len(list_cor), dtype = np.float32)
mask = self._create_mask(2 * nrow, ncol, 0.5 * ratio * ncol, drop)
for i, cor in enumerate(list_cor):
shift = 2.0*(cor - cen_fliplr)
sino_shift = ndi.interpolation.shift(
flip_sino, (0, shift), order = 3, prefilter = True)
if shift>=0:
shift_int = np.int16(np.ceil(shift))
sino_shift[:,:shift_int] = comp_sino[:,:shift_int]
else:
shift_int = np.int16(np.floor(shift))
sino_shift[:,shift_int:] = comp_sino[:,shift_int:]
mat1 = np.vstack((sino, sino_shift))
list_metric[i] = np.mean(
np.abs(np.fft.fftshift(fft.fft2(mat1)))*mask)
min_pos = np.argmin(list_metric)
cor = list_cor[min_pos]
return cor
def _downsample(self, image, dsp_fact0, dsp_fact1):
"""
Downsample an image by averaging.
---------
Parameters: - image: 2D array.
- dsp_fact0: downsampling factor along axis 0.
- dsp_fact1: downsampling factor along axis 1.
---------
Return: - Downsampled image.
"""
(height, width) = image.shape
dsp_fact0 = np.clip(np.int16(dsp_fact0), 1, height//2)
dsp_fact1 = np.clip(np.int16(dsp_fact1), 1, width//2)
height_dsp = height//dsp_fact0
width_dsp = width//dsp_fact1
if (dsp_fact0 == 1) and (dsp_fact1 ==1):
image_dsp = image
else:
image_dsp = image[0:dsp_fact0*height_dsp,0:dsp_fact1*width_dsp]
image_dsp = image_dsp.reshape(
height_dsp,dsp_fact0,width_dsp,dsp_fact1).mean(-1).mean(1)
return image_dsp
def set_filter_padding(self, in_data, out_data):
padding = np.int16(self.parameters['average_radius'])
if padding>0:
in_data[0].padding = {'pad_multi_frames': padding}
def pre_process(self):
self.drop = np.int16(self.parameters['row_drop'])
self.smin, self.smax = np.int16(self.parameters['search_area'])
self.search_radius = np.float32(self.parameters['search_radius'])
self.search_step = np.float32(self.parameters['step'])
self.ratio = np.float32(self.parameters['ratio'])
self.est_cor = self.parameters['start_pixel']
self.broadcast_method = str(self.parameters['broadcast_method'])
self.error_msg_1 = ""
self.error_msg_2 = ""
self.error_msg_3 = ""
if not((self.broadcast_method == 'mean')
or (self.broadcast_method == 'median')
or (self.broadcast_method == 'linear_fit')
or (self.broadcast_method == 'nearest')):
self.error_msg_3 = "!!! WARNING !!! Selected broadcasting "\
"method is out of the list. Use the default option: 'median'"
logging.warn(self.error_msg_3)
cu.user_message(self.error_msg_3)
self.broadcast_method = 'median'
in_pData = self.get_plugin_in_datasets()[0]
data = self.get_in_datasets()[0]
starts,stops,steps = data.get_preview().get_starts_stops_steps()[0:3]
start_ind = starts[1]
stop_ind = stops[1]
step_ind = steps[1]
name = data.get_name()
pre_start = self.exp.meta_data.get(name + '_preview_starts')[1]
pre_stop = self.exp.meta_data.get(name + '_preview_stops')[1]
pre_step = self.exp.meta_data.get(name + '_preview_steps')[1]
self.origin_prev = np.arange(pre_start,pre_stop, pre_step)
self.plugin_prev = self.origin_prev[start_ind:stop_ind:step_ind]
def process_frames(self, data):
if len(data[0].shape)>2:
sino = np.mean(data[0],axis=1)
else:
sino = data[0]
(nrow, ncol) = sino.shape
dsp_row = 1
dsp_col = 1
if ncol>2000:
dsp_col = 4
if nrow>2000:
dsp_row = 2
# Denoising
# There's a critical reason to use different window sizes
# between coarse and fine search.
sino_csearch = ndi.gaussian_filter(sino, (3,1), mode='reflect')
sino_fsearch = ndi.gaussian_filter(sino, (2,2), mode='reflect')
sino_dsp = self._downsample(sino_csearch, dsp_row, dsp_col)
fine_srange = max(self.search_radius, dsp_col)
off_set = 0.5*dsp_col if dsp_col>1 else 0.0
if self.est_cor is None:
self.est_cor = (ncol-1.0)/2.0
else:
self.est_cor = np.float32(self.est_cor)
start_cor = np.int16(
np.floor(1.0 * (self.est_cor + self.smin) / dsp_col))
stop_cor = np.int16(
np.ceil(1.0 * (self.est_cor + self.smax) / dsp_col))
raw_cor = self._coarse_search(sino_dsp, start_cor, stop_cor,
self.ratio, self.drop)
cor = self._fine_search(
sino_fsearch, raw_cor*dsp_col + off_set, fine_srange,
self.search_step, self.ratio, self.drop)
return [np.array([cor]), np.array([cor])]
def post_process(self):
in_datasets, out_datasets = self.get_datasets()
cor_prev = out_datasets[0].data[...]
cor_broad = out_datasets[1].data[...]
cor_broad[:] = np.median(np.squeeze(cor_prev))
self.cor_for_executive_summary = np.median(cor_broad[:])
if self.broadcast_method == 'mean':
cor_broad[:] = np.mean(np.squeeze(cor_prev))
self.cor_for_executive_summary = np.mean(cor_broad[:])
if (self.broadcast_method == 'linear_fit') and (len(cor_prev)>1):
afact, bfact = | np.polyfit(self.plugin_prev, cor_prev[:,0], 1) | numpy.polyfit |
import unittest
from yauber_algo.errors import *
class ApplyTestCase(unittest.TestCase):
def test_percent_rank_category(self):
import yauber_algo.sanitychecks as sc
from numpy import array, nan, inf
import os
import sys
import pandas as pd
import numpy as np
from yauber_algo.algo import apply
#
# Function settings
#
algo = 'apply'
func = apply
with sc.SanityChecker(algo) as s:
#
# Check regular algorithm logic
#
s.check_regular(
array([nan, nan, 6, 7, 8, 9, 6]),
func,
(
array([3, 2, 1, 4, 3, 2, 1]),
3,
np.sum,
None, # category=
None, # return_as_cat=
True, # exclude_nan=
),
suffix='rolling'
)
s.check_regular(
array([nan, nan, 6, nan, nan, 9, 6]),
func,
(
array([3, 2, 1, 4, 3, 2, 1]),
3,
np.sum,
array([0, 0, 0, 1, 1, 1, 1]), # category=
None, # return_as_cat=
True, # exclude_nan=
),
suffix='category'
)
s.check_regular(
array([nan, nan, nan, nan, nan, nan, nan]),
func,
(
array([3, 2, 1, 4, 3, 2, 1]),
3,
np.sum,
array([0, 0, 0, 1, 1, 1, 1]), # category=
3, # return_as_cat=
True, # exclude_nan=
),
suffix='category_ret_as_cat_number_not_exists'
)
s.check_regular(
None,
func,
(
np.arange(0, 101),
3,
np.sum,
np.arange(0, 101),
3, # return_as_cat=
True, # exclude_nan=
),
suffix='category_more_than_100_unique_cats',
exception=YaUberAlgoArgumentError
)
s.check_regular(
array([nan, nan, 6, 6, 6, 6, 6]),
func,
(
array([3, 2, 1, 4, 3, 2, 1]),
3,
np.sum,
array([0, 0, 0, 1, 1, 1, 1]), # category=
0, # return_as_cat=
True, # exclude_nan=
),
suffix='category_exact'
)
s.check_regular(
array([nan, nan, 6, 6, 6, 6, 6]),
func,
(
array([3, 2, 1, nan, nan, nan, nan]),
3,
np.sum,
array([0, 0, 0, 1, 1, 1, 1]), # category=
0, # return_as_cat=
True, # exclude_nan=
),
suffix='category_ret_nan'
)
s.check_regular(
array([nan, nan, nan, nan, nan, nan, nan]),
func,
(
array([3, 2, 1, 4, 1, nan, nan]),
3,
np.sum,
array([0, 0, 0, 1, 1, 1, 1]), # category=
array([1, 1, 1, 1, 1, 1, 1]), # return_as_cat=
True, # exclude_nan=
),
suffix='category_ret_nan_if_arr_nan'
)
s.check_regular(
array([nan, nan, 6, 7, 8, 9, 6]),
func,
(
array([3, 2, 1, 4, 3, 2, 1]),
0,
np.sum,
None, # category=
None, # return_as_cat=
True, # exclude_nan=
),
suffix='zero_period',
exception=YaUberAlgoArgumentError,
)
s.check_regular(
array([nan, nan, 6, 7, 8, 9, 6]),
func,
(
array([3, 2, 1, 4, 3, 2, 1]),
-1,
np.sum,
None, # category=
None, # return_as_cat=
True, # exclude_nan=
),
suffix='neg_period',
exception=YaUberAlgoArgumentError,
)
s.check_regular(
func(array([3, 2, 1, 4, 3, 2, 1]), 3, np.sum),
func,
(
array([3, 2, 1, 4, 3, 2, 1]),
3,
np.sum,
array([1, 1, 1, 1, 1, 1, 1]), # category=
None, # return_as_cat=
True, # exclude_nan=
),
suffix='rolling_and_categorical_equal'
)
s.check_regular(
array([nan, nan, nan, nan, 8, 9, 6]),
func,
(
array([3, nan, 1, 4, 3, 2, 1]),
3,
np.sum,
None, # category=
None, # return_as_cat=
False, # exclude_nan=
),
suffix='rolling_not_exclude_nan'
)
#
# NAN / INF
#
#
s.check_naninf(
array([nan, nan, nan, nan, 8, 9, nan]),
func,
(
array([inf, nan, 1, 4, 3, 2, inf]),
3,
np.sum,
None, # category=
None, # return_as_cat=
False, # exclude_nan=
),
suffix='rolling'
)
s.check_naninf(
array([nan, nan, 1, 5, 8, 9, nan]),
func,
(
array([inf, nan, 1, 4, 3, 2, inf]),
3,
np.sum,
None, # category=
None, # return_as_cat=
True, # exclude_nan=
),
suffix='rolling_naninf_excluded'
)
s.check_series(
pd.Series(array([nan, nan, 6, 7, 8, 9, 6])),
func,
(
pd.Series(array([3, 2, 1, 4, 3, 2, 1])),
3,
np.sum,
None, # category=
None, # return_as_cat=
True, # exclude_nan=
),
suffix='rolling'
)
s.check_series(
pd.Series(array([nan, nan, 6, 7, 8, 9, 6])),
func,
(
pd.Series(array([3, 2, 1, 4, 3, 2, 1])),
3,
np.sum,
pd.Series(array([0, 0, 0, 0, 0, 0, 0])), # category=
None, # return_as_cat=
True, # exclude_nan=
),
suffix='categorical'
)
s.check_series(
pd.Series(array([nan, nan, 6, 7, 8, 9, 6])),
func,
(
pd.Series(array([3, 2, 1, 4, 3, 2, 1])),
3,
np.sum,
pd.Series(array([0, 0, 0, 0, 0, 0, 0])), # category=
pd.Series(array([0, 0, 0, 0, 0, 0, 0])), # return_as_cat=
True, # exclude_nan=
),
suffix='categorical_ret_as'
)
s.check_regular(
array([nan, nan, 6, 7, nan, nan, 6]),
func,
(
array([3, 2, 1, 4, 3, 2, 1]),
3,
np.sum,
array([0, 0, 0, 0, 1, 1, 1]), # category=
None, # return_as_cat=
True, # exclude_nan=
),
suffix='categorical'
)
s.check_naninf(
array([nan, nan, 6, nan, nan, nan, nan]),
func,
(
array([3, 2, 1, nan, 3, 2, inf]),
3,
np.sum,
array([0, 0, 0, 0, 1, 1, 1]), # category=
None, # return_as_cat=
True, # exclude_nan=
),
suffix='categorical'
)
s.check_naninf(
array([nan, nan, 6, nan, nan, nan, nan]),
func,
(
array([3, 2, 1, 2, 3, 2, 4]),
3,
np.sum,
array([0, 0, 0, inf, 1, 1, nan]), # category=
None, # return_as_cat=
True, # exclude_nan=
),
suffix='nan_for_category'
)
s.check_naninf(
array([nan, nan, 6, 6, 6, 6, 6]),
func,
(
array([3, 2, 1, 2, 3, 2, 4]),
3,
np.sum,
array([0, 0, 0, inf, 1, 1, nan]), # category=
0, # return_as_cat=
True, # exclude_nan=
),
suffix='return_as_cat_ignore_codex',
ignore_nan_argument_position_check=True,
)
s.check_naninf(
array([nan, nan, nan, nan, nan, 6, 6]),
func,
(
array([3, 2, 1, 2, 3, 2, nan]),
3,
np.sum,
array([0, 0, 1, inf, 1, 1, nan]), # category=
1, # return_as_cat=
True, # exclude_nan=
),
suffix='return_as_cat_non_NAN_if_reference_with_valid_window',
ignore_nan_argument_position_check=True,
)
s.check_naninf(
array([nan, nan, nan, nan, nan, 6, nan]),
func,
(
array([3, 2, 1, 2, 3, 2, nan]),
3,
np.sum,
array([0, 0, 1, inf, 1, 1, 1]), # category=
1, # return_as_cat=
True, # exclude_nan=
),
suffix='return_as_cat_NOT_ignore_codex_if_same_cat',
)
s.check_naninf(
array([nan, nan, nan, nan, nan, nan, nan]),
func,
(
array([3, 2, 1, 2, 3, 2, nan]),
3,
np.sum,
array([0, 0, 1, inf, 1, 1, nan]), # category=
0, # return_as_cat=
True, # exclude_nan=
),
suffix='return_as_cat_widows_less_period',
)
s.check_dtype_float(
array([nan, nan, 6, 7, 8, 9, 6], dtype=np.float),
func,
(
array([3, 2, 1, 4, 3, 2, 1], dtype=np.float),
3,
np.sum,
None, # category=
None, # return_as_cat=
True, # exclude_nan=
),
suffix='rolling'
)
s.check_dtype_float(
array([nan, nan, 6, 5, nan, nan, 9], dtype=np.float),
func,
(
array([3, 2, 1, 2, 3, 2, 4], dtype=np.float),
3,
np.sum,
array([0, 0, 0, 0, 1, 1, 1], dtype=np.float), # category=
None, # return_as_cat=
True, # exclude_nan=
),
suffix='category'
)
s.check_dtype_float(
array([nan, nan, 6, 5, 5, 5, 5], dtype=np.float),
func,
(
array([3, 2, 1, 2, 3, 2, 4], dtype=np.float),
3,
np.sum,
array([0, 0, 0, 0, 1, 1, 1], dtype=np.float), # category=
array([0, 0, 0, 0, 0, 0, 0], dtype=np.float),
True, # exclude_nan=
),
suffix='category_ret_as'
)
s.check_dtype_bool(
array([nan, nan, 3, 3, 3, 3, 3], dtype=np.float),
func,
(
array([1, 1, 1, 1, 1, 1, 1], dtype=np.bool),
3,
np.sum,
None, # category=
None, # return_as_cat=
True, # exclude_nan=
),
suffix='rolling'
)
s.check_dtype_bool(
array([nan, nan, 3, 3, nan, nan, 3], dtype=np.float),
func,
(
array([1, 1, 1, 1, 1, 1, 1], dtype=np.bool),
3,
np.sum,
array([0, 0, 0, 0, 1, 1, 1], dtype=np.bool), # category=
None, # return_as_cat=
True, # exclude_nan=
),
suffix='category'
)
s.check_dtype_bool(
array([nan, nan, 6, 5, 5, 5, 5], dtype=np.float),
func,
(
| array([3, 2, 1, 2, 3, 2, 4], dtype=np.float) | numpy.array |
import numpy as np
from skimage.filters import frangi, hessian
from skimage.data import camera
from skimage.util import crop
from skimage._shared.testing import (assert_equal, assert_almost_equal,
assert_allclose)
def test_null_matrix():
a = np.zeros((3, 3))
assert_almost_equal(frangi(a), np.zeros((3, 3)))
assert_almost_equal(frangi(a, black_ridges=False), np.zeros((3, 3)))
assert_equal(hessian(a), np.ones((3, 3)))
def test_energy_decrease():
a = np.zeros((5, 5))
a[2, 2] = 1.
assert frangi(a).std() < a.std()
assert frangi(a, black_ridges=False).std() < a.std()
assert hessian(a).std() > a.std()
def test_values_decreased():
a = np.multiply(np.ones((3, 3)), 10)
assert_equal(frangi(a), np.zeros((3, 3)))
assert_equal(hessian(a), np.ones((3, 3)))
def test_cropped_camera_image():
image = crop(camera(), ((206, 206), (206, 206)))
assert_allclose(frangi(image), | np.zeros((100, 100)) | numpy.zeros |
# Copyright 2021 Huawei Technologies Co., Ltd
#
# 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.
# ============================================================================
""" Operate on the dataset """
import os
import cv2
import mmcv
import numpy as np
from numpy import random
import mindspore.dataset as de
import mindspore.dataset.vision.c_transforms as C
from mindspore.mindrecord import FileWriter
from src.config import MEANS
from src.config import yolact_plus_resnet50_config as cfg
def pad_to_max(img, gt_bboxes, gt_label, crowd_boxes, gt_mask, instance_count, crowd_count):
pad_max_number = cfg['max_instance_count']
gt_box_new = np.pad(gt_bboxes, ((0, pad_max_number - instance_count), (0, 0)), mode="constant", constant_values=0)
crowd_box_new = np.pad(crowd_boxes, ((0, 10 - crowd_count), (0, 0)), mode="constant", constant_values=0)
gt_label_new = np.pad(gt_label, ((0, pad_max_number - instance_count)), mode="constant", constant_values=-1)
return img, gt_box_new, gt_label_new, crowd_box_new, gt_mask
def transpose_column(img, gt_bboxes, gt_label, crowd_boxes, gt_mask):
img_data = img.transpose(2, 0, 1).copy()
img_data = img_data.astype(np.float32)
gt_bboxes = gt_bboxes.astype(np.float32)
crowd_box_new = crowd_boxes.astype(np.float32)
gt_label = gt_label.astype(np.int32)
gt_mask_data = gt_mask.astype(np.bool)
return (img_data, gt_bboxes, gt_label, crowd_box_new, gt_mask_data)
def toPercentCoords(img, gt_bboxes, gt_label, num_crowds, gt_mask):
height, width, _ = img.shape
gt_bboxes[:, 0] /= width
gt_bboxes[:, 2] /= width
gt_bboxes[:, 1] /= height
gt_bboxes[:, 3] /= height
return (img, gt_bboxes, gt_label, num_crowds, gt_mask)
def imnormalize_column(img, gt_bboxes, gt_label, gt_num, gt_mask):
"""imnormalize operation for image"""
img_data = mmcv.imnormalize(img, [123.68, 116.78, 103.94], [58.40, 57.12, 57.38], True)
img_data = img_data.astype(np.float32)
return (img_data, gt_bboxes, gt_label, gt_num, gt_mask)
def backboneTransform(img, gt_bboxes, gt_label, num_crowds, gt_mask):
c = BackboneTransform()
img_data = c(img)
return (img_data, gt_bboxes, gt_label, num_crowds, gt_mask)
class BackboneTransform():
"""
Transforms a BRG image made of floats in the range [0, 255] to whatever
input the current backbone network needs.
transform is a transform config object (see config.py).
in_channel_order is probably 'BGR' but you do you, kid.
"""
def __init__(self):
self.mean = np.array((103.94, 116.78, 123.68), dtype=np.float32)
self.std = np.array((57.38, 57.12, 58.40), dtype=np.float32)
self.channel_map = {c: idx for idx, c in enumerate('BGR')}
self.channel_permutation = [self.channel_map[c] for c in 'RGB']
def __call__(self, img):
img = img.astype(np.float32)
img = (img - self.mean) / self.std
img = img[:, :, self.channel_permutation]
return img.astype(np.float32)
def resize_column(img, gt_bboxes, gt_label, num_crowds, gt_mask, resize_gt=True):
"""resize operation for image"""
img_data = img
img_data, w_scale, h_scale = mmcv.imresize(
img_data, (cfg['img_width'], cfg['img_height']), return_scale=True)
if resize_gt:
scale_factor = np.array(
[w_scale, h_scale, w_scale, h_scale], dtype=np.float32)
img_shape = (cfg['img_height'], cfg['img_width'], 1.0)
img_shape = np.asarray(img_shape, dtype=np.float32)
gt_bboxes = gt_bboxes * scale_factor
gt_bboxes[:, 0::2] = np.clip(gt_bboxes[:, 0::2], 0, img_shape[1] - 1) # x1, x2 [0, W-1]
gt_bboxes[:, 1::2] = np.clip(gt_bboxes[:, 1::2], 0, img_shape[0] - 1) # y1, y2 [0, H-1]
gt_mask_data = np.array([
mmcv.imresize(mask, (cfg['img_width'], cfg['img_height']), interpolation='nearest')
for mask in gt_mask])
w = gt_bboxes[:, 2] - gt_bboxes[:, 0]
h = gt_bboxes[:, 3] - gt_bboxes[:, 1]
keep = (w > cfg['discard_box_width']) * (h > cfg['discard_box_height'])
gt_mask_data = gt_mask_data[keep]
gt_bboxes = gt_bboxes[keep]
gt_label = gt_label[keep]
num_crowds[0] = (gt_label < 0).sum()
return (img_data, gt_bboxes, gt_label, num_crowds, gt_mask_data)
def randomMirror(image, boxes, gt_label, num_crowds, masks):
_, width, _ = image.shape
if random.randint(2):
image = image[:, ::-1]
masks = masks[:, :, ::-1]
boxes = boxes.copy()
boxes[:, 0::2] = width - boxes[:, 2::-2]
return image, boxes, gt_label, num_crowds, masks
def randomSampleCrop(image, boxes, gt_label, num_crowds, masks):
"""Random Crop the image and boxes"""
height, width, _ = image.shape
while True:
min_iou = np.random.choice([None, 0.1, 0.3, 0.7, 0.9])
if min_iou is None:
return image, boxes, gt_label, num_crowds, masks
# max trails (50)
for _ in range(50):
image_t = image
w = _rand(0.3, 1.0) * width
h = _rand(0.3, 1.0) * height
# aspect ratio constraint b/t .5 & 2
if h / w < 0.5 or h / w > 2:
continue
left = _rand() * (width - w)
top = _rand() * (height - h)
rect = np.array([int(left), int(top), int(left + w), int(top + h)])
overlap = jaccard_numpy(boxes, rect)
if overlap.min() < min_iou and overlap.max() > (min_iou + 0.2):
continue
# cut the crop from the image
image_t = image_t[rect[1]:rect[3], rect[0]:rect[2], :]
centers = (boxes[:, :2] + boxes[:, 2:4]) / 2.0
m1 = (rect[0] < centers[:, 0]) * (rect[1] < centers[:, 1])
m2 = (rect[2] > centers[:, 0]) * (rect[3] > centers[:, 1])
# mask in that both m1 and m2 are true
mask = m1 * m2
crowd_mask = np.zeros(mask.shape, dtype=np.int32)
if num_crowds[0] > 0:
crowd_mask[-num_crowds[0]:] = 1
# have any valid boxes? try again if not
# Also make sure you have at least one regular gt
if not mask.any() or np.sum(1 - crowd_mask[mask]) == 0:
continue
masks_t = masks[mask, :, :].copy()
# # take only matching gt labels
# take only matching gt boxes
boxes_t = boxes[mask, :].copy()
labels_t = gt_label[mask]
if num_crowds[0] > 0:
num_crowds[0] = np.sum(crowd_mask[mask])
boxes_t[:, :2] = np.maximum(boxes_t[:, :2], rect[:2])
boxes_t[:, :2] -= rect[:2]
boxes_t[:, 2:4] = np.minimum(boxes_t[:, 2:4], rect[2:4])
boxes_t[:, 2:4] -= rect[:2]
masks_t = masks_t[:, rect[1]:rect[3], rect[0]:rect[2]]
return (image_t, boxes_t, labels_t, num_crowds, masks_t)
def expand_column(img, gt_bboxes, gt_label, num_crowds, gt_mask):
"""expand operation for image"""
expand = Expand(MEANS)
img, gt_bboxes, gt_label, gt_mask = expand(img, gt_bboxes, gt_label, gt_mask)
return (img, gt_bboxes, gt_label, num_crowds, gt_mask)
class Expand():
"""expand image"""
def __init__(self, mean):
self.mean = mean
def __call__(self, img, boxes, labels, mask):
if random.randint(2):
return img, boxes, labels, mask
h, w, c = img.shape
ratio = random.uniform(1, 4)
expand_img = np.full((int(h * ratio), int(w * ratio), c),
self.mean).astype(img.dtype)
left = int(random.uniform(0, w * ratio - w))
top = int(random.uniform(0, h * ratio - h))
expand_img[top:top + h, left:left + w] = img
img = expand_img
# Deal with bounding box
boxes += np.tile((left, top), 2)
mask_count, mask_h, mask_w = mask.shape
expand_mask = np.zeros((mask_count, int(mask_h * ratio), int(mask_w * ratio))).astype(mask.dtype)
expand_mask[:, top:top + h, left:left + w] = mask
mask = expand_mask
return img, boxes, labels, mask
def photoMetricDistortion(img, gt_bboxes, gt_label, num_crowds, gt_mask):
c = PhotoMetricDistortion()
img, gt_bboxes, gt_label = c(img, gt_bboxes, gt_label)
return (img, gt_bboxes, gt_label, num_crowds, gt_mask)
class PhotoMetricDistortion:
"""Photo Metric Distortion"""
def __init__(self,
brightness_delta=32,
contrast_range=(0.5, 1.5),
saturation_range=(0.5, 1.5),
hue_delta=18):
self.brightness_delta = brightness_delta
self.contrast_lower, self.contrast_upper = contrast_range
self.saturation_lower, self.saturation_upper = saturation_range
self.hue_delta = hue_delta
def __call__(self, img, boxes, labels):
# random brightness
img = img.astype('float32')
if random.randint(2):
delta = random.uniform(-self.brightness_delta,
self.brightness_delta)
img += delta
# mode == 0 --> do random contrast first
# mode == 1 --> do random contrast last
mode = | random.randint(2) | numpy.random.randint |
# A module to interpolate Live Ocean results onto Salish Sea NEMO grid and
# save boundary forcing files.
# <NAME>, August 2016
# <EMAIL>
import netCDF4 as nc
import xarray as xr
import numpy as np
import datetime
from scipy import interpolate
import mpl_toolkits.basemap as Basemap
import glob
import os
import sys
import re
import subprocess as sp
from salishsea_tools import gsw_calls
# Special python module provided by Parker MacCready
from salishsea_tools import LiveOcean_grid as grid
# -------Main function to generate boundary files from command line--------
# Example: python LiveOcean_BCs '2016-08-30'
def create_files_for_nowcast(date, teos_10=True):
"""Create boundary files from Live Ocean results for use in nowcast,
forecast and forecast2.
:arg str date: the LiveOcean rundate in format yyyy-mm-dd
:arg teos_10: specifies that temperature and salinity are saved in
teos-10 variables if true. If true, temperature is saved as
Conservative Temperature and salinity is Reference Salinity.
If false, temperature is saved as Potential Temperature and
salinity is Practical Salinity
:type teos_10: boolean
"""
save_dir = '/results/forcing/LiveOcean/boundary_conditions/'
LO_dir = '/results/forcing/LiveOcean/downloaded/'
create_LiveOcean_TS_BCs(date, date, '1H', 'daily',
nowcast=True,
teos_10=teos_10,
bc_dir=save_dir, LO_dir=LO_dir)
# ---------------------- Interpolation functions ------------------------
def load_SalishSea_boundary_grid(
fname=('/data/nsoontie/MEOPAR/NEMO-forcing/open_boundaries/west/'
'SalishSea_west_TEOS10.nc'),
):
"""Load the Salish Sea NEMO model boundary depth, latitudes and longitudes.
:arg fname str: name of boundary file
:returns: numpy arrays depth, lon, lat and a tuple shape
"""
f = nc.Dataset(fname)
depth = f.variables['deptht'][:]
lon = f.variables['nav_lon'][:]
lat = f.variables['nav_lat'][:]
shape = lon.shape
return depth, lon, lat, shape
def load_LiveOcean(files, resample_interval='1H'):
"""Load a time series of Live Ocean results represented by a list of files.
Time series is resampled by averaging over resample_interval.
Default is 1 hour.
:arg files: Live Ocean filenames
:type files: list of strings
:arg str resample_interval: interval for resampling based on pandas values.
e.g. 1H is one hour, 7D is seven days, etc
:returns: xarray dataset of Live Ocean results
"""
# Loop through files and load
d = xr.open_dataset(files[0])
for f in files[1:]:
with xr.open_dataset(f) as d1:
# drop uncommon variables - subfunction?
d, d1 = _remove_uncommon_variables_or_coords(d, d1)
d = xr.concat([d, d1], dim='ocean_time', data_vars='minimal')
# Determine z-rho (depth)
G, S, T = grid.get_basic_info(files[0]) # note: grid.py is from Parker
z_rho = np.zeros(d.salt.shape)
for t in np.arange(z_rho.shape[0]):
zeta = d.zeta.values[t, :, :]
z_rho[t, :, :, :] = grid.get_z(G['h'], zeta, S)
# Add z_rho to dataset
zrho_DA = xr.DataArray(z_rho, dims=['ocean_time', 's_rho',
'eta_rho', 'xi_rho'],
coords={'ocean_time': d.ocean_time.values[:],
's_rho': d.s_rho.values[:],
'eta_rho': d.eta_rho.values[:],
'xi_rho': d.xi_rho.values[:]},
attrs={'units': 'metres',
'positive': 'up',
'long_name': 'Depth at s-levels',
'field': 'z_rho ,scalar'})
d = d.assign(z_rho=zrho_DA)
# Resample
d = d.resample(resample_interval, 'ocean_time')
return d
def _remove_uncommon_variables_or_coords(d, d1, remove_type='variables'):
"""Removes uncommon variables or coordinates between two xarray datasets
:arg d: First dataset
:type d: xarray dataset
:arg d1: Second dataset
:type d1: xarray dataset
:arg str remove_type: the type to be removed. Either 'variables'
or 'coordinates'.
:returns: two new datasets with uncommon variables/coordinates removed
"""
if remove_type == 'variables':
d1list = d1.data_vars
dlist = d.data_vars
elif remove_type == 'coords':
d1list = d1.coords
dlist = d.coords
diff = set(dlist) ^ set(d1list)
rm_d1 = set(d1list) & diff
rm_d = set(dlist) & diff
return d.drop(list(rm_d)), d1.drop(list(rm_d1))
def interpolate_to_NEMO_depths(dataset, NEMO_depths, var_names):
""" Interpolate variables in var_names from a Live Ocean dataset to NEMO
depths. LiveOcean land points (including points lower than bathymetry) are
set to np.nan and then masked.
:arg dataset: Live Ocean dataset
:type dataset: xarray Dataset
:arg NEMO_depths: NEMO model depths
:type NEMO_depths: 1D numpy array
:arg var_names: list of Live Ocean variable names to be interpolated,
e.g ['salt', 'temp']
:type var_names: list of str
:returns: dictionary continaing interpolated numpy arrays for each variable
"""
interps = {}
for var_name in var_names:
var_interp = np.zeros(dataset[var_name].shape)
for t in np.arange(var_interp.shape[0]):
for j in np.arange(var_interp.shape[2]):
for i in np.arange(var_interp.shape[3]):
LO_depths = dataset.z_rho.values[t, :, j, i]
var = dataset[var_name].values[t, :, j, i]
var_interp[t, :, j, i] = np.interp(-NEMO_depths,
LO_depths, var,
left=np.nan)
# NEMO depths are positive, LiveOcean are negative
interps[var_name] = np.ma.masked_invalid(var_interp)
return interps
def fill_NaNs_with_nearest_neighbour(data, lons, lats):
"""At each depth level and time, fill in NaN values with nearest lateral
neighbour. If the entire depth level is NaN, fill with values from level
above. The last two dimensions of data are the lateral dimensions.
lons.shape and lats.shape = (data.shape[-2], data.shape[-1])
:arg data: the data to be filled
:type data: 4D numpy array
:arg lons: longitude points
:type lons: 2D numpy array
:arg lats: latitude points
:type lats: 2D numpy array
:returns: a 4D numpy array
"""
filled = data.copy()
for t in np.arange(data.shape[0]):
for k in np.arange(data.shape[1]):
subdata = data[t, k, :, :]
mask = | np.isnan(subdata) | numpy.isnan |
import random
import numpy as np
def bits2int(bits):
"""
Convert an array of bits to integer
"""
r = 0
s = 1
for b in bits:
if b & 1:
r += s
s <<= 1
return r
def parity(v):
"""
Count number of '1' (modulo 2) in binary representation of 'v'
"""
return bin(v).count('1') & 1
def normalize_state(state):
"""
Normalize a quantum state
The norm of the state is equal to unity, and the first nonzero element
is real and positive.
"""
norm = | np.linalg.norm(state) | numpy.linalg.norm |
import os
import sys
import time
import numpy as np
import imgaug # https://github.com/aleju/imgaug (pip3 install imgaug)
import json
import skimage
import cv2
from mrcnn import visualize
from PIL import ImageEnhance
import matplotlib.pyplot as plt
from mrcnn.config import Config
from mrcnn import model as modellib, utils
class lp_Config(Config):
NAME = "plate"
IMAGES_PER_GPU = 1
NUM_CLASSES =2 # COCO has 80 classes
STEPS_PER_EPOCH = 100
BACKBONE = 'resnet101'
GPU_COUNT = 1
IMAGES_PER_GPU = 1
IMAGE_MIN_DIM = int(480)
IMAGE_MAX_DIM = int(640)
RPN_ANCHOR_SCALES = (16,24,32,48,64)
RPN_ANCHOR_RATIOS = [ 1, 3,6 ]
MEAN_PIXEL = np.array([123.7, 116.8, 103.9])
DETECTION_NMS_THRESHOLD =0.5
DETECTION_MIN_CONFIDENCE = 0.5
RPN_NMS_THRESHOLD = 0.5
TRAIN_ROIS_PER_IMAGE = 200
RPN_TRAIN_ANCHORS_PER_IMAGE=256
class char_Config(Config):
NAME = "char"
IMAGES_PER_GPU = 1
NUM_CLASSES =34 # COCO has 80 classes
STEPS_PER_EPOCH = 100
BACKBONE = 'resnet101'
GPU_COUNT = 1
IMAGES_PER_GPU = 1
RPN_NMS_THRESHOLD = 0.5
DETECTION_MIN_CONFIDENCE = 0
DETECTION_NMS_THRESHOLD = 0.6
IMAGE_MIN_DIM = int(256)
IMAGE_MAX_DIM = int(640)
def space_NMS(box_a,box_b):#((x1,y1),(x2,y2))
width_a=abs(box_a[0][0]-box_a[1][0])
width_b=abs(box_b[0][0]-box_b[1][0])
height_a=abs(box_a[0][1]-box_a[1][1])
height_b=abs(box_b[0][1]-box_b[1][1])
size_a=width_a*height_a
size_b=width_b*height_b
start_x=max(box_a[0][0],box_b[0][0])
end_x=min(box_a[1][0],box_b[1][0])
start_y = max(box_a[0][1], box_b[0][1])
end_y= min(box_a[1][1], box_b[1][1])
#size_b = (box_b[2] - box_b[0]) * (box_b[3] - box_b[1])
center_a=((box_a[0][0]+box_a[1][0])/2,(box_a[0][1]+box_a[1][1])/2)
center_b=((box_b[0][0]+box_b[1][0])/2,(box_b[0][1]+box_b[1][1])/2)
if start_x>end_x or start_y>end_y:
#no overlap
#print(center_a,center_b)
return False
else:
# overlapsize=((width_a+width_b)-2*(abs(center_a[0]-center_b[0])))*((height_a+height_b)-2*(abs(center_a[1]-center_b[1])))
# overlapsize=(0.5*(width_a+width_b)-(center_b[0]-center_a[0]))*(0.5*(height_a+height_b)-(center_b[1]-center_a[1]))
overlapsize=abs(end_x-start_x)*abs(end_y-start_y)
#print("overlapsize: ", overlapsize, " size_b: ", size_b)
if overlapsize>=0.7*size_b or overlapsize>=0.7*size_a:
return True
else:
return False
def aggregate(line,labels,scores,boxs,h_thershold):
opt_label=[]
temps=[]
#print(line,labels,scores,boxs)
sum_score = 0
while(len(line)):
mark = []
pos=line[0][0]
label=labels[0]
score=scores[0]
box=boxs[0]
#mark.append(0)
for i in range(1,len(line),1):
if not space_NMS(box,boxs[i]):
mark.append(i)
elif scores[i]>score:
#print("label: ", label)
label=labels[i]
score=scores[i]
else:
#print("label: ",labels[i])
continue
newline=[]
newlabels=[]
newscores=[]
newbox=[]
#print(mark)
for i in mark:
newline.append(line[i])
newlabels.append(labels[i])
newscores.append(scores[i])
newbox.append(boxs[i])
line=newline
labels=newlabels
scores=newscores
boxs=newbox
sum_score +=score
temps.append((pos,label))
#mark.clear()
temps.sort(key=lambda tu:tu[0])
for t in temps:
opt_label.append(t[1])
return opt_label,sum_score
import skimage.transform as st
import math
def find_line(point_img):
h, theta, d = st.hough_line(point_img)
k = -1
# in same theata the difference of d should less than the thersehold
b_sum = 9999
for j in range(h.shape[1]): # d
all_dis = h[:, j]
previous = -1
alldis = []
for i in range(len(all_dis)):
apperance = all_dis[i]
while (apperance):
alldis.append(d[i])
apperance -= 1
temp_d = alldis[0]
sum = 0
for i in range(1, len(alldis), 1):
sum += abs(alldis[i] - alldis[i - 1])
temp_d+=alldis[i]
if sum < b_sum:
k = theta[j]
b = temp_d/len(alldis)
b_sum = sum
return k,b
def Seperate_V(centers, imgsize, boxs, scores, labels):
output_lines = []
output_labels = []
output_boxs = []
output_scores = []
if (len(centers) < 2):
return output_lines, output_labels, output_scores, output_boxs
point_img = np.zeros((imgsize[0], imgsize[1]))
for center in centers:
point_img[int(center[1]), int(center[0])] = 255
# cv2.imshow(" ", point_img)
# cv2.waitKey(0)
h, theta, d = st.hough_line(point_img)
k = -1
b = []
# in same theata the difference of d should less than the thersehold
first_line = []
second_line = []
average = 9999
left = list(range(0, 60, 1))
right = list(range(120, 180, 1))
pos_angle = left + right
# 在可能的角度内去寻找一个最窄的range
# print(pos_angle)
# print(theta/(3.141592658)*180)
#for j in range(h.shape[1]):
for j in pos_angle:
all_dis = h[:, j]
previous = -1
alldis = []
for i in range(len(all_dis)):
apperance = all_dis[i]
while (apperance):
alldis.append(d[i])
apperance -= 1
th = 2 # 不允许超过0.1
count = 0
#print("alldis",alldis)
temp_d = [alldis[0]]
sum = 0
for i in range(1, len(alldis), 1):
sum += abs(alldis[i] - alldis[i - 1])
if abs(alldis[i] - alldis[i - 1]) > th:
temp_d.append(alldis[i])
count += 1
temp_average = sum / len(alldis)
if count <= 1 and temp_average < average:
k = theta[j]
b = temp_d
average = temp_average
# if count<=1:
# #print(j,temp_d)
# k=j
# b=temp_d
# break
print(k,b)
if not len(b):
return output_lines, output_labels, output_scores, output_boxs
if len(b) == 1:
output_lines = [centers]
output_boxs = [boxs]
output_labels = [labels]
output_scores = [scores]
else:
if k == 0:
k = 1
cos = math.cos(k)
sin = math.sin(k)
output_lines = [[], []]
output_labels = [[], []]
output_boxs = [[], []]
output_scores = [[], []]
for i in range(len(centers)):
# print(cos/sin*i[0]+b[0]/sin,cos/sin*i[0]+b[1]/sin)
if abs(centers[i][1] + cos / sin * centers[i][0] - b[0] / sin) > abs(
centers[i][1] + cos / sin * centers[i][0] - b[1] / sin):
output_lines[0].append(centers[i])
output_labels[0].append(labels[i])
output_boxs[0].append(boxs[i])
output_scores[0].append(scores[i])
else:
output_lines[1].append(centers[i])
output_labels[1].append(labels[i])
output_boxs[1].append(boxs[i])
output_scores[1].append(scores[i])
#以下分别对上下两排的边缘进行检测
check=[]
for index in range(len(output_lines)):
all=[]
chas=[]
for i in range(len(output_lines[index])):
temp=[output_lines[index][i],output_labels[index][i],output_boxs[index][i],output_scores[index][i]]
all.append(temp)
if len(all)<3:
check.append(all)
continue
#all=zip(line,label,box,score)
all.sort(key=lambda p:p[0][0])
# 去除明显高度不对的box
# average_heights=sum(t[2][1][1]-t[2][0][1] for t in all )/len(all)
# for t in all:
#NMS
mark=[]
prev = all[0]
for k in range(1,len(all),1):
now=all[k]
if space_NMS(now[2],prev[2]):
if now[3]>prev[3]:
mark.append(k-1)
prev=now
else:
mark.append(k)
else:
prev=now
new=[]
for i in range(len(all)):
if not i in mark:
new.append(all[i])
all=new
left=None
right=None
print(all)
if (all[0][1]=='1' or all[0][1]=='J' or all[0][1]=='Y' or all[0][1]=='T' or all[0][1]=='7'):
left=all[0]
if all[len(all)-1][1]=='1' or all[len(all)-1][1]=='J' or all[len(all)-1][1]=='Y' or all[len(all)-1][1]=='T' or all[len(all)-1][1]=='7':
right=all[len(all)-1]
start=0
end=len(all)
if left:
start=1
if right:
end=len(all)-1
center=all[start:end]
if len(center)<2:
check.append(all)
continue
average_height = | np.sum(t[2][1][1] - t[2][0][1] for t in center) | numpy.sum |
import numpy as np
import pandas as pd
import os
from matplotlib import pyplot as plt
import requests, json
from pprint import pprint
from IPython.core.debugger import set_trace
from tqdm import tqdm
import warnings
warnings.filterwarnings("ignore")
import random
import numpy as np
# from scout import *
random.seed(11)
np.random.seed(11)
# For each FPL Manager
'''
This is the transfer simulator code
'''
class BaseSimulator():
# this part of the simulator is for every interaction between agent's action and environment
def __init__(self, state_dim , action_dim ):
self.state = None
# self.action = None
self.state_dim = state_dim
self.action_dim = action_dim
def reset(self):
'''
Returns a random state vector
'''
# self.state = np.random.randn(self.state_dim) # (N,)
# self.state = self.state / np.linalg(self.state)
# self.state = self.actual_player_ids
self.state = self.create_one_hot_embedding(self.actual_players_ids)
self.state = self.state[:,0] # first week
return self.state
def create_one_hot_embedding(self, player_ids):
# self.all_player_ids # (620,)
# player_ids # (15,10)
# for axis = 0 every value is repeated so comp1[0] = 0, comp1[1] = 1 . . .
comp1 = np.broadcast_to(self.all_player_ids[:,np.newaxis,np.newaxis], (self.all_player_ids.shape[0],) + player_ids.shape) # (620,15,10)
comp2 = np.broadcast_to(player_ids[np.newaxis,:,:], (self.all_player_ids.shape[0],) + player_ids.shape) # (620,15,10)
comp_mask = comp1 == comp2 # (620,15,10)
comp_mask = comp_mask.sum(axis = 1) # (620,10)
assert(np.all(comp_mask.astype(np.int) <= 1))
assert(comp_mask.shape == (self.all_player_ids.shape[0], player_ids.shape[1])) # (620,10) one hot encoded
return comp_mask
# def step(self, action:np.ndarray, week_idx:int = 0):
# '''
# action : ndarray shape:(N,). this is passed to get_transfer_in / out function to get the in/out players
# week_idx : int
# '''
# #writing dummy code for now just to simulate
# # 1. the recruiter has already given us a profile which is the action
# # 2. find a transfer_in players which considers this profile
# # 3. find transfer_out_players
# # 4. do the transfer
# # new_team_player_ids = np.array(self.running_player_ids)
# # print(self.all_player_points.shape, self.running_player_ids.shape)
# running_player_points = self.get_player_info_matrix(self.all_player_points, self.running_player_ids)
# # the action here has to instigate a transfer. lets do random for now independant of action #TODO: change this code
# sample_transfer_ins = self.get_swapped_in_players_test(self.running_player_ids, game_week = week_idx)
# self.transfers_in_episode.append(sample_transfer_ins) # IMP : this step is needed but change this to the actual transfer
# self.running_player_ids, new_running_player_points, _ = self.do_transfer(sample_transfer_ins, self.running_player_ids)
# self.state = self.create_one_hot_embedding(self.running_player_ids) # IMP : this step is needed
# self.state = self.state[:,week_idx]
# rewards = self.compute_rewards_matrix(running_player_points, new_running_player_points)
# r = rewards[week_idx]
# done = True if week_idx == (self.current_week-1) else False
# return self.state, r, done
def step(self, action_idx:int, week_idx:int = 0, scout=None):
'''
action : int. this is passed to get_transfer_in / out function to get the in/out players
week_idx : int
scout : the scout class object
'''
# 1. the recruiter has already given us a profile which is the action
# 2. find a transfer_in players which considers this profile
# 3. find transfer_out_players
# 4. do the transfer
# new_team_player_ids = np.array(self.running_player_ids)
# print(self.all_player_points.shape, self.running_player_ids.shape)
prev_running_player_points = self.get_player_info_matrix(self.all_player_points, self.running_player_ids)
# the action here has to instigate a transfer. lets do random for now independant of action #TODO: change this code
# sample_transfer_ins = self.get_swapped_in_players_test(self.running_player_ids, game_week = week_idx)
out_ids = scout.find_transfer_out_candidates()
# in_ids = np.array([1,3,4,5,6,101,200,330,500,600])
in_ids = scout.find_transfer_in_candidates(action_idx,out_ids)
sample_transfer_ins, self.balance = scout.get_transfer_in_out_players(in_ids, out_ids)
self.transfers_in_episode.append(sample_transfer_ins) # IMP : this step is needed but change this to the actual transfer
self.running_player_ids, self.running_player_points, self.running_player_cost = self.do_transfer(sample_transfer_ins, self.running_player_ids)
self.state = self.create_one_hot_embedding(self.running_player_ids) # IMP : this step is needed
self.state = self.state[:,week_idx]
rewards = self.compute_rewards_matrix(prev_running_player_points, self.running_player_points)
r = rewards[week_idx]
done = True if week_idx == (self.current_week-1) else False
return self.state, r, done
# 7. we need to have rewards in the simulator (check the diagram in the progress report)
def compute_rewards_matrix(self, before_team_points , after_team_points):
'''
before_team_points : Team before transfer , ndarray shape: (15,10)
after_team_points : Team after the transfer : (15,10)
returns : reward : ndarray . shape (10,)
'''
rewards = np.repeat(-1, self.current_week) # (10,)
rewards = after_team_points.sum(axis=0) - before_team_points.sum(axis=0)
rewards[rewards <= 0] = -1 # play with these values too. TODO. check the fpl docs too
rewards[rewards > 0] = 0
return rewards
class FPLSimulator(BaseSimulator):
def __init__(self, current_week, fpl_manager_id, req_cols = [], state_dim = 10, action_dim = 5, balance= 100):
super(FPLSimulator, self).__init__(state_dim, action_dim)
self.current_week = current_week
self.fpl_manager_id = fpl_manager_id
self.balance = balance
self.all_player_ids = None
self.all_player_cost = None
self.all_player_points = None
self.all_player_other_data_cols = req_cols
self.all_player_other_data = None
self.actual_players_ids = None
self.actual_players_points = None
self.actual_player_cost = None
self.actual_player_other_data = None
self.transfers_in_episode = []
self.running_player_ids = None
self.running_player_cost = None
self.running_player_points = None
self.all_week_data = None
self.init_fpl_team()
def reset(self):
self.transfers_in_episode = []
self.running_player_ids = np.array(self.actual_players_ids)
self.running_player_points = np.array(self.actual_players_points)
self.running_player_cost = np.array(self.actual_player_cost)
self.balance = 100
return super(FPLSimulator, self).reset()
def init_fpl_team(self):
#1. load from the CSV
self.all_week_data = self.load_all_player_weekwise_data(self.current_week)
#2. get the team
self.actual_players_ids = self.get_players_of_manager(self.fpl_manager_id, self.current_week) # (15, W)
#3. creating the ids, points and cost for all players
#creating a dummy cost matrix for now
self.all_player_ids = np.unique(np.concatenate([np.unique(self.all_week_data[i].index) for i in range(len(self.all_week_data))])) # (620,)
# self.all_player_cost = np.random.normal(5, 1, size=(self.all_player_ids.shape[0], len(self.all_week_data))).round(2) # (620,10)
self.all_player_cost = self.load_all_player_cost_from_csv() # (620,10)
self.all_player_points = np.zeros((self.all_player_ids.shape[0], len(self.all_week_data)))
self.all_player_points, self.all_player_other_data = self.get_data_for_all_players(self.all_week_data, self.all_player_ids)
print(self.all_player_ids.shape, self.all_player_points.shape, self.all_player_cost.shape, self.all_player_other_data.shape) # this is our universe
# actual_players_points = get_points_for_players(self.all_week_data, actual_players_ids) # (15,W) before code
#4. creating the ids, points and cost for actual players
self.actual_players_points = self.get_player_info_matrix(self.all_player_points, self.actual_players_ids)
per_week_total_points = self.actual_players_points.sum(axis=0) #(W,)
print('cumsum of per_week_total_points: ',np.cumsum(per_week_total_points))
self.actual_player_cost = self.get_player_info_matrix(self.all_player_cost, self.actual_players_ids)
self.actual_player_other_data = []
for i in range(len(self.all_player_other_data_cols)):
self.actual_player_other_data.append(self.get_player_info_matrix(self.all_player_other_data[i], self.actual_players_ids))
self.actual_player_other_data = np.array(self.actual_player_other_data)
print(self.actual_players_ids.shape, self.actual_players_points.shape, self.actual_player_cost.shape, self.actual_player_other_data.shape) # this is our tuple
self.running_player_ids = np.array(self.actual_players_ids)
self.running_player_points = np.array(self.actual_players_points)
self.running_player_cost = np.array(self.actual_player_cost)
return
def load_from_csv_player_types(self):
df_type = pd.read_csv("player_types.csv", index_col=0)
df_type = df_type.set_index("id")
return df_type
def load_all_player_weekwise_data(self, current_week:int):
'''
returns list of dataframes (W,)
'''
# Get the static data and append to each week's data
base_url = 'https://fantasy.premierleague.com/api/'
# get data from bootstrap-static endpoint
r = requests.get(base_url+'bootstrap-static/').json()
df_static = pd.DataFrame(r['elements'])
cols = ['id', 'selected_by_percent']
df_static = df_static[cols]
all_week_data = []
player_types_df = self.load_from_csv_player_types()
for week in range(1,current_week+1):
df = pd.read_csv("Players_Weekwise/week_"+str(week)+".csv")
df = df.merge(df_static, how='left', on='id')
df = df.set_index('id')
df = df.join(player_types_df, on='id', how='left')
#df = df[['stats.total_points'] + self.all_player_other_data_cols]
df['saves_goal_conceded_ratio'] = df['stats.saves']/df['stats.goals_conceded']
df = df.fillna(0)
all_week_data.append(df)
return all_week_data
def load_all_player_cost_from_csv(self):
all_player_cost = pd.read_csv("Player_Cost_Weekwise/all_player_costs.csv")
all_player_cost = all_player_cost.T.iloc[1:,:self.current_week]
all_player_cost.index = all_player_cost.index.map(int)
res = all_player_cost.loc[self.all_player_ids,:] # (620,10)
# print(np.array(res.head()))
return np.array(res)
# def get_points_for_players(all_week_data: list, player_ids : np.ndarray):
# '''
# player_ids : (15,W) player ids for W game weeks
# returns : (15,W) ndarray of player points
# '''
# assert(len(all_week_data) == player_ids.shape[1])
# players_points = []
# for i in range(len(all_week_data)):
# players_points.append(all_week_data[i].loc[player_ids[:,i], :]['stats.total_points'])
# return np.array(players_points).T
# def get_points_for_all_players(self, all_week_data: list, player_ids : np.ndarray):
# all_player_points = np.zeros((self.all_player_ids.shape[0], len(all_week_data)))
# for i in range(len(all_week_data)):
# # cur_player_ids = np.unique(np.array(all_week_data[i].index))
# cur_player_ids = np.unique(np.array(all_week_data[i].index)) # (N,)
# act_P_reshaped = np.broadcast_to(cur_player_ids[:,np.newaxis], (cur_player_ids.shape[0],self.all_player_ids.shape[0])) # (N, 620)
# all_P_reshaped = np.broadcast_to(self.all_player_ids[np.newaxis, :], (cur_player_ids.shape[0],self.all_player_ids.shape[0]) )# (N,620)
# match_idx = np.argwhere(act_P_reshaped == all_P_reshaped) # this should have all the matches, lets do an assertion check
# # match_idx[:,-1].reshape
# assert(match_idx.shape == (cur_player_ids.shape[0],2)) # (N,2)
# act_match_idx = match_idx[:,-1]
# all_player_points[act_match_idx,i] = all_week_data[i].loc[cur_player_ids, :]['stats.total_points']
# return all_player_points
def get_data_for_all_players(self, all_week_data: list, player_ids : np.ndarray):
all_player_points = np.zeros((self.all_player_ids.shape[0], len(all_week_data)))
all_player_other_data = np.zeros((len(self.all_player_other_data_cols), self.all_player_ids.shape[0], len(all_week_data)) , dtype=np.object)
for i in range(len(all_week_data)):
# cur_player_ids = np.unique(np.array(all_week_data[i].index))
cur_player_ids = np.unique(np.array(all_week_data[i].index)) # (N,)
act_P_reshaped = np.broadcast_to(cur_player_ids[:,np.newaxis], (cur_player_ids.shape[0],self.all_player_ids.shape[0])) # (N, 620)
all_P_reshaped = np.broadcast_to(self.all_player_ids[np.newaxis, :], (cur_player_ids.shape[0],self.all_player_ids.shape[0]) )# (N,620)
match_idx = np.argwhere(act_P_reshaped == all_P_reshaped) # this should have all the matches, lets do an assertion check
# match_idx[:,-1].reshape
assert(match_idx.shape == (cur_player_ids.shape[0],2)) # (N,2)
act_match_idx = match_idx[:,-1]
all_player_points[act_match_idx,i] = all_week_data[i].loc[cur_player_ids, :]['stats.total_points']
for j,col in enumerate(self.all_player_other_data_cols):
all_player_other_data[j,act_match_idx,i] = all_week_data[i].loc[cur_player_ids, :][col]
return all_player_points, all_player_other_data
def get_players_of_manager(self, manager_id:int, current_week:int):
'''
return (15,W) ndarray of players for manager_id
'''
player_ids = []
for week in range(1,current_week+1):
r = requests.get('https://fantasy.premierleague.com/api/entry/'+manager_id+'/event/'+str(week)+'/picks/').json()
player_ids.append([x['element'] for x in r['picks']])
return np.array(player_ids).T
def get_swapped_in_players(self, actual_player_ids, num_tranfers = 8):
'''
this is the output from the scout model based on suggestion from the recruiter NN model
returns a (N_t, 15, 10) ndarray of transfers
1.this array will have only one point set. Only one cell
2.the value will be the player in for that game week
3.the value of team matrix at that index will be the player_out
4. transfer_ins must be in order of transfer . ie; week(transfer_ins[0]) < week(transfer_ins[1]) < .... < week(transfer_ins[N_t])
'''
N_t = np.random.randint(1, num_tranfers) # dummy value for now
random_game_weeks = np.random.choice(np.arange(self.current_week), N_t) # use replace = False if we dont want multiple transfers in same game week
random_game_weeks = sorted(random_game_weeks) # (N_t,)
random_in_players = np.random.choice(self.all_player_ids, N_t, replace=False)
random_out_players = np.random.choice(np.arange(actual_player_ids.shape[0]), N_t, replace=False)
transfer_ins = np.zeros((N_t, ) + actual_player_ids.shape)
# transfer_ins[0,10,5] = 23
# transfer_ins[1,12,6] = 24
# transfer_ins[2,4,7] = 265
transfer_ins[np.arange(N_t), random_out_players, random_game_weeks] = random_in_players
return transfer_ins
def get_swapped_in_players_test(self, actual_player_ids, num_transfers = 1, game_week = 0):
'''
this will just produce a random transfer for that game week
this is the output from the scout model based on suggestion from the recruiter NN model
returns a (N_t, 15, 10) ndarray of transfers
1.this array will have only one point set. Only one cell
2.the value will be the player in for that game week
3.the value of team matrix at that index will be the player_out
4. transfer_ins must be in order of transfer . ie; week(transfer_ins[0]) < week(transfer_ins[1]) < .... < week(transfer_ins[N_t])
'''
N_t = num_transfers
# random_game_weeks = np.random.choice(np.arange(self.current_week), N_t) # use replace = False if we dont want multiple transfers in same game week
# random_game_weeks = sorted(random_game_weeks) # (N_t,)
random_game_weeks = np.array([game_week])
assert(num_transfers == 1) # otherwise the below statement wont work
other_players_ids = np.setdiff1d(self.all_player_ids,actual_player_ids[:,game_week])
random_in_players = np.random.choice(other_players_ids, N_t, replace=False)
random_out_players = np.random.choice(np.arange(actual_player_ids.shape[0]), N_t, replace=False)
transfer_ins = np.zeros((N_t, ) + actual_player_ids.shape)
# transfer_ins[0,10,5] = 23
# transfer_ins[1,12,6] = 24
# transfer_ins[2,4,7] = 265
transfer_ins[np.arange(N_t), random_out_players, random_game_weeks] = random_in_players
return transfer_ins
def get_swapped_out_players(self, actual_player_ids):
'''
this is the output from some logic
returns a (N_t, 15, 10) ndarray of transfers
1.this array will have only one point set. Only one cell
2.the value will be the player in for that game week
3.the value of team matrix at that index will be the player_out
4. transfer_ins must be in order of transfer . ie; week(transfer_ins[0]) < week(transfer_ins[1]) < .... < week(transfer_ins[N_t])
'''
N_t = np.random.randint(8) # dummy value for now
transfer_outs = np.zeros((N_t, ) + actual_player_ids.shape)
'''
WRITE CODE HERE
'''
return transfer_outs
def get_player_info_matrix(self, all_player_info, actual_players_ids):
'''
This is a generic function to retrieve the cost or points of the player_ids
get the player index position in the all player id array. we need this to get the cost of the
actual players from the all player cost array. this is a bit complicated but the fastest way to compare
all_player_info : ndarray shape = (620,10)
'''
assert(all_player_info.shape == (self.all_player_ids.shape[0], self.current_week))
act_P_reshaped = np.broadcast_to(actual_players_ids[:,:,np.newaxis], actual_players_ids.shape + (self.all_player_ids.shape[0], ) ) # (15, 10, 620)
all_P_reshaped = np.broadcast_to(self.all_player_ids[np.newaxis, np.newaxis,:], actual_players_ids.shape + (self.all_player_ids.shape[0], ) )# (15, 10, 620)
match_idx = np.argwhere(act_P_reshaped == all_P_reshaped) # this should have all the matches, lets do an assertion check
assert(match_idx.shape == (actual_players_ids.reshape(-1).shape[0],3))
# just see how hte
act_to_all_match_idx = match_idx[:,-1].reshape((actual_players_ids.shape[0],10))
act_to_all_match_idx # (15,10)
actual_player_info = all_player_info[act_to_all_match_idx, np.broadcast_to(np.arange(self.current_week)[np.newaxis, :]\
,act_to_all_match_idx.shape)]
return actual_player_info
def do_transfer(self, transfer_ins, actual_players_ids):
'''
transfer_ins : ndarray . shape = (N_t,15,10)
actual_players_ids : ndarray . shape = (15,10),
actual_players_points : ndarray . shape = (15,10),
actual_player_cost : ndarray . shape = (15,10)
returns actual_players_ids, actual_players_points, actual_player_cost after applying the transfer in and out
'''
# 1. get the transfer weeks
transfer_week_idxs = np.argmax(transfer_ins.sum(axis=1), axis=1) # (N_t,)
# 2 . create the replicator mask for the transfers
# well the transfer at a point means, we assume that the team formed after the transfer continue until end week
# this is because all the actual transfers occuring after that will be bogus. we can only look at one week and see if a transfer is possible
# to just replace the trajectory of tranferred out player in the team with the player_in is not simple
replicator_masks = np.zeros(transfer_ins.shape) # (N_t,15,10)
for i, w in enumerate(transfer_week_idxs):
replicator_masks[i,:,np.arange(w,actual_players_ids.shape[-1])] = 1
# the replicator masks will just extend out the two matrices : actual_players_ids and transfer_ins
replicated_actual_players_ids = replicator_masks * actual_players_ids[:,transfer_week_idxs[0]][np.newaxis,:,np.newaxis] # (N_t,15,10)
replicated_player_transfers = replicator_masks * transfer_ins[np.arange(transfer_ins.shape[0]),:,transfer_week_idxs][:,:,np.newaxis] # (N_t,15,10)
# 3. create the transfer index matrix which has the transfer idx to be copied to that cell
trf_broad = np.broadcast_to(np.arange(transfer_ins.shape[0])[:,np.newaxis,np.newaxis], transfer_ins.shape).copy()
trf_broad[replicated_player_transfers == 0] = 0 # (N_t,15,10)
transfer_order_idxs = np.argmax(trf_broad,axis=0) # (15,10)
ww,pp = np.meshgrid(np.arange(actual_players_ids.shape[1]),\
np.arange(actual_players_ids.shape[0]))
# 4. now that we have the transfer_order_idxs we have to step by step sum up the matrices : player_ids and transfers
# this indexing below will give you a flattened matrix with value corresponding to what transfer occured. This is done by the transfer_order_idxs matrix
replicated_actual_players_ids = replicated_actual_players_ids[transfer_order_idxs, pp, ww] # (15,10)
replicated_player_transfers = replicated_player_transfers[transfer_order_idxs, pp, ww] # (15,10)
replicated_actual_players_ids[replicated_player_transfers > 0] = replicated_player_transfers[replicated_player_transfers > 0] # step here
# 5. these are our new set of variables
new_team_player_ids = np.array(actual_players_ids)
new_team_player_points = | np.zeros_like(new_team_player_ids) | numpy.zeros_like |
# import required packages
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import tensorflow as tf
from tensorflow.python.framework import ops
# define the sigmoid function
def sigmoid(z):
g = 1.0 / (1.0 + np.exp(-z))
return g
# compute the cost using theta, x, y, lambda
def cost_function(theta, x, y, lambda_):
# initialize the parameters
m = y.shape[0]
j = 0
grad = np.zeros(theta.shape)
# print(m, j, grad)
# compute the cost
h = sigmoid(np.dot(x, theta))
j = (-np.dot(y.T, | np.log(h) | numpy.log |
import numpy as np
from mayavi import mlab
# data preparation
orgPC = np.random.normal(size=(1000, 3))
roadPC = | np.random.normal(size=(500, 3)) | numpy.random.normal |
import scipy as sp
import numpy as np
from scipy.stats import lognorm as dist
eps = 1e-6
class LogNormal(object):
n_params = 2
def __init__(self, params, temp_scale = 1.0):
mu = params[0]
logsigma = params[1]
sigma = np.exp(logsigma)
self.mu = mu
self.sigma = sigma
self.dist = dist(s=sigma, scale=np.exp(mu))
def __getattr__(self, name):
if name in dir(self.dist):
return getattr(self.dist, name)
return None
def nll(self, Y):
try:
E = Y['Event']
T = Y['Time']
cens = (1-E) * np.log(1 - self.dist.cdf(T) + eps)
uncens = E * self.dist.logpdf(T)
return -(cens + uncens)
except:
return -self.dist.logpdf(Y)
def D_nll(self, Y):
if True:
E = Y['Event'].reshape((-1, 1))
T = Y['Time']
lT = np.log(T)
D_uncens = np.zeros((self.mu.shape[0], 2))
D_uncens[:, 0] = (self.mu - lT) / (self.sigma ** 2)
D_uncens[:, 1] = 1 - ((self.mu - lT) ** 2) / (self.sigma ** 2)
D_cens = np.zeros((self.mu.shape[0], 2))
Z = (lT - self.mu) / self.sigma
D_cens[:, 0] = sp.stats.norm.pdf(lT, loc=self.mu, scale=self.sigma)/(1 - self.dist.cdf(T) + eps)
D_cens[:, 0] = Z * sp.stats.norm.pdf(lT, loc=self.mu, scale=self.sigma)/(1 - self.dist.cdf(T) + eps)
cens = (1-E) * D_cens
uncens = -(E * D_uncens)
return -(cens + uncens)
else:
Y = Y_.squeeze()
D = np.zeros((self.mu.shape[0], 2))
D[:, 0] = (self.mu - np.log(T)) / (self.sigma ** 2)
D[:, 1] = 1 - ((self.mu - np.log(T)) ** 2) / (self.sigma ** 2)
return D
def crps(self, Y_):
Y = np.log(Y_.squeeze())
Z = (Y - self.loc) / self.scale
return self.scale * (Z * (2 * sp.stats.norm.cdf(Z) - 1) + \
2 * sp.stats.norm.pdf(Z) - 1 / np.sqrt(np.pi))
def crps_metric(self):
I = 1/(2*np.sqrt(np.pi)) * np.diag(np.array([1, self.var/2]))
return I + 1e-4 * np.eye(2)
def fisher_info(self):
FI = | np.zeros((self.mu.shape[0], 2, 2)) | numpy.zeros |
from __future__ import print_function
import numpy as np
import os
import sys
import cv2
import random
import pickle
import torch
import torch.backends.cudnn as cudnn
from torch.autograd import Variable
import torch.optim as optim
from torch.optim import lr_scheduler
import torch.utils.data as data
import torch.nn.init as init
from tensorboardX import SummaryWriter
from layers import *
from layers.modules.multibox_loss import MultiBoxLoss2
from data import BaseTransform
from utils.timer import Timer
from data.data_augment import preproc
from data.dataset_factory import load_data
from utils.config import cfg
from layers.functions import Detect, PriorBox
from layers.functions.detection import Detect2
from models import *
#from utils.eval_utils import *
#from utils.visualize_utils import *
class Solver(object):
"""
A wrapper class for the training process
"""
def __init__(self):
self.cfg = cfg
# Load data
print('===> Loading data')
self.train_loader = load_data(cfg.dataset, 'train') if 'train' in cfg.phase else None
self.eval_loader = load_data(cfg.dataset, 'eval') if 'eval' in cfg.phase else None
self.test_loader = load_data(cfg.dataset, 'test') if 'test' in cfg.phase else None
# self.visualize_loader = load_data(cfg.DATASET, 'visualize') if 'visualize' in cfg.PHASE else None
# Build model
print('===> Building model')
self.base_trans = BaseTransform(cfg.image_size[0], cfg.network.rgb_means, cfg.network.rgb_std, (2, 0, 1))
self.priors = PriorBox(cfg.anchor)
self.model = eval(cfg.model+'.build_net')(cfg.image_size[0], cfg.dataset.num_classes)
with torch.no_grad():
self.priors = self.priors.forward()
self.detector = Detect2(cfg.post_process)
# Utilize GPUs for computation
self.use_gpu = torch.cuda.is_available()
if cfg.train.train_scope == '':
trainable_param = self.model.parameters()
else:
trainable_param = self.trainable_param(cfg.train.train_scope)
self.output_dir = os.path.join(cfg.output_dir, cfg.name, cfg.date)
if not os.path.exists(self.output_dir):
os.makedirs(self.output_dir)
self.log_dir = os.path.join(self.output_dir, 'logs')
if not os.path.exists(self.log_dir):
os.makedirs(self.log_dir)
self.checkpoint = cfg.train.checkpoint
previous = self.find_previous()
previous = False
if previous:
self.start_epoch = previous[0][-1]
self.resume_checkpoint(previous[1][-1])
else:
self.start_epoch = self.initialize()
if self.use_gpu:
print('Utilize GPUs for computation')
print('Number of GPU available', torch.cuda.device_count())
self.model.cuda()
self.priors.cuda()
cudnn.benchmark = True
if cfg.ngpu > 1:
self.model = torch.nn.DataParallel(self.model, device_ids=list(range(cfg.ngpu)))
# Print the model architecture and parameters
#print('Model architectures:\n{}\n'.format(self.model))
#print('Parameters and size:')
#for name, param in self.model.named_parameters():
# print('{}: {}'.format(name, list(param.size())))
# print trainable scope
print('Trainable scope: {}'.format(cfg.train.train_scope))
self.optimizer = self.configure_optimizer(trainable_param, cfg.train.optimizer)
self.exp_lr_scheduler = self.configure_lr_scheduler(self.optimizer, cfg.train.lr_scheduler)
self.max_epochs = cfg.train.lr_scheduler.max_epochs
# metric
if cfg.network.multi_box_loss_type == 'origin':
self.criterion = MultiBoxLoss2(cfg.matcher, self.priors, self.use_gpu)
else:
print('ERROR: '+cfg.multi_box_loss_type+' is not supported')
sys.exit()
# Set the logger
self.writer = SummaryWriter(log_dir=self.log_dir)
self.checkpoint_prefix = cfg.name+'_'+cfg.dataset.dataset
def save_checkpoints(self, epochs, iters=None):
if not os.path.exists(self.output_dir):
os.makedirs(self.output_dir)
if iters:
filename = self.checkpoint_prefix + '_epoch_{:d}_iter_{:d}'.format(epochs, iters) + '.pth'
else:
filename = self.checkpoint_prefix + '_epoch_{:d}'.format(epochs) + '.pth'
filename = os.path.join(self.output_dir, filename)
torch.save(self.model.state_dict(), filename)
with open(os.path.join(self.output_dir, 'checkpoint_list.txt'), 'a') as f:
f.write('epoch {epoch:d}: {filename}\n'.format(epoch=epochs, filename=filename))
print('Wrote snapshot to: {:s}'.format(filename))
# TODO: write relative cfg under the same page
def resume_checkpoint(self, resume_checkpoint):
if resume_checkpoint == '' or not os.path.isfile(resume_checkpoint):
print(("=> no checkpoint found at '{}'".format(resume_checkpoint)))
return False
print(("=> loading checkpoint '{:s}'".format(resume_checkpoint)))
checkpoint = torch.load(resume_checkpoint)
# print("=> Weigths in the checkpoints:")
# print([k for k, v in list(checkpoint.items())])
# remove the module in the parrallel model
if 'module.' in list(checkpoint.items())[0][0]:
pretrained_dict = {'.'.join(k.split('.')[1:]): v for k, v in list(checkpoint.items())}
checkpoint = pretrained_dict
resume_scope = self.cfg.train.resume_scope
# extract the weights based on the resume scope
if resume_scope != '':
pretrained_dict = {}
for k, v in list(checkpoint.items()):
for resume_key in resume_scope.split(','):
if resume_key in k:
pretrained_dict[k] = v
break
checkpoint = pretrained_dict
pretrained_dict = {k: v for k, v in checkpoint.items() if k in self.model.state_dict()}
# print("=> Resume weigths:")
# print([k for k, v in list(pretrained_dict.items())])
checkpoint = self.model.state_dict()
unresume_dict = set(checkpoint)-set(pretrained_dict)
if len(unresume_dict) != 0:
print("=> UNResume weigths:")
print(unresume_dict)
checkpoint.update(pretrained_dict)
return self.model.load_state_dict(checkpoint)
def find_previous(self):
if not os.path.exists(os.path.join(self.output_dir, 'checkpoint_list.txt')):
return False
with open(os.path.join(self.output_dir, 'checkpoint_list.txt'), 'r') as f:
lineList = f.readlines()
epoches, resume_checkpoints = [list() for _ in range(2)]
for line in lineList:
epoch = int(line[line.find('epoch ') + len('epoch '): line.find(':')])
checkpoint = line[line.find(':') + 2:-1]
epoches.append(epoch)
resume_checkpoints.append(checkpoint)
return epoches, resume_checkpoints
def weights_init(self, m):
for key in m.state_dict():
if key.split('.')[-1] == 'weight':
if 'conv' in key:
init.kaiming_normal(m.state_dict()[key], mode='fan_out')
if 'bn' in key:
m.state_dict()[key][...] = 1
elif key.split('.')[-1] == 'bias':
m.state_dict()[key][...] = 0
def initialize(self):
# TODO: ADD INIT ways
# raise ValueError("Fan in and fan out can not be computed for tensor with less than 2 dimensions")
# for module in self.cfg.TRAIN.TRAINABLE_SCOPE.split(','):
# if hasattr(self.model, module):
# getattr(self.model, module).apply(self.weights_init)
if self.checkpoint:
print('Loading initial model weights from {:s}'.format(self.checkpoint))
self.resume_checkpoint(self.checkpoint)
return cfg.train.resume_epoch
else:
self.model.init_model(cfg.network.basenet)
return 0
def trainable_param(self, trainable_scope):
for param in self.model.parameters():
param.requires_grad = False
trainable_param = []
for module in trainable_scope.split(','):
if hasattr(self.model, module):
# print(getattr(self.model, module))
for param in getattr(self.model, module).parameters():
param.requires_grad = True
trainable_param.extend(getattr(self.model, module).parameters())
return trainable_param
def train_model(self):
# export graph for the model, onnx always not works
# self.export_graph()
# warm_up epoch
for epoch in iter(range(self.start_epoch+1, self.max_epochs+1)):
#learning rate
sys.stdout.write('\rEpoch {epoch:d}/{max_epochs:d}:\n'.format(epoch=epoch, max_epochs=self.max_epochs))
self.exp_lr_scheduler.step(epoch-cfg.train.lr_scheduler.warmup)
if 'train' in cfg.phase:
self.train_epoch(self.model, self.train_loader, self.optimizer, self.criterion, self.writer, epoch, self.use_gpu)
if 'eval' in cfg.phase and epoch%cfg.test_frequency == 0:
self.eval_epoch(self.model, self.eval_loader, self.detector, self.criterion, self.writer, epoch, self.use_gpu)
#if 'test' in cfg.PHASE:
# self.test_epoch(self.model, self.test_loader, self.detector, self.output_dir, self.use_gpu)
#if 'visualize' in cfg.PHASE:
# self.visualize_epoch(self.model, self.visualize_loader, self.priorbox, self.writer, epoch, self.use_gpu)
if epoch % cfg.train.save_frequency == 0:
self.save_checkpoints(epoch)
def train_epoch(self, model, data_loader, optimizer, criterion, writer, epoch, use_gpu):
model.train()
epoch_size = len(data_loader)
batch_iterator = iter(data_loader)
loc_loss = 0
conf_loss = 0
_t = Timer()
for iteration in iter(range((epoch_size))):
with torch.no_grad():
images, targets = next(batch_iterator)
if use_gpu:
images = images.cuda()
targets = [anno.cuda() for anno in targets]
_t.tic()
# forward
out = model(images)
# backprop
optimizer.zero_grad()
loss_l, loss_c = criterion(out, targets)
# some bugs in coco train2017. maybe the annonation bug.
if loss_l.item() == float("Inf"):
continue
loss = loss_l + loss_c
loss.backward()
optimizer.step()
time = _t.toc()
loc_loss += loss_l.item()
conf_loss += loss_c.item()
# log per iter
log = '\r==>Train: || {iters:d}/{epoch_size:d} in {time:.3f}s [{prograss}] || loc_loss: {loc_loss:.4f} cls_loss: {cls_loss:.4f}\r'.format(
prograss='#'*int(round(10*iteration/epoch_size)) + '-'*int(round(10*(1-iteration/epoch_size))), iters=iteration, epoch_size=epoch_size,
time=time, loc_loss=loss_l.item(), cls_loss=loss_c.item())
sys.stdout.write(log)
sys.stdout.flush()
# log per epoch
sys.stdout.write('\r')
sys.stdout.flush()
lr = optimizer.param_groups[0]['lr']
log = '\r==>Train: || Total_time: {time:.3f}s || loc_loss: {loc_loss:.4f} conf_loss: {conf_loss:.4f} || lr: {lr:.6f}\n'.format(lr=lr,
time=_t.total_time, loc_loss=loc_loss/epoch_size, conf_loss=conf_loss/epoch_size)
sys.stdout.write(log)
sys.stdout.flush()
# log for tensorboard
writer.add_scalar('Train/loc_loss', loc_loss/epoch_size, epoch)
writer.add_scalar('Train/conf_loss', conf_loss/epoch_size, epoch)
writer.add_scalar('Train/lr', lr, epoch)
def eval_epoch(self, model, data_loader, detector, output_dir, use_gpu):
model.eval()
dataset = data_loader.dataset
num_images = len(testset)
num_classes = cfg.dataset.num_classes
all_boxes = [[[] for _ in range(num_images)]
for _ in range(num_classes)]
_t = {'im_detect': Timer(), 'misc': Timer()}
det_file = os.path.join(self.output_dir, 'detections.pkl')
if cfg.test.retest:
f = open(det_file, 'rb')
all_boxes = pickle.load(f)
print('Evaluating detections')
testset.evaluate_detections(all_boxes, save_folder)
return
for i in range(num_images):
img = testset.pull_image(i)
with torch.no_grad():
x = transform(img).unsqueeze(0)
if cuda:
x = x.to(torch.device("cuda"))
_t['im_detect'].tic()
out = net(x=x, test=True) # forward pass
boxes, scores = detector.forward(out, self.priors)
detect_time = _t['im_detect'].toc()
boxes = boxes[0]
scores = scores[0]
boxes = boxes.cpu().numpy()
scores = scores.cpu().numpy()
# scale each detection back up to the image
scale = torch.Tensor([img.shape[1], img.shape[0],
img.shape[1], img.shape[0]]).cpu().numpy()
boxes *= scale
_t['misc'].tic()
for j in range(1, num_classes):
inds = | np.where(scores[:, j] > cfg.post_process.score_threshold) | numpy.where |
"""
Tests for the BNMF Gibbs sampler.
"""
import sys, os
project_location = os.path.dirname(__file__)+"/../../../"
sys.path.append(project_location)
import numpy, math, pytest, itertools
from BNMTF.code.models.bnmf_gibbs_optimised import bnmf_gibbs_optimised
""" Test constructor """
def test_init():
# Test getting an exception when R and M are different sizes, and when R is not a 2D array.
R1 = numpy.ones(3)
M = numpy.ones((2,3))
I,J,K = 5,3,1
lambdaU = numpy.ones((I,K))
lambdaV = numpy.ones((J,K))
alpha, beta = 3, 1
priors = { 'alpha':alpha, 'beta':beta, 'lambdaU':lambdaU, 'lambdaV':lambdaV }
with pytest.raises(AssertionError) as error:
bnmf_gibbs_optimised(R1,M,K,priors)
assert str(error.value) == "Input matrix R is not a two-dimensional array, but instead 1-dimensional."
R2 = numpy.ones((4,3,2))
with pytest.raises(AssertionError) as error:
bnmf_gibbs_optimised(R2,M,K,priors)
assert str(error.value) == "Input matrix R is not a two-dimensional array, but instead 3-dimensional."
R3 = numpy.ones((3,2))
with pytest.raises(AssertionError) as error:
bnmf_gibbs_optimised(R3,M,K,priors)
assert str(error.value) == "Input matrix R is not of the same size as the indicator matrix M: (3, 2) and (2, 3) respectively."
# Similarly for lambdaU, lambdaV
R4 = numpy.ones((2,3))
lambdaU = numpy.ones((2+1,1))
priors = { 'alpha':alpha, 'beta':beta, 'lambdaU':lambdaU, 'lambdaV':lambdaV }
with pytest.raises(AssertionError) as error:
bnmf_gibbs_optimised(R4,M,K,priors)
assert str(error.value) == "Prior matrix lambdaU has the wrong shape: (3, 1) instead of (2, 1)."
lambdaU = numpy.ones((2,1))
lambdaV = numpy.ones((3+1,1))
priors = { 'alpha':alpha, 'beta':beta, 'lambdaU':lambdaU, 'lambdaV':lambdaV }
with pytest.raises(AssertionError) as error:
bnmf_gibbs_optimised(R4,M,K,priors)
assert str(error.value) == "Prior matrix lambdaV has the wrong shape: (4, 1) instead of (3, 1)."
# Test getting an exception if a row or column is entirely unknown
lambdaU = numpy.ones((2,1))
lambdaV = numpy.ones((3,1))
M1 = [[1,1,1],[0,0,0]]
M2 = [[1,1,0],[1,0,0]]
priors = { 'alpha':alpha, 'beta':beta, 'lambdaU':lambdaU, 'lambdaV':lambdaV }
with pytest.raises(AssertionError) as error:
bnmf_gibbs_optimised(R4,M1,K,priors)
assert str(error.value) == "Fully unobserved row in R, row 1."
with pytest.raises(AssertionError) as error:
bnmf_gibbs_optimised(R4,M2,K,priors)
assert str(error.value) == "Fully unobserved column in R, column 2."
# Finally, a successful case
I,J,K = 3,2,2
R5 = 2*numpy.ones((I,J))
lambdaU = numpy.ones((I,K))
lambdaV = numpy.ones((J,K))
M = numpy.ones((I,J))
priors = { 'alpha':alpha, 'beta':beta, 'lambdaU':lambdaU, 'lambdaV':lambdaV }
BNMF = bnmf_gibbs_optimised(R5,M,K,priors)
assert numpy.array_equal(BNMF.R,R5)
assert numpy.array_equal(BNMF.M,M)
assert BNMF.I == I
assert BNMF.J == J
assert BNMF.K == K
assert BNMF.size_Omega == I*J
assert BNMF.alpha == alpha
assert BNMF.beta == beta
assert numpy.array_equal(BNMF.lambdaU,lambdaU)
assert numpy.array_equal(BNMF.lambdaV,lambdaV)
# And when lambdaU and lambdaV are integers
I,J,K = 3,2,2
R5 = 2*numpy.ones((I,J))
lambdaU = 3.
lambdaV = 4.
M = numpy.ones((I,J))
priors = { 'alpha':alpha, 'beta':beta, 'lambdaU':lambdaU, 'lambdaV':lambdaV }
BNMF = bnmf_gibbs_optimised(R5,M,K,priors)
assert numpy.array_equal(BNMF.R,R5)
assert numpy.array_equal(BNMF.M,M)
assert BNMF.I == I
assert BNMF.J == J
assert BNMF.K == K
assert BNMF.size_Omega == I*J
assert BNMF.alpha == alpha
assert BNMF.beta == beta
assert numpy.array_equal(BNMF.lambdaU,lambdaU*numpy.ones((I,K)))
assert numpy.array_equal(BNMF.lambdaV,lambdaV*numpy.ones((J,K)))
""" Test initialing parameters """
def test_initialise():
I,J,K = 5,3,2
R = numpy.ones((I,J))
M = numpy.ones((I,J))
lambdaU = 2*numpy.ones((I,K))
lambdaV = 3*numpy.ones((J,K))
alpha, beta = 3, 1
priors = { 'alpha':alpha, 'beta':beta, 'lambdaU':lambdaU, 'lambdaV':lambdaV }
# First do a random initialisation - we can then only check whether values are correctly initialised
init = 'random'
BNMF = bnmf_gibbs_optimised(R,M,K,priors)
BNMF.initialise(init)
assert BNMF.tau >= 0.0
for i,k in itertools.product(xrange(0,I),xrange(0,K)):
assert BNMF.U[i,k] >= 0.0
for j,k in itertools.product(xrange(0,J),xrange(0,K)):
assert BNMF.V[j,k] >= 0.0
# Then initialise with expectation values
init = 'exp'
BNMF = bnmf_gibbs_optimised(R,M,K,priors)
BNMF.initialise(init)
assert BNMF.tau >= 0.0
for i,k in itertools.product(xrange(0,I),xrange(0,K)):
assert BNMF.U[i,k] == 1./2.
for j,k in itertools.product(xrange(0,J),xrange(0,K)):
assert BNMF.V[j,k] == 1./3.
#assert BNMF.tau == 3./1.
""" Test computing values for alpha, beta, mu, tau. """
I,J,K = 5,3,2
R = numpy.ones((I,J))
M = numpy.ones((I,J))
M[0,0], M[2,2], M[3,1] = 0, 0, 0
lambdaU = 2*numpy.ones((I,K))
lambdaV = 3*numpy.ones((J,K))
alpha, beta = 3, 1
priors = { 'alpha':alpha, 'beta':beta, 'lambdaU':lambdaU, 'lambdaV':lambdaV }
init = 'exp' #U=1/2,V=1/3
def test_alpha_s():
BNMF = bnmf_gibbs_optimised(R,M,K,priors)
BNMF.initialise(init)
alpha_s = alpha + 6.
assert BNMF.alpha_s() == alpha_s
def test_beta_s():
BNMF = bnmf_gibbs_optimised(R,M,K,priors)
BNMF.initialise(init)
beta_s = beta + .5*(12*(2./3.)**2) #U*V.T = [[1/6+1/6,..]]
assert abs(BNMF.beta_s() - beta_s) < 0.000000000000001
def test_tauU():
BNMF = bnmf_gibbs_optimised(R,M,K,priors)
BNMF.initialise(init)
BNMF.tau = 3.
#V^2 = [[1/9,1/9],[1/9,1/9],[1/9,1/9]], sum_j V^2 = [2/9,1/3,2/9,2/9,1/3] (index=i)
tauU = 3.*numpy.array([[2./9.,2./9.],[1./3.,1./3.],[2./9.,2./9.],[2./9.,2./9.],[1./3.,1./3.]])
for i,k in itertools.product(xrange(0,I),xrange(0,K)):
assert BNMF.tauU(k)[i] == tauU[i,k]
def test_muU():
BNMF = bnmf_gibbs_optimised(R,M,K,priors)
BNMF.initialise(init)
BNMF.tau = 3.
#U*V^T - Uik*Vjk = [[1/6,..]], so Rij - Ui * Vj + Uik * Vjk = 5/6
tauU = 3.*numpy.array([[2./9.,2./9.],[1./3.,1./3.],[2./9.,2./9.],[2./9.,2./9.],[1./3.,1./3.]])
muU = 1./tauU * ( 3. * numpy.array([[2.*(5./6.)*(1./3.),10./18.],[15./18.,15./18.],[10./18.,10./18.],[10./18.,10./18.],[15./18.,15./18.]]) - lambdaU )
for i,k in itertools.product(xrange(0,I),xrange(0,K)):
assert abs(BNMF.muU(tauU[:,k],k)[i] - muU[i,k]) < 0.000000000000001
def test_tauV():
BNMF = bnmf_gibbs_optimised(R,M,K,priors)
BNMF.initialise(init)
BNMF.tau = 3.
#U^2 = [[1/4,1/4],[1/4,1/4],[1/4,1/4],[1/4,1/4],[1/4,1/4]], sum_i U^2 = [1,1,1] (index=j)
tauV = 3.*numpy.array([[1.,1.],[1.,1.],[1.,1.]])
for j,k in itertools.product(xrange(0,J),xrange(0,K)):
assert BNMF.tauV(k)[j] == tauV[j,k]
def test_muV():
BNMF = bnmf_gibbs_optimised(R,M,K,priors)
BNMF.initialise(init)
BNMF.tau = 3.
#U*V^T - Uik*Vjk = [[1/6,..]], so Rij - Ui * Vj + Uik * Vjk = 5/6
tauV = 3.*numpy.array([[1.,1.],[1.,1.],[1.,1.]])
muV = 1./tauV * ( 3. * numpy.array([[4.*(5./6.)*(1./2.),4.*(5./6.)*(1./2.)],[4.*(5./6.)*(1./2.),4.*(5./6.)*(1./2.)],[4.*(5./6.)*(1./2.),4.*(5./6.)*(1./2.)]]) - lambdaV )
for j,k in itertools.product(xrange(0,J),xrange(0,K)):
assert BNMF.muV(tauV[:,k],k)[j] == muV[j,k]
""" Test some iterations, and that the values have changed in U and V. """
def test_run():
I,J,K = 10,5,2
R = numpy.ones((I,J))
M = numpy.ones((I,J))
M[0,0], M[2,2], M[3,1] = 0, 0, 0
lambdaU = 2*numpy.ones((I,K))
lambdaV = 3*numpy.ones((J,K))
alpha, beta = 3, 1
priors = { 'alpha':alpha, 'beta':beta, 'lambdaU':lambdaU, 'lambdaV':lambdaV }
init = 'exp' #U=1/2,V=1/3
U_prior = numpy.ones((I,K))/2.
V_prior = numpy.ones((J,K))/3.
iterations = 15
BNMF = bnmf_gibbs_optimised(R,M,K,priors)
BNMF.initialise(init)
(Us,Vs,taus) = BNMF.run(iterations)
assert BNMF.all_U.shape == (iterations,I,K)
assert BNMF.all_V.shape == (iterations,J,K)
assert BNMF.all_tau.shape == (iterations,)
for i,k in itertools.product(xrange(0,I),xrange(0,K)):
assert Us[0,i,k] != U_prior[i,k]
for j,k in itertools.product(xrange(0,J),xrange(0,K)):
assert Vs[0,j,k] != V_prior[j,k]
assert taus[1] != alpha/float(beta)
""" Test approximating the expectations for U, V, tau """
def test_approx_expectation():
burn_in = 2
thinning = 3 # so index 2,5,8 -> m=3,m=6,m=9
(I,J,K) = (5,3,2)
Us = [numpy.ones((I,K)) * 3*m**2 for m in range(1,10+1)] #first is 1's, second is 4's, third is 9's, etc.
Vs = [numpy.ones((J,K)) * 2*m**2 for m in range(1,10+1)]
taus = [m**2 for m in range(1,10+1)]
expected_exp_tau = (9.+36.+81.)/3.
expected_exp_U = numpy.array([[9.+36.+81.,9.+36.+81.],[9.+36.+81.,9.+36.+81.],[9.+36.+81.,9.+36.+81.],[9.+36.+81.,9.+36.+81.],[9.+36.+81.,9.+36.+81.]])
expected_exp_V = numpy.array([[(9.+36.+81.)*(2./3.),(9.+36.+81.)*(2./3.)],[(9.+36.+81.)*(2./3.),(9.+36.+81.)*(2./3.)],[(9.+36.+81.)*(2./3.),(9.+36.+81.)*(2./3.)]])
R = | numpy.ones((I,J)) | numpy.ones |
"""Create synthetic datasets for surrogate training."""
# %%
from os import mkdir, getcwd
import numpy as np
import pandas as pd
from optproblems import wfg, dtlz, zdt
from pyDOE import lhs
from tqdm import tqdm
mean = 0.5
std_dev = 0.1
noise_mean = 0
noise_std = 0.05
num_obj = 2
num_var_zdt = {"ZDT1": 30, "ZDT2": 30, "ZDT3": 30, "ZDT4": 10, "ZDT6": 10}
problems = {
"WFG1": wfg.WFG1,
"WFG2": wfg.WFG2,
"WFG3": wfg.WFG3,
"WFG4": wfg.WFG4,
"WFG5": wfg.WFG5,
"WFG6": wfg.WFG6,
"WFG7": wfg.WFG7,
"WFG8": wfg.WFG8,
"WFG9": wfg.WFG9,
"ZDT1": zdt.ZDT1,
"ZDT2": zdt.ZDT2,
"ZDT3": zdt.ZDT3,
"ZDT4": zdt.ZDT4,
"ZDT6": zdt.ZDT6,
"DTLZ1": dtlz.DTLZ1,
"DTLZ2": dtlz.DTLZ2,
"DTLZ3": dtlz.DTLZ3,
"DTLZ4": dtlz.DTLZ4,
"DTLZ5": dtlz.DTLZ5,
"DTLZ6": dtlz.DTLZ6,
"DTLZ7": dtlz.DTLZ7,
}
def generatedata(
*,
problemname: str,
num_var: int,
num_samples: int,
distribution: str,
noise: bool,
missing_data: bool,
save_folder: str,
):
"""Generate random dataset from known benchmark problems or engineering problems.
Parameters
----------
problemname : str
Name of the problem
num_var : int
number of decision variables
num_samples : int
number of samples
distribution : str
Normal or uniform distribution
noise : bool
Presence or absence of noise in data
missing_data : bool
Presence or absence of missing chunks of data
save_folder : str
Path to the save folder
"""
if "DTLZ" in problemname:
generateDTLZ(
problemname,
num_var,
num_samples,
distribution,
noise,
missing_data,
save_folder,
)
return
elif "WFG" in problemname:
generateWFG(
problemname,
num_var,
num_samples,
distribution,
noise,
missing_data,
save_folder,
)
return
elif "ZDT" in problemname:
generateZDT(
problemname,
num_var,
num_samples,
distribution,
noise,
missing_data,
save_folder,
)
return
else:
print("Error with Problem name")
return
def generate_var_0_1(
problemname: str,
num_var: int,
num_samples: int,
distribution: str,
noise: bool,
missing_data: bool,
save_folder: str,
):
filename = (
save_folder
+ "/"
+ problemname
+ "_"
+ str(num_var)
+ "_"
+ str(num_samples)
+ "_"
+ distribution
)
if distribution == "uniform":
var = lhs(num_var, num_samples)
elif distribution == "normal":
means = [mean] * num_var
cov = np.eye(num_var) * np.square(std_dev)
var = np.random.multivariate_normal(means, cov, num_samples)
if noise:
noise_means = [noise_mean] * num_var
noise_cov = np.eye(num_var) * np.square(noise_std)
noise_var = np.random.multivariate_normal(noise_means, noise_cov, num_samples)
filename = filename + "_noisy"
var = var + noise_var
# To keep values between 0 and 1
var[var > 1] = 1
var[var < 0] = 0
return (var, filename)
def generateDTLZ(
problemname: str,
num_var: int,
num_samples: int,
distribution: str,
noise: bool,
missing_data: bool,
save_folder: str,
):
"""Generate and save DTLZ datasets as csv.
Parameters
----------
problemname : str
Name of the problem
num_var : int
number of variables
num_samples : int
Number of samples
distribution : str
Uniform or normal distribution
noise : bool
Presence or absence of noise
missing_data : bool
Presence or absence of missing data
save_folder : str
Path to the folder to save csv files
"""
objective = problems[problemname](num_obj, num_var)
var_names = ["x{0}".format(x) for x in range(num_var)]
obj_names = ["f1", "f2"]
if distribution in ["uniform", "normal"]:
var, filename = generate_var_0_1(
problemname,
num_var,
num_samples,
distribution,
noise,
missing_data,
save_folder,
)
elif distribution == "optimal":
x_first_m_1 = np.random.random((num_samples, num_obj - 1))
if problemname == "DTLZ6" or problemname == "DTLZ7":
x_last_k = np.zeros((num_samples, num_var - num_obj + 1))
else:
x_last_k = np.zeros((num_samples, num_var - num_obj + 1)) + 0.5
var = np.hstack((x_first_m_1, x_last_k))
filename = (
save_folder
+ "/"
+ problemname
+ "_"
+ str(num_var)
+ "_"
+ str(num_samples)
+ "_"
+ distribution
)
obj = [objective(x) for x in var]
data = np.hstack((var, obj))
data = pd.DataFrame(data, columns=var_names + obj_names)
filename = filename + ".csv"
data.to_csv(filename, index=False)
return
def generateWFG(
problemname: str,
num_var: int,
num_samples: int,
distribution: str,
noise: bool,
missing_data: bool,
save_folder: str,
):
"""Generate and save WFG datasets as csv.
Parameters
----------
problemname : str
Name of the problem
num_var : int
number of variables
num_samples : int
Number of samples
distribution : str
Uniform or normal distribution
noise : bool
Presence or absence of noise
missing_data : bool
Presence or absence of missing data
save_folder : str
Path to the folder to save csv files
"""
objective = problems[problemname](num_obj, num_var, k=4)
var_names = ["x{0}".format(x) for x in range(num_var)]
obj_names = ["f1", "f2"]
if distribution in ["uniform", "normal"]:
var, filename = generate_var_0_1(
problemname,
num_var,
num_samples,
distribution,
noise,
missing_data,
save_folder,
)
elif distribution == "optimal":
solns = objective.get_optimal_solutions(max_number=num_samples)
var = np.asarray([soln.phenome for soln in solns])
filename = (
save_folder
+ "/"
+ problemname
+ "_"
+ str(num_var)
+ "_"
+ str(num_samples)
+ "_"
+ distribution
)
obj = [objective(x) for x in var]
data = np.hstack((var, obj))
data = pd.DataFrame(data, columns=var_names + obj_names)
filename = filename + ".csv"
data.to_csv(filename, index=False)
return
def generateZDT(
problemname: str,
num_var: int,
num_samples: int,
distribution: str,
noise: bool,
missing_data: bool,
save_folder: str,
):
"""Generate and save ZDT datasets as csv.
Parameters
----------
problemname : str
Name of the problem
num_var : int
number of variables
num_samples : int
Number of samples
distribution : str
Uniform or normal distribution
noise : bool
Presence or absence of noise
missing_data : bool
Presence or absence of missing data
save_folder : str
Path to the folder to save csv files
"""
objective = problems[problemname]()
num_var = num_var_zdt[problemname]
var_names = ["x{0}".format(x) for x in range(num_var)]
obj_names = ["f1", "f2"]
if distribution in ["uniform", "normal"]:
var, filename = generate_var_0_1(
problemname,
num_var,
num_samples,
distribution,
noise,
missing_data,
save_folder,
)
elif distribution == "optimal":
var = np.zeros((num_samples, num_var - 1))
var_x1 = np.linspace(0, 1, num_samples).reshape(-1, 1)
var = | np.hstack((var_x1, var)) | numpy.hstack |
import numpy as np
import multiprocessing
import sys
import time
import matplotlib.pyplot as plt
# =============================================================================
# Distributed Computing Parameters
pool_size = multiprocessing.cpu_count()
# Genetic Circuit Hyperparameters
NODES = 3000
# Evolutionary Algorithm Hyperparameters
GENERATIONS = 201 # number of generations to run
# Other Hyperparameters
# STEP_MUTATION_RATE = 0.9
# BIG_STEP_MUTATION_RATE = 0.8
# RANDOM_MUTATION_RATE = 1
# SIGN_FLIP_MUTATION_RATE = 0.1
# REG_RATE = 0.0003 # regularization rate
STEP_SIZE = 2.0 # max mutation intensity of each weight
POPULATION = pool_size * 6 # total number of population
SURVIVABLE_PARENTS = POPULATION // 3 # number of parents to survive
# Novelty Search Hyperparameters
# KNN_BC_NUM = 1 # k nearest neighbors number for behavior characteristics
# ARCHIVE_STORING_RATE = 0.01
# ODE
TIME_STEPS = 300
BATCH_SIZE = 30 # Fully dividable by 3 recommended
# Score Constraints
ERROR_BOUND = 0.1 # percentage of error allowed (sigmoid bounds are +-1)
BANDPASS_BOUND = 0.3
# the absolute bound of each weight (very important)
# choose something close to sigmoid saturation is good (eg. 7.5+, 5 is not good, 10 is good)
BOUND = 13
# Parameters (Derived from hyperparameters)
DNA_SIZE = NODES * NODES
UPPER_BANDPASS_BOUND = 1 - BANDPASS_BOUND
COST_UPPER_BOUND = ERROR_BOUND * BATCH_SIZE
# =============================================================================
# Mean normalization
def standardize(population):
# as known as z-score normalization
# the other method being min-max normalization
for i, weights in enumerate(population):
mean = np.mean(weights)
std = np.std(weights)
population[i] = (weights - mean) / std
return population
# =============================================================================
# ODE & Simulations
def sigmoid(x):
return 1 / (1 + np.exp(-x))
# FF Classifier
# Here, only the classical solution determinator is implemented
# def simulate_ode_original(W, N, B, S):
# dt = 0.01
# initial_val = 0.1 * np.ones([B, S]) # can we reuse this?
# input_val = np.linspace(0, 2, B).reshape(B, 1) * np.random.normal(
# loc=1.0, scale=0.0001, size=[N, B, S]) # can we reduce the redundants?
# input_val[:, :, 1:S] = 0.0
# output = initial_val + (
# sigmoid(np.matmul(initial_val, W)) - initial_val + input_val[0]) * dt
# # print(output)
# # HOW: create one time np.linspace(0, 2, B), mutate and reuse in for loop
# for i in range(1, N):
# output = output + (
# sigmoid(np.matmul(output, W)) - output + input_val[i]) * dt
# # print(output)
# return output
# input_initializer = np.linspace(0, 2, BATCH_SIZE).reshape(BATCH_SIZE, 1,)
# input_val[:, 0] = np.linspace(0, 2, BATCH_SIZE).reshape(BATCH_SIZE)
# print(np.random.normal(loc=1.0, scale=0.0001))
dt = 0.01
initial_val = 0.1 * np.ones([BATCH_SIZE, NODES])
input_val = np.zeros((BATCH_SIZE, NODES))
linspace_col = np.linspace(0, 2, BATCH_SIZE).reshape(BATCH_SIZE)
def simulate_ode(W, N, B, S):
# Insert one input and have three outputs
input_val[:, 0] = linspace_col * np.random.normal(loc=1.0, scale=0.0001)
input_val[:, 1] = linspace_col * np.random.normal(loc=1.0, scale=0.0001)
input_val[:, 2] = linspace_col * np.random.normal(loc=1.0, scale=0.0001)
output = (
initial_val
+ (sigmoid(np.matmul(initial_val, W)) - initial_val + input_val) * dt
)
for i in range(1, N):
input_val[:, 0] = linspace_col * np.random.normal(loc=1.0, scale=0.0001)
input_val[:, 1] = linspace_col * np.random.normal(loc=1.0, scale=0.0001)
input_val[:, 2] = linspace_col * np.random.normal(loc=1.0, scale=0.0001)
output = output + (sigmoid(np.matmul(output, W)) - output + input_val) * dt
# print(output)
return output
def plot_expressions(y, B):
b = np.linspace(1, B, B)
plt.title(f"{NODES} Nodes")
plt.plot(b, y[:, 0], "black", linewidth=2, label="Input Node #1")
plt.plot(b, y[:, 1], "saddlebrown", linewidth=2, label="Input Node #2")
for i in range(3, y.shape[1] - 1):
# plt.plot(b, y[:, i], 'g-', linewidth=2, label='Support Node')
plt.plot(b, y[:, i], "gray", linewidth=2)
plt.plot(b, y[:, -3], "b", linewidth=2, label="Output Node #3 - Switch")
plt.plot(b, y[:, -2], "g", linewidth=2, label="Output Node #2 - Valley")
plt.plot(b, y[:, -1], "r", linewidth=2, label="Output Node #1 - Bandpass")
plt.xlabel("Input Level")
plt.ylabel("Output Level")
plt.legend()
plt.show()
# =============================================================================
# Behavior characteristic distance mean calculator
# def population_novelty(population):
# pop_novelty = np.zeros(POPULATION)
# bc_distance = np.zeros(POPULATION)
# for i, weights in enumerate(population):
# for j, target in enumerate(population):
# bc_distance[j] = np.linalg.norm(weights - target)
# # only uses KNN_BC_NUM of bc_distance to calculate bc_dist_mean
# bc_distance.sort()
# pop_novelty[i] = np.mean(bc_distance[-KNN_BC_NUM:])
# return pop_novelty
# =============================================================================
# The forever (unforgettable) archive of most novel children in a generation
# Or another method: Prob 1% to store any children to archive
# archive = []
# =============================================================================
# Double mergesort sorting by alist
def double_mergesort(alist, blist):
# print("Splitting ",alist)
if len(alist) > 1:
mid = len(alist) // 2
lefthalf_a = alist[:mid]
lefthalf_b = blist[:mid]
righthalf_a = alist[mid:]
righthalf_b = blist[mid:]
double_mergesort(lefthalf_a, lefthalf_b)
double_mergesort(righthalf_a, righthalf_b)
i = 0
j = 0
k = 0
while i < len(lefthalf_a) and j < len(righthalf_a):
if lefthalf_a[i] < righthalf_a[j]:
alist[k] = lefthalf_a[i]
blist[k] = lefthalf_b[i]
i = i + 1
else:
alist[k] = righthalf_a[j]
blist[k] = righthalf_b[j]
j = j + 1
k = k + 1
while i < len(lefthalf_a):
alist[k] = lefthalf_a[i]
blist[k] = lefthalf_b[i]
i = i + 1
k = k + 1
while j < len(righthalf_a):
alist[k] = righthalf_a[j]
blist[k] = righthalf_b[j]
j = j + 1
k = k + 1
# =============================================================================
# Main functions
# Bandpass Determinator
# Determines whether the solution given is a bandpass
# so that you don't need the flags -> faster
def bandpass_determinator(y):
# here we check only one node
# it would be wise to check other nodes, to check if it is classical solution
starting_low_flag = False
middle_high_flag = False
ending_low_flag = False
for pt in y[:, -1]:
if not starting_low_flag:
if pt < BANDPASS_BOUND:
starting_low_flag = True
elif not middle_high_flag:
if pt > UPPER_BANDPASS_BOUND:
middle_high_flag = True
elif not ending_low_flag:
if pt < BANDPASS_BOUND: # something is wrong here
ending_low_flag = True
else:
if pt > BANDPASS_BOUND:
ending_low_flag = False
# print(starting_low_flag, middle_high_flag, ending_low_flag)
return starting_low_flag and middle_high_flag and ending_low_flag
# Bandpass Cost function (for objective based selection method, the lower the better)
# Assume pt size is dividable by three
bandpass_design = [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.5,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
0.5,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
]
bandpass_design = np.array(bandpass_design)
def bandpass_cost_calculator(y, B):
cost = np.sum(np.abs(y - bandpass_design))
return cost
def switch_cost_calculator(y, B):
cost = 0
for pt in y[: B // 2]:
cost += np.absolute(pt - 0)
for put in y[B // 2 :]:
cost += np.absolute(1 - pt)
return cost
def linear_cost_calculator(y, B):
B -= 1
cost = 0
for i, pt in enumerate(y):
cost += np.absolute(pt - (i / B))
return cost
peak_design = [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.125,
0.25,
0.375,
0.5,
0.625,
0.75,
0.875,
1.0,
1.0,
0.875,
0.75,
0.625,
0.5,
0.375,
0.25,
0.125,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
]
peak_design = np.array(peak_design)
def peak_cost_calculator(y, B):
# Experiment failed: Made a mountain instead, much easier than bandpass...
cost = np.sum(np.abs(y - peak_design))
return cost
cosine_design = [
1.0,
0.9766205557100867,
0.907575419670957,
0.7960930657056438,
0.6473862847818277,
0.46840844069979015,
0.26752833852922075,
0.05413890858541761,
-0.16178199655276473,
-0.37013815533991445,
-0.5611870653623823,
-0.7259954919231308,
-0.8568571761675893,
-0.9476531711828025,
-0.9941379571543596,
-0.9941379571543596,
-0.9476531711828025,
-0.8568571761675892,
-0.7259954919231307,
-0.5611870653623825,
-0.37013815533991445,
-0.16178199655276476,
0.05413890858541758,
0.267528338529221,
0.4684084406997903,
0.6473862847818279,
0.796093065705644,
0.9075754196709569,
0.9766205557100867,
1.0,
]
cosine_design = np.array(cosine_design)
def cosine_cost_calculator(y, B):
cost = np.sum(np.abs(y - cosine_design))
return cost
# valley_design = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.9458172417006346, 0.7891405093963936, 0.546948158122427, 0.24548548714079924, -0.08257934547233227, -0.40169542465296926, -0.6772815716257409, -0.879473751206489, -0.9863613034027223, -0.9863613034027224, -0.8794737512064891, -0.6772815716257414, -0.40169542465296987, -0.08257934547233274, 0.2454854871407988, 0.5469481581224266, 0.7891405093963934, 0.9458172417006346, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
# valley_design = 1 - bandpass_design
# valley_design = 1 - peak_design
def valley_cost_calculator(y, B):
cost = np.sum(np.abs(y - valley_design))
return cost
bandpass_reversed_design = 1 - bandpass_design
def bandpass_reversed_cost_calculator(y, B):
cost = np.sum(np.abs(y - bandpass_reversed_design))
return cost
# def adaptation_cost_calculator(y, B):
# cost = 0
# ADAPTED_LEVEL = 0.1
# for pt in y[:B // 3]:
# cost += np.absolute(pt - 0)
# slice = ((1- ADAPTED_LEVEL) / (B//3))
# for i, pt in enumerate(y[B // 3:2 * B // 3]):
# cost += np.absolute(1 - i * slice) * 3
# print(1 - i * slice)
# sys.exit()
# for pt in y[2 * B // 3:]:
# cost += np.absolute(pt - ADAPTED_LEVEL)
# return cost
adaptation_design = [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.5,
1.0,
0.5,
0.25,
0.125,
0.0625,
0.03125,
0.015625,
0.0078125,
0.00390625,
0.001953125,
0.0009765625,
0.00048828125,
0.000244140625,
0.0001220703125,
6.103515625e-05,
3.0517578125e-05,
1.52587890625e-05,
7.62939453125e-06,
3.814697265625e-06,
1.9073486328125e-06,
]
adaptation_design = np.array(adaptation_design)
def adaptation_cost_calculator(y, B):
cost = 0
# for i, pt in enumerate(y):
# cost += np.absolute(pt - adaptation_design[i])
cost = np.sum(np.abs(y - adaptation_design))
return cost
# # def adaptation_cost_calculator(y, B):
# cost = 0
# for pt in y[:B // 3]:
# cost += np.absolute(pt - 0)
# for pt in y[B // 3:2 * B // 3]:
# cost += np.absolute(1 - pt)
# for pt in y[2 * B // 3:]:
# cost += np.absolute(pt - 0.5)
# return cost
# Fitness based
cost_storage = [-1] * POPULATION
# def select(population):
# for i, potential_parent in enumerate(population):
# y = simulate_ode(potential_parent, TIME_STEPS, BATCH_SIZE, NODES)
# # Multiple outputs
# cost_storage[i] = bandpass_cost_calculator(y[:, -1], BATCH_SIZE) * 1.5
# cost_storage[i] += switch_cost_calculator(y[:, -2], BATCH_SIZE) * 1.25
# # cost_storage[i] = adaptation_cost_calculator(y[:, -1], BATCH_SIZE)
# cost_storage[i] += linear_cost_calculator(y[:, -3], BATCH_SIZE)
# cost_storage[i] /= 3
# # cost_storage[i] += REG_RATE * sum(sum(abs(potential_parent))) # regularization
# double_mergesort(cost_storage, population)
# y = simulate_ode(population[0], TIME_STEPS, BATCH_SIZE, NODES)
# print("Bandpass Cost:", bandpass_cost_calculator(y[:, -1], BATCH_SIZE))
# print("Switch Cost:", switch_cost_calculator(y[:, -2], BATCH_SIZE))
# print("Linear Cost:", linear_cost_calculator(y[:, -3], BATCH_SIZE))
# # print(cost_storage[0])
# survivors = population[:SURVIVABLE_PARENTS]
# survivors = np.append(survivors, survivors, axis=0)
# # repopulated_parents = np.append(repopulated_parents, survivors, axis=0)
# # random_children = np.random.uniform(-BOUND, BOUND, (SURVIVABLE_PARENTS, NODES, NODES))
# # survivors = np.append(repopulated_parents, random_children, axis=0)
# # print(repopulated_parents)
# return survivors, population[0], cost_storage[0]
# def select(population):
# # Harmonic Version - Mitigate Impact of Outliers
# for i, potential_parent in enumerate(population):
# y = simulate_ode(potential_parent, TIME_STEPS, BATCH_SIZE, NODES)
# # Multiple outputs
# f_bandpass = BATCH_SIZE - bandpass_cost_calculator(y[:, -1], BATCH_SIZE)
# f_switch = BATCH_SIZE - switch_cost_calculator(y[:, -2], BATCH_SIZE)
# f_linear = BATCH_SIZE - linear_cost_calculator(y[:, -3], BATCH_SIZE)
# cost_storage[i] = BATCH_SIZE - 3 / (((1/f_bandpass) + (1/f_switch) + (1/f_linear)))
# # cost_storage[i] += REG_RATE * sum(sum(abs(potential_parent))) # regularization
# # cost_storage[i] = f_bandpass + f_switch + f_linear
# double_mergesort(cost_storage, population)
# y = simulate_ode(population[0], TIME_STEPS, BATCH_SIZE, NODES)
# print("Bandpass Cost:", bandpass_cost_calculator(y[:, -1], BATCH_SIZE))
# print("Switch Cost:", switch_cost_calculator(y[:, -2], BATCH_SIZE))
# print("Linear Cost:", linear_cost_calculator(y[:, -3], BATCH_SIZE))
# # print(cost_storage[0])
# survivors = population[:SURVIVABLE_PARENTS]
# survivors = np.append(survivors, survivors, axis=0)
# # repopulated_parents = np.append(repopulated_parents, survivors, axis=0)
# # random_children = np.random.uniform(-BOUND, BOUND, (SURVIVABLE_PARENTS, NODES, NODES))
# # survivors = np.append(repopulated_parents, random_children, axis=0)
# # print(repopulated_parents)
# return survivors, population[0], cost_storage[0]
# def select(population):
# # Square Version - Aggravate Impact of Outliers
# for i, potential_parent in enumerate(population):
# y = simulate_ode(potential_parent, TIME_STEPS, BATCH_SIZE, NODES)
# # Multiple outputs
# f_bandpass = bandpass_cost_calculator(y[:, -1], BATCH_SIZE)
# f_bandpass_reversed = bandpass_reversed_cost_calculator(y[:, -2], BATCH_SIZE)
# f_switch = switch_cost_calculator(y[:, -3], BATCH_SIZE)
# # f_valley = valley_cost_calculator(y[:, -3], BATCH_SIZE)
# # f_linear = linear_cost_calculator(y[:, -3], BATCH_SIZE)
# # cost_storage[i] = valley_cost_calculator(y[:, -1], BATCH_SIZE)
# # cost_storage[i] = peak_cost_calculator(y[:, -1], BATCH_SIZE)
# # cost_storage[i] = bandpass_cost_calculator(y[:, -1], BATCH_SIZE)
# cost_storage[i] = f_bandpass**2 + f_switch**2 + f_bandpass_reversed**2
# # cost_storage[i] += REG_RATE * sum(sum(abs(potential_parent))) # regularization
# # cost_storage[i] = f_bandpass + f_switch + f_linear
# double_mergesort(cost_storage, population)
# y = simulate_ode(population[0], TIME_STEPS, BATCH_SIZE, NODES)
# print("Bandpass Cost:", bandpass_cost_calculator(y[:, -1], BATCH_SIZE))
# print("Valley Cost:", bandpass_reversed_cost_calculator(y[:, -2], BATCH_SIZE))
# print("Switch Cost:", switch_cost_calculator(y[:, -3], BATCH_SIZE))
# # print("Valley Cost:", valley_cost_calculator(y[:, -3], BATCH_SIZE))
# # print("Linear Cost:", linear_cost_calculator(y[:, -3], BATCH_SIZE))
# # print(cost_storage[0])
# survivors = population[:SURVIVABLE_PARENTS]
# survivors = np.append(survivors, survivors, axis=0)
# # repopulated_parents = np.append(repopulated_parents, survivors, axis=0)
# # random_children = np.random.uniform(-BOUND, BOUND, (SURVIVABLE_PARENTS, NODES, NODES))
# # survivors = np.append(repopulated_parents, random_children, axis=0)
# # print(repopulated_parents)
# return survivors, population[0], cost_storage[0]
def select(population):
for i, potential_parent in enumerate(population):
f_bandpass = simulate_and_cost_bandpass(potential_parent)
f_bandpass_reversed = simulate_and_cost_bandpass_reversed(potential_parent)
f_switch = simulate_and_cost_switch(potential_parent)
cost_storage[i] = f_bandpass ** 2 + f_bandpass_reversed ** 2 + f_switch ** 2
double_mergesort(cost_storage, population)
survivors = population[:SURVIVABLE_PARENTS]
survivors = np.append(survivors, survivors, axis=0)
return survivors, population[0], cost_storage[0]
def plot(y):
b = np.linspace(1, BATCH_SIZE, BATCH_SIZE)
plt.title(f"{NODES} Nodes")
plt.plot(b, y[:, 0], "black", linewidth=2, label="Input Node #1")
plt.plot(b, y[:, 1], "saddlebrown", linewidth=2, label="Input Node #2")
for i in range(2, y.shape[1] - 1):
# plt.plot(b, y[:, i], 'g-', linewidth=2, label='Support Node')
plt.plot(b, y[:, i], "gray", linewidth=2)
plt.plot(b, y[:, -1], "r", linewidth=2, label="Multifunction Output Node")
plt.xlabel("Input Level")
plt.ylabel("Output Level")
plt.legend()
plt.show()
def simulate_and_cost_bandpass(individual):
# Encode <- 0, 1
input_val = np.zeros((BATCH_SIZE, NODES))
input_val[:, 0] = linspace_col * np.random.normal(loc=1.0, scale=0.0001)
output = (
initial_val
+ (sigmoid(np.matmul(initial_val, individual)) - initial_val + input_val) * dt
)
for i in range(1, TIME_STEPS):
input_val[:, 0] = linspace_col * np.random.normal(loc=1.0, scale=0.0001)
output = (
output + (sigmoid(np.matmul(output, individual)) - output + input_val) * dt
)
cost = np.sum(np.abs(output[:, -1] - bandpass_design))
return cost
def simulate_and_cost_bandpass_reversed(individual):
# Encode <- 1, 0
input_val = np.zeros((BATCH_SIZE, NODES))
input_val[:, 1] = linspace_col * np.random.normal(loc=1.0, scale=0.0001)
output = (
initial_val
+ (sigmoid(np.matmul(initial_val, individual)) - initial_val + input_val) * dt
)
for i in range(1, TIME_STEPS):
input_val[:, 1] = linspace_col * np.random.normal(loc=1.0, scale=0.0001)
output = (
output + (sigmoid(np.matmul(output, individual)) - output + input_val) * dt
)
cost = np.sum(np.abs(output[:, -1] - bandpass_reversed_design))
return cost
switch_design = [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
1.0,
]
switch_design = np.array(switch_design)
def simulate_and_cost_switch(individual):
# Encode <- 1, 1
input_val = np.zeros((BATCH_SIZE, NODES))
input_val[:, 0] = linspace_col * np.random.normal(loc=1.0, scale=0.0001)
input_val[:, 1] = linspace_col * np.random.normal(loc=1.0, scale=0.0001)
output = (
initial_val
+ (sigmoid(np.matmul(initial_val, individual)) - initial_val + input_val) * dt
)
for i in range(1, TIME_STEPS):
input_val[:, 0] = linspace_col * np.random.normal(loc=1.0, scale=0.0001)
input_val[:, 1] = linspace_col * np.random.normal(loc=1.0, scale=0.0001)
output = (
output + (sigmoid(np.matmul(output, individual)) - output + input_val) * dt
)
cost = np.sum(np.abs(output[:, -1] - switch_design))
return cost
def simulate_plot_cost_bandpass(individual):
# Encode <- 0, 1
input_val = np.zeros((BATCH_SIZE, NODES))
input_val[:, 0] = linspace_col * np.random.normal(loc=1.0, scale=0.0001)
output = (
initial_val
+ (sigmoid(np.matmul(initial_val, individual)) - initial_val + input_val) * dt
)
for i in range(1, TIME_STEPS):
input_val[:, 0] = linspace_col * np.random.normal(loc=1.0, scale=0.0001)
output = (
output + (sigmoid(np.matmul(output, individual)) - output + input_val) * dt
)
plot(output)
def simulate_and_plot_bandpass_reversed(individual):
# Encode <- 1, 0
input_val = np.zeros((BATCH_SIZE, NODES))
input_val[:, 1] = linspace_col * np.random.normal(loc=1.0, scale=0.0001)
output = (
initial_val
+ (sigmoid(np.matmul(initial_val, individual)) - initial_val + input_val) * dt
)
for i in range(1, TIME_STEPS):
input_val[:, 1] = linspace_col * np.random.normal(loc=1.0, scale=0.0001)
output = (
output + (sigmoid(np.matmul(output, individual)) - output + input_val) * dt
)
plot(output)
def simulate_and_plot_switch(individual):
# Encode <- 1, 1
input_val = np.zeros((BATCH_SIZE, NODES))
input_val[:, 0] = linspace_col * np.random.normal(loc=1.0, scale=0.0001)
input_val[:, 1] = linspace_col * np.random.normal(loc=1.0, scale=0.0001)
output = (
initial_val
+ (sigmoid(np.matmul(initial_val, individual)) - initial_val + input_val) * dt
)
for i in range(1, TIME_STEPS):
input_val[:, 0] = linspace_col * np.random.normal(loc=1.0, scale=0.0001)
input_val[:, 1] = linspace_col * np.random.normal(loc=1.0, scale=0.0001)
output = (
output + (sigmoid(np.matmul(output, individual)) - output + input_val) * dt
)
plot(output)
def distributed_select(population):
pass
# Mutation
def mutate(population):
# doesn't mutate the elite
for p in range(1, len(population)):
for i in range(NODES):
for j in range(NODES):
if np.random.rand() < RANDOM_MUTATION_RATE:
population[p][i][j] = (
BOUND * np.random.rand() * (-1) ** np.random.randint(2)
)
elif np.random.rand() < SIGN_FLIP_MUTATION_RATE:
population[p][i][j] = -1 * population[p][i][j]
else:
population[p][i][j] += (
STEP_SIZE * np.random.rand() * (-1) ** np.random.randint(2)
)
# population[p][i][j] += 100
# print(population)
return population
def original_mutate(population):
for p in range(1, len(population)):
for i in range(NODES):
for j in range(NODES):
population[p][i][j] += (
STEP_SIZE * np.random.rand() * (-1) ** np.random.randint(2)
)
return population
def distributed_mutation(individual):
for i in range(NODES):
for j in range(NODES):
individual[i][j] += (
STEP_SIZE * np.random.rand() * (-1) ** np.random.randint(2)
)
return individual
def distributed_small_mutation(individual):
for i in range(NODES):
for j in range(NODES):
if np.random.rand() < STEP_MUTATION_RATE:
individual[i][j] += (
STEP_SIZE * np.random.rand() * (-1) ** np.random.randint(2)
)
else:
individual[i][j] = (
BOUND * np.random.rand() * (-1) ** np.random.randint(2)
)
# elif np.random.rand() < SIGN_FLIP_MUTATION_RATE:
# individual[i][j] = -1 * individual[i][j]
# population[p][i][j] += 100
return individual
def distributed_big_mutation(individual):
for i in range(NODES):
for j in range(NODES):
if np.random.rand() < BIG_STEP_MUTATION_RATE:
individual[i][j] += (
BIG_STEP_SIZE * np.random.rand() * (-1) ** np.random.randint(2)
)
else:
individual[i][j] = (
BOUND * np.random.rand() * (-1) ** np.random.randint(2)
)
# elif np.random.rand() < SIGN_FLIP_MUTATION_RATE:
# individual[i][j] = -1 * individual[i][j]
# population[p][i][j] += 100
return individual
# =============================================================================
# Random Initialization Phase
population = np.random.uniform(-BOUND, BOUND, (POPULATION, NODES, NODES))
# print(population)
# population = standardize(population)
# print(population)
# multiprocessing pool initializer
pool = multiprocessing.Pool(pool_size)
# best_score = BATCH_SIZE
# best_elite = -1
# Genetic Algorithm Loop
for g in range(GENERATIONS):
# Simulated Annealing
# if g % 10 == 0 and STEP_SIZE > 0.1:
STEP_SIZE -= 0.005
BOUND -= 0.01
# for g in range(1):
# print(population)
print("Generation:", g)
start = time.time()
survivors, elite, elite_score = select(population)
end = time.time()
print("Selection Time:", end - start)
print("Elite Score:", elite_score)
# if g % 10 == 0:
np.save(
f"large_controllability_generation_result_3000/controllability-encoded-2-in-1-out-generation-{g}.npy",
elite,
)
# if elite_score < best_score:
# best_score = elite_score
# best_elite = survivors[0]
# print("Elite:\n", elite)
# print("10th:\n", population[9])
# break if found t he solution
# print(COST_UPPER_BOUND)
# if elite_score < COST_UPPER_BOUND:
# if elite_score < 27:
# break
# population = crossover(population)
start = time.time()
survivors = np.array(pool.map(distributed_mutation, survivors))
# survivors = original_mutate(survivors)
# print(survivors[0])
# print(elite)
survivors[0] = elite
population = np.append(
survivors,
| np.random.uniform(-BOUND, BOUND, (SURVIVABLE_PARENTS, NODES, NODES)) | numpy.random.uniform |
import torch
import torch.backends.cudnn as cudnn
import numpy as np
import os
import argparse
import time
from tqdm import tqdm
from utils.setup import get_model,get_data_loader
parser = argparse.ArgumentParser()
parser.add_argument("--model_dir",default='checkpoints',type=str,help="directory of checkpoints")
parser.add_argument('--data_dir', default='data', type=str,help="directory of data")
parser.add_argument('--dataset', default='imagenette',type=str,choices=('imagenette','imagenet','cifar','cifar100','svhn','flower102'),help="dataset")
parser.add_argument("--model",default='vit_base_patch16_224',type=str,help="model name")
parser.add_argument("--num_img",default=-1,type=int,help="number of randomly selected images for this experiment (-1: using the all images)")
args = parser.parse_args()
DATASET = args.dataset
MODEL_DIR=os.path.join('.',args.model_dir)
DATA_DIR=os.path.join(args.data_dir,DATASET)
MODEL_NAME = args.model
NUM_IMG = args.num_img
#get model and data loader
model = get_model(MODEL_NAME,DATASET,MODEL_DIR)
val_loader,NUM_IMG,_ = get_data_loader(DATASET,DATA_DIR,model,batch_size=16,num_img=NUM_IMG,train=False)
device = 'cuda'
model = model.to(device)
model.eval()
cudnn.benchmark = True
accuracy_list=[]
time_list=[]
for data,labels in tqdm(val_loader):
data,labels=data.to(device),labels.to(device)
start = time.time()
output_clean = model(data)
end=time.time()
time_list.append(end-start)
acc_clean=torch.sum(torch.argmax(output_clean, dim=1) == labels).item()#cpu().detach().numpy()
accuracy_list.append(acc_clean)
print("Test accuracy:", | np.sum(accuracy_list) | numpy.sum |
import fcl
import numpy as np
from abc import ABC, abstractmethod
from collections import namedtuple
def transform_vector(tf, vector):
""" Transform a vector with a homogeneous transform matrix tf.
TODO move this to acrolib.geometry or acrobotics.util?
"""
return np.dot(tf[:3, :3], vector) + tf[:3, 3]
Polyhedron = namedtuple("Polyhedron", ["A", "b"])
class Shape(ABC):
""" Shape for visualization and collision checking.
Wraps around an fcl_shape for collision checking.
Generated vertices and edges for plotting.
A Shape has no inherent position! You always have to specify
a transform when you want something from a shape.
If you want fixed shapes for a planning scene,
you need to use a Scene object that contains a shape and a transform.
"""
num_edges: int
fcl_shape: fcl.CollisionGeometry
request: fcl.CollisionRequest
result: fcl.CollisionResult
c_req: fcl.ContinuousCollisionRequest
c_res: fcl.ContinuousCollisionResult
@abstractmethod
def get_vertices(self, transform: np.ndarray) -> np.ndarray:
pass
@abstractmethod
def get_edges(self, transform: np.ndarray) -> np.ndarray:
pass
@abstractmethod
def get_normals(self, transform: np.ndarray) -> np.ndarray:
pass
def is_in_collision(self, tf, other, tf_other):
""" Collision checking with another shape for the given transforms. """
fcl_tf_1 = fcl.Transform(tf[:3, :3], tf[:3, 3])
fcl_tf_2 = fcl.Transform(tf_other[:3, :3], tf_other[:3, 3])
o1 = fcl.CollisionObject(self.fcl_shape, fcl_tf_1)
o2 = fcl.CollisionObject(other.fcl_shape, fcl_tf_2)
return fcl.collide(o1, o2, self.request, self.result)
def is_path_in_collision(self, tf, tf_target, other, tf_other):
# assert np.sum(np.abs(tf - tf_target)) > 1e-12
fcl_tf_1 = fcl.Transform(tf[:3, :3], tf[:3, 3])
fcl_tf_2 = fcl.Transform(tf_other[:3, :3], tf_other[:3, 3])
fcl_tf_1_target = fcl.Transform(tf_target[:3, :3], tf_target[:3, 3])
o1 = fcl.CollisionObject(self.fcl_shape, fcl_tf_1)
o2 = fcl.CollisionObject(other.fcl_shape, fcl_tf_2)
self.c_req.ccd_motion_type = fcl.CCDMotionType.CCDM_LINEAR
fcl.continuousCollide(o1, fcl_tf_1_target, o2, fcl_tf_2, self.c_req, self.c_res)
return self.c_res.is_collide
def get_empty_plot_lines(self, ax, *arg, **kwarg):
""" Create empty lines to initialize an animation """
return [ax.plot([], [], "-", *arg, **kwarg)[0] for i in range(self.num_edges)]
def update_plot_lines(self, lines, tf):
""" Update existing lines on a plot using the given transform tf"""
edges = self.get_edges(tf)
for i, l in enumerate(lines):
x = np.array([edges[i, 0], edges[i, 3]])
y = np.array([edges[i, 1], edges[i, 4]])
z = np.array([edges[i, 2], edges[i, 5]])
l.set_data(x, y)
l.set_3d_properties(z)
return lines
def plot(self, ax, tf, *arg, **kwarg):
""" Plot a box as lines on a given axes_handle."""
lines = self.get_empty_plot_lines(ax, *arg, **kwarg)
lines = self.update_plot_lines(lines, tf)
class Box(Shape):
"""
I'm just a Box with six sides.
But you would be suprised,
how many robots this provides.
"""
def __init__(self, dx, dy, dz):
self.dx = dx
self.dy = dy
self.dz = dz
self.num_edges = 12
self.fcl_shape = fcl.Box(dx, dy, dz)
self.request = fcl.CollisionRequest()
self.result = fcl.CollisionResult()
self.c_req = fcl.ContinuousCollisionRequest()
self.c_res = fcl.ContinuousCollisionResult()
def get_vertices(self, tf):
v = np.zeros((8, 3))
a = self.dx / 2
b = self.dy / 2
c = self.dz / 2
v[0] = transform_vector(tf, [-a, b, c])
v[1] = transform_vector(tf, [-a, b, -c])
v[2] = transform_vector(tf, [-a, -b, c])
v[3] = transform_vector(tf, [-a, -b, -c])
v[4] = transform_vector(tf, [a, b, c])
v[5] = transform_vector(tf, [a, b, -c])
v[6] = transform_vector(tf, [a, -b, c])
v[7] = transform_vector(tf, [a, -b, -c])
return v
def get_edges(self, tf):
v = self.get_vertices(tf)
e = np.zeros((12, 6))
e[0] = np.hstack((v[0], v[1]))
e[1] = np.hstack((v[1], v[3]))
e[2] = np.hstack((v[3], v[2]))
e[3] = np.hstack((v[2], v[0]))
e[4] = np.hstack((v[0], v[4]))
e[5] = np.hstack((v[1], v[5]))
e[6] = np.hstack((v[3], v[7]))
e[7] = np.hstack((v[2], v[6]))
e[8] = np.hstack((v[4], v[5]))
e[9] = np.hstack((v[5], v[7]))
e[10] = np.hstack((v[7], v[6]))
e[11] = np.hstack((v[6], v[4]))
return e
def get_normals(self, tf):
n = np.zeros((6, 3))
R = tf[:3, :3]
n[0] = np.dot(R, [1, 0, 0])
n[1] = np.dot(R, [-1, 0, 0])
n[2] = np.dot(R, [0, 1, 0])
n[3] = np.dot(R, [0, -1, 0])
n[4] = np.dot(R, [0, 0, 1])
n[5] = np.dot(R, [0, 0, -1])
return n
def get_polyhedron(self, tf):
""" Shape represented as inequality A*x <= b
This is usefull when modelling the "no collision" constraints
as a separating hyperplane problem.
"""
A = self.get_normals(tf)
b = 0.5 * np.array([self.dx, self.dx, self.dy, self.dy, self.dz, self.dz])
b = b + np.dot(A, tf[:3, 3])
return Polyhedron(A, b)
class Cylinder(Shape):
"""
I'm just a Box with six sides.
But you would be suprised,
how many robots this provides.
"""
def __init__(self, radius, length, approx_faces=8):
self.r = radius
self.l = length
# the number of faces to use in the polyherdron approximation
self.nfac = approx_faces
self.num_edges = 3 * self.nfac
self.fcl_shape = fcl.Cylinder(radius, length)
self.request = fcl.CollisionRequest()
self.result = fcl.CollisionResult()
self.c_req = fcl.ContinuousCollisionRequest()
self.c_res = fcl.ContinuousCollisionResult()
def get_vertices(self, tf):
v = np.zeros((2 * self.nfac, 3))
# angle offset because vertices do not coincide with
# local x-axis by convention
angle_offset = 2 * np.pi / self.nfac / 2
# upper part along +z
for k in range(self.nfac):
angle = 2 * np.pi * k / self.nfac + angle_offset
v[k] = np.array(
[self.r * np.cos(angle), self.r * np.sin(angle), self.l / 2]
)
# lower part along -z
for k in range(self.nfac):
angle = 2 * np.pi * k / self.nfac + angle_offset
v[k + self.nfac] = np.array(
[self.r * np.cos(angle), self.r * np.sin(angle), -self.l / 2]
)
# tranform normals using tf (translation not relevant for normals)
for i in range(len(v)):
v[i] = tf[:3, :3] @ v[i] + tf[:3, 3]
return v
def get_edges(self, tf):
v = self.get_vertices(tf)
e = np.zeros((3 * self.nfac, 6))
# upper part
e[0] = np.hstack((v[self.nfac - 1], v[0]))
for k in range(1, self.nfac):
e[k] = np.hstack((v[k - 1], v[k]))
# lower part
# upper part
e[self.nfac] = np.hstack((v[2 * self.nfac - 1], v[self.nfac]))
for k in range(1, self.nfac):
e[k + self.nfac] = np.hstack((v[k + self.nfac - 1], v[k + self.nfac]))
# edges along z axis
for k in range(self.nfac):
e[k + 2 * self.nfac] = np.hstack((v[k], v[k + self.nfac]))
# note: tf is already applied when calculating the vertices
return e
def get_normals(self, tf):
n = np.zeros((self.nfac + 2, 3))
# normals at around the cylinder
for k in range(self.nfac):
angle = 2 * np.pi * k / self.nfac
n[k] = np.array([np.cos(angle), | np.sin(angle) | numpy.sin |
import os
import numpy as np
# from . import _api, cbook, colors, ticker
import matplotlib
from matplotlib.lines import Line2D
from matplotlib.patches import Rectangle
from matplotlib.text import Text
from matplotlib.widgets import AxesWidget
from matplotlib.backends.qt_compat import QtGui
import matplotlib.pyplot as plt
import mplcursors
from packaging import version
if version.parse(matplotlib.__version__) > version.parse("3.3.1"):
matplotlib_old = False
from matplotlib.backend_bases import _Mode
else:
matplotlib_old = True
import math
from scipy.spatial.transform import Rotation as R
from numpy.linalg import inv
rpd = math.pi / 180.0
class Picker(AxesWidget):
def __init__(self, ax, picked, callback=None):
super().__init__(ax)
self.picked = picked
self.callback = callback
self.connect_event('pick_event', self.onpress)
self.canvas.widgetlock(self)
return
def onpick(self, event):
if event.artist != self.picked:
return
if event.button == 1:
self.callback(event.ind[0])
if event.button == 3:
return
def endpick(self, event):
if event.button != 3:
return
self.disconnect_events()
self.canvas.widgetlock.release(self)
return
class LineBuilder(AxesWidget):
"""
class defined to trace lines on an existing figure
the class one time defined calculate few attributes
self.origin = origin of the line
self.vect = vector represented
self.mod = lenght of the line
self.fline = line object passing grom the two point
"""
def __init__(self, ax, callback=None, useblit=True,
stay=False, linekargs={}):
super().__init__(ax)
self.useblit = useblit and self.canvas.supports_blit
if self.useblit:
self.background = self.canvas.copy_from_bbox(self.ax.bbox)
self.stay = stay
self.callback = callback
self.linekargs = linekargs
self.connect_event('button_press_event', self.onpress)
return
def onrelease(self, event):
if self.ignore(event):
return
if self.verts is not None:
self.verts.append((event.xdata, event.ydata))
if self.callback is not None:
if len(self.verts) > 1:
self.callback(self.verts)
if not(self.stay):
self.ax.lines.remove(self.line)
self.verts = None
self.disconnect_events()
def onmove(self, event):
if self.ignore(event):
return
if self.verts is None:
return
if event.inaxes != self.ax:
return
if event.button != 1:
return
data = self.verts + [(event.xdata, event.ydata)]
data = np.array(data, dtype=float).T
self.line.set_data(*data)
if self.useblit:
self.canvas.restore_region(self.background)
self.ax.draw_artist(self.line)
self.canvas.blit(self.ax.bbox)
else:
self.canvas.draw_idle()
def onpress(self, event):
if self.canvas.widgetlock.locked():
return
if event.inaxes is None:
return
# acquire a lock on the widget drawing
if self.ignore(event):
return
if event.inaxes != self.ax:
return
if event.button != 1:
return
self.verts = [(event.xdata, event.ydata)]
self.line = Line2D([event.xdata], [event.ydata],
linestyle='-', lw=2, **self.linekargs)
self.ax.add_line(self.line)
if self.useblit:
self.canvas.restore_region(self.background)
self.ax.draw_artist(self.line)
self.canvas.blit(self.ax.bbox)
else:
self.canvas.draw_idle()
self.connect_event('button_release_event', self.onrelease)
self.connect_event('motion_notify_event', self.onmove)
###########################################################################################################
class LineAxes(AxesWidget):
def __init__(self, ax, m, callback=None, useblit=True,
linekargs={}):
super().__init__(ax)
self.useblit = useblit and self.canvas.supports_blit
if self.useblit:
self.background = self.canvas.copy_from_bbox(self.ax.bbox)
self.m = m
self.callback = callback
self.linekargs = linekargs
self.connect_event('button_press_event', self.onpress)
return
def onpress(self, event):
self.line = Line2D([0], [0], linestyle='-', marker='+',
lw=2, **self.linekargs)
self.ax.add_line(self.line)
self.p_line = [Line2D([0], [0], linestyle='--',
color='grey', lw=1) for i in range(self.m)]
for pline_i in self.p_line:
self.ax.add_line(pline_i)
self.text = self.ax.text(0, 0, '')
if self.useblit:
self.canvas.restore_region(self.background)
self.ax.draw_artist(self.line)
self.canvas.blit(self.ax.bbox)
else:
self.canvas.draw_idle()
self.connect_event('button_release_event', self.onrelease)
self.connect_event('motion_notify_event', self.onmove)
return
def onmove(self, event):
if self.ignore(event):
return
if event.inaxes != self.ax:
return
if event.button != 1:
return
lim = 1.5 * max(self.ax.get_xlim() + self.ax.get_xlim())
pdatax = lim * np.array((-event.ydata, event.ydata))
pdatay = lim * np.array((event.xdata, -event.xdata))
for i, pline_i in enumerate(self.p_line):
pline_i.set_data(pdatax + (event.xdata * (i + 1) / self.m),
pdatay + (event.ydata * (i + 1) / self.m))
# (event.xdata * (i + 1) / self.m)
# (event.ydata * (i + 1) / self.m)
datax = np.linspace(0, event.xdata, self.m + 1)
datay = np.linspace(0, event.ydata, self.m + 1)
inv_mod = round(self.m / np.sqrt(event.xdata**2 + event.ydata**2), 2)
self.line.set_data(datax, datay)
self.text.set_position((event.xdata, event.ydata))
self.text.set_text(f'{inv_mod:3.2f} ')
if self.useblit:
self.canvas.restore_region(self.background)
self.ax.draw_artist(self.line)
self.ax.draw_artist(self.text)
for pline_i in self.p_line:
self.ax.draw_artist(pline_i)
self.canvas.blit(self.ax.bbox)
else:
self.canvas.draw_idle()
def onrelease(self, event):
if self.ignore(event):
return
self.text.remove()
for pline_i in self.p_line:
pline_i.remove()
self.canvas.draw()
if self.callback is not None:
print('callback')
self.callback(self.event.xdata,
self.event.xdata)
self.disconnect_events()
class RectangleBuilder(AxesWidget):
"""
class defined to trace lines on an existing figure
the class one time defined calculate few attributes
self.origin = origin of the line
self.vect = vector represented
self.mod = lenght of the line
self.fline = line object passing grom the two point
"""
def __init__(self, ax, callback=None, useblit=False):
super().__init__(ax)
self.useblit = useblit and self.canvas.supports_blit
if self.useblit:
self.background = self.canvas.copy_from_bbox(self.ax.bbox)
self.line = LineBuilder(ax, callback=self.line_callback,
useblit=useblit, linekargs={'color': 'red'})
self.callback = callback
# self.canvas.widgetlock(self.line)
# self.__xtl = []
return
def line_callback(self, verts):
x0, y0 = verts[0]
x1, y1 = verts[1]
self.line.origin = np.array([x0, y0])
self.line.vect = np.array([x1 - x0, y1 - y0])
self.line.mod = np.sqrt(self.line.vect @ self.line.vect)
self.line.angle = -np.arctan2(*self.line.vect) / rpd
self.width = 0.0
self.Rleft = Rectangle(self.line.origin, self.width, self.line.mod,
self.line.angle, color='r', alpha=0.3)
self.Rright = Rectangle(self.line.origin, -self.width, self.line.mod,
self.line.angle, color='r', alpha=0.3)
self.ax.add_patch(self.Rleft)
self.ax.add_patch(self.Rright)
self.connect_event('button_press_event', self.onrelease)
self.connect_event('motion_notify_event', self.onmove)
if self.useblit:
self.canvas.restore_region(self.background)
self.ax.draw_artist(self.Rleft)
self.ax.draw_artist(self.Rright)
self.canvas.blit(self.ax.bbox)
else:
self.canvas.draw_idle()
def onrelease(self, event):
if self.ignore(event):
return
if self.width:
self.callback(self.line.origin, self.line.vect,
self.width)
self.Rleft.remove()
self.Rright.remove()
self.canvas.draw_idle()
self.disconnect_events()
def onmove(self, event):
if self.ignore(event):
return
if event.inaxes != self.ax:
return
# if event.button != 1:
# return
coor = np.array([event.xdata, event.ydata])
dist = np.abs(np.cross(self.line.vect, coor - self.line.origin))
self.width = dist / self.line.mod
self.Rleft.set_width(self.width)
self.Rright.set_width(-self.width)
if self.useblit:
self.canvas.restore_region(self.background)
self.canvas.blit(self.ax.bbox)
else:
self.canvas.draw_idle()
class ToolbarPlus():
def __init__(self, selfi, log=False, fig=None, ax=None, tool_b=None, *args, **kwds):
index = 0
lun = len(selfi)
self.Peak_plot = True
self.args = args
self.kwds = kwds
def UP_DO(up):
nonlocal index
index += up
index -= up * lun * (abs(index) // lun)
selfi.ima = selfi[index]
plt.sca(ax)
selfi.ima.plot(new=0, log=log, peaks=self.Peak_plot,
n=index, *self.args, **self.kwds)
ax.set_axis_off()
ax.set_frame_on(False)
#self.canvas.draw_idle()
fig.canvas.draw()
def Plot_p():
self.Peak_plot = not(self.Peak_plot)
if self.Peak_plot:
selfi.ima.Peaks.plot()
else:
selfi.ima.Peaks.deplot()
fig.canvas.draw()
def Del_p():
selfPL = selfi.ima.Peaks
if not hasattr(selfi.ima.Peaks, 'lp'):
return
if fig.canvas.widgetlock.locked():
return
def onpick(event):
if event.artist != selfi.ima.Peaks.lp:
return
selfi.ima.Peaks.del_peak(event.ind[0])
return
def endpick(event):
if event is None:
pass
elif event.button != 3:
return
fig.canvas.mpl_disconnect(selfPL._cid)
fig.canvas.mpl_disconnect(selfPL._mid)
fig.canvas.widgetlock.release(tool_b._actions['del_p'])
tool_b._actions['del_p'].setChecked(False)
return
selfPL._cid = fig.canvas.mpl_connect('pick_event', onpick)
selfPL._mid = fig.canvas.mpl_connect('button_press_event', endpick)
# fig.canvas.widgetlock(self)
# fig.canvas.widgetlock(tool_b._actions['del_p'])
#tool_b._actions['pan'].setChecked(tool_b._active == 'PAN')
#tool_b._actions['zoom'].setChecked(tool_b._active == 'ZOOM')
def DelR_p():
if not hasattr(selfi.ima.Peaks, 'lp'):
return
if matplotlib_old:
if tool_b._active == 'DelR P':
tool_b._active = None
else:
tool_b._active = 'DelR P'
if tool_b._idPress is not None:
tool_b._idPress = fig.canvas.mpl_disconnect(
tool_b._idPress)
tool_b.mode = ''
if tool_b._idRelease is not None:
tool_b._idRelease = fig.canvas.mpl_disconnect(
tool_b._idRelease)
tool_b.mode = ''
else:
if tool_b.mode == _Mode.ZOOM:
tool_b.mode = _Mode.NONE
tool_b._actions['zoom'].setChecked(False)
if tool_b.mode == _Mode.PAN:
tool_b.mode = _Mode.NONE
tool_b._actions['pan'].setChecked(False)
selfi.ima.Peaks.del_PlotRange()
def lenght():
if hasattr(selfi.ima, 'line'):
del selfi.ima.line
selfi.ima.profile_Line(plot=True)
while not(hasattr(selfi.ima.line, 'fline')):
plt.pause(0.3)
at = '\nlengh of the vector'
le = selfi.ima.line.mod * selfi.ima.scale
print(f'{at} {10*le: 4.2f} 1/Ang.')
print(f'and {0.1/le: 4.2f} Ang. in direct space')
at = 'component of the vector'
le = selfi.ima.line.vect * selfi.ima.scale
print(f'{at} {le[0]: 4.2f} {le[1]: 4.2f} 1/nm')
print('\n\n')
def angle():
if hasattr(selfi.ima, 'line'):
del selfi.ima.line
angle = selfi.ima.angle()
at = 'angle between the vectors'
print(f'{at} {angle: 4.2f} degrees')
print('\n\n')
def press(event):
if event.key == 'f4':
DelR_p()
def _icon(name):
direct = os.path.dirname(__file__)
name = os.path.join(direct, name)
pm = QtGui.QPixmap(name)
if hasattr(pm, 'setDevicePixelRatio'):
pm.setDevicePixelRatio(fig.canvas._dpi_ratio)
return QtGui.QIcon(pm)
fig.canvas.toolbar.addSeparator()
a = tool_b.addAction(_icon('down.png'), 'back', lambda: UP_DO(-1))
a.setToolTip('Previous image')
a = tool_b.addAction(_icon('up.png'), 'foward', lambda: UP_DO(1))
a.setToolTip('Next image')
tool_b.addSeparator()
a = tool_b.addAction(_icon('PlotP.png'), 'Peaks', Plot_p)
a.setToolTip('Peaks On/Off')
a = tool_b.addAction(_icon('RemP.png'), 'Del_P', Del_p)
a.setCheckable(True)
a.setToolTip('Delete Peaks')
tool_b._actions['del_p'] = a
a = tool_b.addAction(_icon('RanP.png'), 'DelR P', DelR_p)
a.setToolTip('Delete Peaks in range (F4)')
tool_b.addSeparator()
a = tool_b.addAction(_icon('lenght.png'), 'len', lenght)
a.setToolTip('calculate lenght of a line and plot profile')
a = tool_b.addAction(_icon('angle.png'), 'angle', angle)
a.setToolTip('calculate angle between two lines')
class ToolbarPlusCal():
def __init__(self, selfi, axes, log=False, fig=None, ax=None, tool_b=None, *args, **kwds):
self.index = 0
lun = len(selfi)
self.args = args
self.kwds = kwds
self.round = 0
# paasage to axes base
P = | inv(axes) | numpy.linalg.inv |
# -*- coding: utf-8 -*-
"""
Created on Fri Feb 9 13:37:59 2018
@author: jsgosselin
"""
# ---- Standard Library Imports
import sys
import os
import os.path as osp
import time
import calendar
import multiprocessing
import shutil
import subprocess
import csv
from collections import OrderedDict
# ---- Third Party imports
import netCDF4
import geopandas as gpd
import numpy as np
import h5py
from PyQt5.QtCore import pyqtSlot as QSlot
from PyQt5.QtCore import pyqtSignal as QSignal
from PyQt5.QtCore import Qt, QObject, QThread
from PyQt5.QtWidgets import QApplication
# ---- Local Libraries Imports
from pyhelp import HELP3O
from pyhelp.meteo.weather_reader import (
save_precip_to_HELP, save_airtemp_to_HELP, save_solrad_to_HELP,
read_cweeds_file, join_daily_cweeds_wy2_and_wy3)
DIRNAME = '.help_threads'
HELPNAME = 'H3OFS32F.exe'
def run_help(path_to_exe):
if osp.exists(path_to_exe):
subprocess.call(path_to_exe)
class HelpThreadPoolManager(QObject):
"""
An object that parallelize the HELP calculation and post-processing
over multiple threads.
"""
def __init__(self, nthread=None, path_hdf5=None):
super(QObject, self).__init__()
self._thread_pool = []
self._worker_pool = []
# self._hdf5file = None
self._output = {}
self.d10data = None
self.d11data = None
self.connect_tables = None
self.cellnames = []
# Output from HELP :
self._daily_out = False
self._monthly_out = True
self._yearly_out = False
self._summary_out = False
# Number of threads to use for the calculation :
self.nthread = (multiprocessing.cpu_count() if nthread is None
else nthread)
self.setup_threadpool()
self.path_hdf5 = (osp.abspath('HELP.OUT') if path_hdf5 is None
else path_hdf5)
self.setup_hdf5_output_file()
def setup_threadpool(self):
"""Setup the threads in which HELP calculations will be run."""
for i in range(self.nthread):
clonedir = osp.join(DIRNAME, 'thread%d' % i)
if not os.path.exists(clonedir):
os.makedirs(clonedir)
clonename = osp.join(clonedir, HELPNAME)
if not osp.exists(clonename):
shutil.copy2(HELPNAME, clonename)
help_thread = QThread()
help_worker = HelpWorker(clonename, self)
self._thread_pool.append(help_thread)
self._worker_pool.append(help_worker)
help_worker.moveToThread(help_thread)
help_thread.started.connect(help_worker.run_help)
help_worker.sig_cellchunk_finished.connect(
self._end_thread_calculation)
help_worker.sig_singlecell_finished.connect(
self._handle_singlecell_result)
def setup_hdf5_output_file(self):
"""Setup the hdf5 file where HELP simulation output are saved."""
if not osp.exists(osp.dirname(self.path_hdf5)):
os.makedirs(osp.dirname(self.path_hdf5))
# self._hdf5file = h5py.File(self.path_hdf5, mode='w')
def load_help_D10D11_inputs(self, path_d10file, path_d11file):
"""
Read the D10 and D11 simulation inputs from files that were produced
with the LCNP Help application and return the data for all cells
in an OrderedDict, where the keys are the names of the cells and
the value the content of the D10 and D11 csv files for each cell.
"""
self.d10data, self.d11data = read_d10d11_file(
path_d10file, path_d11file)
self.cellnames = list(self.d11data.keys())
def load_meteo_connect_tables(self, filename):
"""
Load the table that connects the D4, D7, and D13 input weather HELP
files to each cell.
"""
self.connect_tables = np.load(filename).item()
def is_calcul_running(self):
"""Return whether calculations are still being run."""
for thread in self._thread_pool:
if thread.isRunning():
return True
else:
return False
def start_calculation(self):
"""
Divide the cells in chunks and assign them to a thread and start the
calculation process for each thread.
"""
# self.cellnames = self.cellnames[:10000]
self._output = {}
self.__calcul_progress = 0
self.__start_calcul_time = time.clock()
print("Total number of cells: %d" % len(self.cellnames))
print("Number of threads: %d" % self.nthread)
cellchunks = np.array_split(self.cellnames, self.nthread)
self._nbr_of_thread_running = 0
for i in range(self.nthread):
self._nbr_of_thread_running += 1
self._worker_pool[i].cellchunk = cellchunks[i]
self._thread_pool[i].start()
@QSlot(QObject, float)
def _end_thread_calculation(self, worker, calcul_time):
self._nbr_of_thread_running += -1
worker.thread().quit()
def _store_monthly_values(self, filename, cellname):
self._output[cellname] = read_monthly_help_output(filename)
# data = read_monthly_help_output(filename)
# if 'years' not in list(self._hdf5file.keys()):
# self._hdf5file.create_dataset('years', data=data['years'])
# cellgrp = self._hdf5file.create_group(cellname)
# cellgrp.create_dataset('rain', data=data['rain'])
# cellgrp.create_dataset('runoff', data=data['runoff'])
# cellgrp.create_dataset('evapo', data=data['evapo'])
# cellgrp.create_dataset('sub-runoff', data=data['sub-runoff'])
# cellgrp.create_dataset('percolation', data=data['percolation'])
# cellgrp.create_dataset('recharge', data=data['recharge'])
# self._hdf5file.flush()
def _store_daily_values(self, filename, cellname):
data = read_daily_help_output(filename)
# if 'years' not in list(self._hdf5file.keys()):
# self._hdf5file.create_dataset('years', data=data['years'])
# if 'days' not in list(self._hdf5file.keys()):
# self._hdf5file.create_dataset('days', data=data['days'])
# cellgrp = self._hdf5file.create_group(cellname)
# cellgrp.create_dataset('rain', data=data['rain'])
# cellgrp.create_dataset('runoff', data=data['runoff'])
# cellgrp.create_dataset('et', data=data['et'])
# cellgrp.create_dataset('ezone', data=data['ezone'])
# cellgrp.create_dataset('head first', data=data['head first'])
# cellgrp.create_dataset('drain first', data=data['drain first'])
# cellgrp.create_dataset('leak first', data=data['leak first'])
# cellgrp.create_dataset('leak last', data=data['leak last'])
# self._hdf5file.flush()
@QSlot(str, str)
def _handle_singlecell_result(self, filename, cellname):
self._store_monthly_values(filename, cellname)
os.remove(filename)
self.__calcul_progress += 1
progress_pct = self.__calcul_progress/len(self.cellnames)*100
tpassed = time.clock() - self.__start_calcul_time
tremain = (100-progress_pct)*tpassed/progress_pct/60
print('\r%0.1f%% (%d min remaining)' % (progress_pct, tremain), end='')
if self.__calcul_progress == len(self.cellnames):
calcul_time = (time.clock() - self.__start_calcul_time)
print('\nCalculation time: %0.2fs\n' % calcul_time)
# self._hdf5file.close()
savedata_to_hdf5(self._output, 'monthly_help_all.out')
app.quit()
class HelpWorker(QObject):
sig_cellchunk_finished = QSignal(QObject, float)
sig_singlecell_finished = QSignal(str, str)
def __init__(self, help_exe_path, manager):
super(HelpWorker, self).__init__()
self.manager = manager
self.help_exe_path = osp.abspath(help_exe_path)
self.thread_dir = osp.dirname(self.help_exe_path)
self.path_outparam = osp.join(self.thread_dir, 'OUTPARAM.DAT')
self.path_datad10 = osp.join(self.thread_dir, 'DATA10.D10')
self.path_datad11 = osp.join(self.thread_dir, 'DATA11.D11')
self.cellchunk = []
def run_help(self):
"""Run HELP for all the cells in cellchunk."""
tstart = time.clock()
for cellname in self.cellchunk:
self._update_d10d11(cellname)
self._update_outparam(cellname)
subprocess.call(self.help_exe_path,
cwd=osp.dirname(self.help_exe_path))
outdir = osp.join(self.thread_dir, cellname+'.OUT')
self.sig_singlecell_finished.emit(outdir, cellname)
tend = time.clock()
self.sig_cellchunk_finished.emit(self, tend-tstart)
def _update_d10d11(self, cellname):
"""Update the data in the D10 and D11 input files for cellname."""
with open(self.path_datad10, 'w') as csvfile:
writer = csv.writer(csvfile, lineterminator='\n')
writer.writerows(self.manager.d10data[cellname])
with open(self.path_datad11, 'w') as csvfile:
writer = csv.writer(csvfile, lineterminator='\n')
writer.writerows(self.manager.d11data[cellname])
def _update_outparam(self, cellname):
d4name = self.manager.connect_tables['D4'][cellname]
d7name = self.manager.connect_tables['D7'][cellname]
d13name = self.manager.connect_tables['D13'][cellname]
shutil.copyfile(d4name, osp.join(self.thread_dir, 'DATA4.D4'))
shutil.copyfile(d7name, osp.join(self.thread_dir, 'DATA7.D7'))
shutil.copyfile(d13name, osp.join(self.thread_dir, 'DATA13.D13'))
outputparam = [['DATA4.D4'],
['DATA7.D7'],
['DATA13.D13'],
['DATA11.D11'],
['DATA10.D10'],
[cellname + '.OUT'],
[2],
[15],
[int(self.manager._daily_out)],
[int(self.manager._monthly_out)],
[int(self.manager._yearly_out)],
[int(self.manager._summary_out)]
]
with open(self.path_outparam, 'w') as csvfile:
writer = csv.writer(csvfile, lineterminator='\n')
writer.writerows(outputparam)
class HelpResultReader(QObject):
def __init__(self, path_hdf5):
super(HelpResultReader, self).__init__()
self.path_hdf5 = path_hdf5
self._hdf5 = h5py.File(self.path_hdf5, mode='r+')
def read_monthly_help_output(filename):
"""
Read the monthly output from .OUT HELP file and return the data as
numpy arrays stored in a dictionary.
"""
with open(filename, 'r') as csvfile:
csvread = list(csv.reader(csvfile))
arr_years = []
vstack_precip = []
vstack_runoff = []
vstack_evapo = []
vstack_subrunoff = []
vstack_percol = []
vstack_rechg = []
year = None
i = 0
while True:
if i+1 >= len(csvread):
break
if len(csvread[i]) == 0:
i += 1
continue
line = csvread[i][0]
if 'MONTHLY TOTALS' in line:
year = int(line.split()[-1])
arr_years.append(year)
subrunoff = None
percol = None
while True:
i += 1
if len(csvread[i]) == 0:
continue
line = csvread[i][0]
if '**********' in line:
break
if len(csvread[i+1]) == 0:
continue
nline = csvread[i+1][0]
if 'PRECIPITATION' in line:
precip = line.split()[-6:] + nline.split()[-6:]
elif 'RUNOFF' in line:
runoff = line.split()[-6:] + nline.split()[-6:]
elif 'EVAPOTRANSPIRATION' in line:
evapo = line.split()[-6:] + nline.split()[-6:]
elif 'LATERAL DRAINAGE' in line and subrunoff is None:
subrunoff = line.split()[-6:] + nline.split()[-6:]
elif 'PERCOLATION' in line:
if percol is None:
percol = line.split()[-6:] + nline.split()[-6:]
rechg = line.split()[-6:] + nline.split()[-6:]
vstack_precip.append(np.array(precip).astype('float32'))
vstack_runoff.append(np.array(runoff).astype('float32'))
vstack_evapo.append(np.array(evapo).astype('float32'))
vstack_rechg.append(np.array(rechg).astype('float32'))
vstack_percol.append(np.array(percol).astype('float32'))
if subrunoff is None:
vstack_subrunoff.append(np.zeros(12).astype('float32'))
else:
vstack_subrunoff.append( | np.array(subrunoff) | numpy.array |
import numpy as np
# X: a standard data array (d by n)
# y: a standard labels row vector (1 by n)
# iters: the number of updates to perform on weights WW
# lrate: the learning rate used
# K: the mini-batch size to be used
import math
class Sequential:
def __init__(self, modules, loss):
self.modules = modules
self.loss = loss
def mini_gd(self, X, Y, iters, lrate, notif_each=None, K=10):
D, N = X.shape
np.random.seed(0)
num_updates = 0
indices = np.arange(N)
while num_updates < iters:
np.random.shuffle(indices)
X = X[:,indices] # Your code
Y = Y[:,indices] # Your code
for j in range(math.floor(N/K)):
if num_updates >= iters: break
# Implement the main part of mini_gd here
Xt = X[:,(j*K):(j+1)*K] # Your code
Yt = Y[:,(j*K):(j+1)*K] # Your code
# The rest of this function should be similar to your
# implementation of Sequential.sgd in HW 7
# Your code
Ypred= self.forward(Xt)
loss= self.loss.forward(Ypred,Yt)
dLdZ= self.loss.backward()
self.backward(dLdZ)
self.sgd_step(lrate)
num_updates += 1
def forward(self, Xt):
for m in self.modules: Xt = m.forward(Xt)
return Xt
def backward(self, delta):
for m in self.modules[::-1]: delta = m.backward(delta)
def sgd_step(self, lrate):
for m in self.modules: m.sgd_step(lrate)
class BatchNorm(Module):
def __init__(self, m):
np.random.seed(0)
self.eps = 1e-20
self.m = m # number of input channels
# Init learned shifts and scaling factors
self.B = np.zeros([self.m, 1]) # m x 1
self.G = np.random.normal(0, 1.0 * self.m ** (-.5), [self.m, 1]) # m x 1
# Works on m x b matrices of m input channels and b different inputs
def forward(self, A):# A is m x K: m input channels and mini-batch size K
# Store last inputs and K for next backward() call
self.A = A
self.K = A.shape[1]
self.mus = np.mean(A,axis=1).reshape(-1,1) # Your Code
self.vars = np.var(A,axis=1).reshape(-1,1) # Your Code
# Normalize inputs using their mean and standard deviation
self.norm = (A-self.mus)/( | np.sqrt(self.vars) | numpy.sqrt |
from __future__ import division
import os
import pandas as pd
import math
import numpy as np
from scipy.spatial import ConvexHull
import scipy
from configparser import ConfigParser
def extract_features_wotarget(inifile):
config = ConfigParser()
configFile = str(inifile)
config.read(configFile)
csv_dir = config.get('General settings', 'csv_path')
csv_dir_in = os.path.join(csv_dir, 'outlier_corrected_movement_location')
csv_dir_out = os.path.join(csv_dir, 'features_extracted')
vidInfPath = config.get('General settings', 'project_path')
vidInfPath = os.path.join(vidInfPath, 'logs')
vidInfPath = os.path.join(vidInfPath, 'video_info.csv')
vidinfDf = pd.read_csv(vidInfPath)
if not os.path.exists(csv_dir_out):
os.makedirs(csv_dir_out)
def count_values_in_range(series, values_in_range_min, values_in_range_max):
return series.between(left=values_in_range_min, right=values_in_range_max).sum()
def angle3pt(ax, ay, bx, by, cx, cy):
ang = math.degrees(
math.atan2(cy - by, cx - bx) - math.atan2(ay - by, ax - bx))
return ang + 360 if ang < 0 else ang
filesFound = []
roll_windows = []
roll_windows_values = [2, 5, 6, 7.5, 15]
loopy = 0
########### FIND CSV FILES ###########
for i in os.listdir(csv_dir_in):
if i.__contains__(".csv"):
fname = os.path.join(csv_dir_in, i)
filesFound.append(fname)
print('Extracting features from ' + str(len(filesFound)) + ' files...')
########### CREATE PD FOR RAW DATA AND PD FOR MOVEMENT BETWEEN FRAMES ###########
for i in filesFound:
M1_hull_large_euclidean_list = []
M1_hull_small_euclidean_list = []
M1_hull_mean_euclidean_list = []
M1_hull_sum_euclidean_list = []
M2_hull_large_euclidean_list = []
M2_hull_small_euclidean_list = []
M2_hull_mean_euclidean_list = []
M2_hull_sum_euclidean_list = []
currentFile = i
currVidName = os.path.basename(currentFile)
currVidName = currVidName.replace('.csv', '')
# get current pixels/mm
currVideoSettings = vidinfDf.loc[vidinfDf['Video'] == currVidName]
try:
currPixPerMM = float(currVideoSettings['pixels/mm'])
except TypeError:
print('Error: make sure all the videos that are going to be analyzed are represented in the project_folder/logs/video_info.csv file')
fps = float(currVideoSettings['fps'])
print('Processing ' + '"' + str(currVidName) + '".' + ' Fps: ' + str(fps) + ". mm/ppx: " + str(currPixPerMM))
for i in range(len(roll_windows_values)):
roll_windows.append(int(fps / roll_windows_values[i]))
loopy += 1
columnHeaders = ["Ear_left_1_x", "Ear_left_1_y", "Ear_left_1_p", "Ear_right_1_x", "Ear_right_1_y",
"Ear_right_1_p", "Nose_1_x", "Nose_1_y", "Nose_1_p", "Center_1_x", "Center_1_y", "Center_1_p",
"Lat_left_1_x", "Lat_left_1_y",
"Lat_left_1_p", "Lat_right_1_x", "Lat_right_1_y", "Lat_right_1_p", "Tail_base_1_x",
"Tail_base_1_y", "Tail_base_1_p", "Tail_end_1_x", "Tail_end_1_y", "Tail_end_1_p",
"Ear_left_2_x",
"Ear_left_2_y", "Ear_left_2_p", "Ear_right_2_x", "Ear_right_2_y", "Ear_right_2_p",
"Nose_2_x", "Nose_2_y", "Nose_2_p", "Center_2_x", "Center_2_y", "Center_2_p", "Lat_left_2_x",
"Lat_left_2_y",
"Lat_left_2_p", "Lat_right_2_x", "Lat_right_2_y", "Lat_right_2_p", "Tail_base_2_x",
"Tail_base_2_y", "Tail_base_2_p", "Tail_end_2_x", "Tail_end_2_y", "Tail_end_2_p"]
csv_df = pd.read_csv(currentFile, names=columnHeaders)
csv_df = csv_df.fillna(0)
csv_df = csv_df.drop(csv_df.index[[0]])
csv_df = csv_df.apply(pd.to_numeric)
csv_df = csv_df.reset_index()
csv_df = csv_df.reset_index(drop=True)
print('Evaluating convex hulls...')
########### MOUSE AREAS ###########################################
csv_df['Mouse_1_poly_area'] = csv_df.apply(lambda x: ConvexHull(np.array(
[[x['Ear_left_1_x'], x["Ear_left_1_y"]],
[x['Ear_right_1_x'], x["Ear_right_1_y"]],
[x['Nose_1_x'], x["Nose_1_y"]],
[x['Lat_left_1_x'], x["Lat_left_1_y"]], \
[x['Lat_right_1_x'], x["Lat_right_1_y"]],
[x['Tail_base_1_x'], x["Tail_base_1_y"]],
[x['Center_1_x'], x["Center_1_y"]]])).area, axis=1)
csv_df['Mouse_1_poly_area'] = csv_df['Mouse_1_poly_area'] / currPixPerMM
csv_df['Mouse_2_poly_area'] = csv_df.apply(lambda x: ConvexHull(np.array(
[[x['Ear_left_2_x'], x["Ear_left_2_y"]],
[x['Ear_right_2_x'], x["Ear_right_2_y"]],
[x['Nose_2_x'], x["Nose_2_y"]],
[x['Lat_left_2_x'], x["Lat_left_2_y"]], \
[x['Lat_right_2_x'], x["Lat_right_2_y"]],
[x['Tail_base_2_x'], x["Tail_base_2_y"]],
[x['Center_2_x'], x["Center_2_y"]]])).area, axis=1)
csv_df['Mouse_2_poly_area'] = csv_df['Mouse_2_poly_area'] / currPixPerMM
########### CREATE SHIFTED DATAFRAME FOR DISTANCE CALCULATIONS ###########################################
csv_df_shifted = csv_df.shift(periods=1)
csv_df_shifted = csv_df_shifted.rename(
columns={'Ear_left_1_x': 'Ear_left_1_x_shifted', 'Ear_left_1_y': 'Ear_left_1_y_shifted',
'Ear_left_1_p': 'Ear_left_1_p_shifted', 'Ear_right_1_x': 'Ear_right_1_x_shifted', \
'Ear_right_1_y': 'Ear_right_1_y_shifted', 'Ear_right_1_p': 'Ear_right_1_p_shifted',
'Nose_1_x': 'Nose_1_x_shifted', 'Nose_1_y': 'Nose_1_y_shifted', \
'Nose_1_p': 'Nose_1_p_shifted', 'Center_1_x': 'Center_1_x_shifted',
'Center_1_y': 'Center_1_y_shifted', 'Center_1_p': 'Center_1_p_shifted', 'Lat_left_1_x': \
'Lat_left_1_x_shifted', 'Lat_left_1_y': 'Lat_left_1_y_shifted',
'Lat_left_1_p': 'Lat_left_1_p_shifted', 'Lat_right_1_x': 'Lat_right_1_x_shifted',
'Lat_right_1_y': 'Lat_right_1_y_shifted', \
'Lat_right_1_p': 'Lat_right_1_p_shifted', 'Tail_base_1_x': 'Tail_base_1_x_shifted',
'Tail_base_1_y': 'Tail_base_1_y_shifted', \
'Tail_base_1_p': 'Tail_base_1_p_shifted', 'Tail_end_1_x': 'Tail_end_1_x_shifted',
'Tail_end_1_y': 'Tail_end_1_y_shifted', 'Tail_end_1_p': 'Tail_end_1_p_shifted',
'Ear_left_2_x': 'Ear_left_2_x_shifted', 'Ear_left_2_y': 'Ear_left_2_y_shifted',
'Ear_left_2_p': 'Ear_left_2_p_shifted', 'Ear_right_2_x': 'Ear_right_2_x_shifted', \
'Ear_right_2_y': 'Ear_right_2_y_shifted', 'Ear_right_2_p': 'Ear_right_2_p_shifted',
'Nose_2_x': 'Nose_2_x_shifted', 'Nose_2_y': 'Nose_2_y_shifted', \
'Nose_2_p': 'Nose_2_p_shifted', 'Center_2_x': 'Center_2_x_shifted',
'Center_2_y': 'Center_2_y_shifted', 'Center_2_p': 'Center_2_p_shifted', 'Lat_left_2_x': \
'Lat_left_2_x_shifted', 'Lat_left_2_y': 'Lat_left_2_y_shifted',
'Lat_left_2_p': 'Lat_left_2_p_shifted', 'Lat_right_2_x': 'Lat_right_2_x_shifted',
'Lat_right_2_y': 'Lat_right_2_y_shifted', \
'Lat_right_2_p': 'Lat_right_2_p_shifted', 'Tail_base_2_x': 'Tail_base_2_x_shifted',
'Tail_base_2_y': 'Tail_base_2_y_shifted', \
'Tail_base_2_p': 'Tail_base_2_p_shifted', 'Tail_end_2_x': 'Tail_end_2_x_shifted',
'Tail_end_2_y': 'Tail_end_2_y_shifted', 'Tail_end_2_p': 'Tail_end_2_p_shifted',
'Mouse_1_poly_area': 'Mouse_1_poly_area_shifted',
'Mouse_2_poly_area': 'Mouse_2_poly_area_shifted'})
csv_df_combined = pd.concat([csv_df, csv_df_shifted], axis=1, join='inner')
csv_df_combined = csv_df_combined.fillna(0)
csv_df_combined = csv_df_combined.reset_index(drop=True)
print('Calculating euclidean distances...')
########### EUCLIDEAN DISTANCES ###########################################
csv_df['Mouse_1_nose_to_tail'] = (np.sqrt((csv_df.Nose_1_x - csv_df.Tail_base_1_x) ** 2 + (
csv_df.Nose_1_y - csv_df.Tail_base_1_y) ** 2)) / currPixPerMM
csv_df['Mouse_2_nose_to_tail'] = (np.sqrt((csv_df.Nose_2_x - csv_df.Tail_base_2_x) ** 2 + (
csv_df.Nose_2_y - csv_df.Tail_base_2_y) ** 2)) / currPixPerMM
csv_df['Mouse_1_width'] = (np.sqrt((csv_df.Lat_left_1_x - csv_df.Lat_right_1_x) ** 2 + (
csv_df.Lat_left_1_y - csv_df.Lat_right_1_y) ** 2)) / currPixPerMM
csv_df['Mouse_2_width'] = (np.sqrt((csv_df.Lat_left_2_x - csv_df.Lat_right_2_x) ** 2 + (
csv_df.Lat_left_2_y - csv_df.Lat_right_2_y) ** 2)) / currPixPerMM
csv_df['Mouse_1_Ear_distance'] = (np.sqrt((csv_df.Ear_left_1_x - csv_df.Ear_right_1_x) ** 2 + (
csv_df.Ear_left_1_y - csv_df.Ear_right_1_y) ** 2)) / currPixPerMM
csv_df['Mouse_2_Ear_distance'] = (np.sqrt((csv_df.Ear_left_2_x - csv_df.Ear_right_2_x) ** 2 + (
csv_df.Ear_left_2_y - csv_df.Ear_right_2_y) ** 2)) / currPixPerMM
csv_df['Mouse_1_Nose_to_centroid'] = (np.sqrt(
(csv_df.Nose_1_x - csv_df.Center_1_x) ** 2 + (csv_df.Nose_1_y - csv_df.Center_1_y) ** 2)) / currPixPerMM
csv_df['Mouse_2_Nose_to_centroid'] = (np.sqrt(
(csv_df.Nose_2_x - csv_df.Center_2_x) ** 2 + (csv_df.Nose_2_y - csv_df.Center_2_y) ** 2)) / currPixPerMM
csv_df['Centroid_distance'] = (np.sqrt(
(csv_df.Center_2_x - csv_df.Center_1_x) ** 2 + (csv_df.Center_2_y - csv_df.Center_1_y) ** 2)) / currPixPerMM
csv_df['Nose_to_nose_distance'] = (np.sqrt(
(csv_df.Nose_2_x - csv_df.Nose_1_x) ** 2 + (csv_df.Nose_2_y - csv_df.Nose_1_y) ** 2)) / currPixPerMM
csv_df['M1_Nose_to_M2_lat_left'] = (np.sqrt(
(csv_df.Nose_1_x - csv_df.Lat_left_2_x) ** 2 + (csv_df.Nose_1_y - csv_df.Lat_left_2_y) ** 2)) / currPixPerMM
csv_df['M1_Nose_to_M2_lat_right'] = (np.sqrt((csv_df.Nose_1_x - csv_df.Lat_right_2_x) ** 2 + (
csv_df.Nose_1_y - csv_df.Lat_right_2_y) ** 2)) / currPixPerMM
csv_df['M2_Nose_to_M1_lat_left'] = (np.sqrt(
(csv_df.Nose_2_x - csv_df.Lat_left_1_x) ** 2 + (csv_df.Nose_2_y - csv_df.Lat_left_1_y) ** 2)) / currPixPerMM
csv_df['M2_Nose_to_M1_lat_right'] = (np.sqrt((csv_df.Nose_2_x - csv_df.Lat_right_1_x) ** 2 + (
csv_df.Nose_2_y - csv_df.Lat_right_1_y) ** 2)) / currPixPerMM
csv_df['M1_Nose_to_M2_tail_base'] = (np.sqrt((csv_df.Nose_1_x - csv_df.Tail_base_2_x) ** 2 + (
csv_df.Nose_1_y - csv_df.Tail_base_2_y) ** 2)) / currPixPerMM
csv_df['M2_Nose_to_M1_tail_base'] = (np.sqrt((csv_df.Nose_2_x - csv_df.Tail_base_1_x) ** 2 + (
csv_df.Nose_2_y - csv_df.Tail_base_1_y) ** 2)) / currPixPerMM
csv_df['Movement_mouse_1_centroid'] = (np.sqrt(
(csv_df_combined.Center_1_x_shifted - csv_df_combined.Center_1_x) ** 2 + (
csv_df_combined.Center_1_y_shifted - csv_df_combined.Center_1_y) ** 2)) / currPixPerMM
csv_df['Movement_mouse_2_centroid'] = (np.sqrt(
(csv_df_combined.Center_2_x_shifted - csv_df_combined.Center_2_x) ** 2 + (
csv_df_combined.Center_2_y_shifted - csv_df_combined.Center_2_y) ** 2)) / currPixPerMM
csv_df['Movement_mouse_1_nose'] = (np.sqrt(
(csv_df_combined.Nose_1_x_shifted - csv_df_combined.Nose_1_x) ** 2 + (
csv_df_combined.Nose_1_y_shifted - csv_df_combined.Nose_1_y) ** 2)) / currPixPerMM
csv_df['Movement_mouse_2_nose'] = (np.sqrt(
(csv_df_combined.Nose_2_x_shifted - csv_df_combined.Nose_2_x) ** 2 + (
csv_df_combined.Nose_2_y_shifted - csv_df_combined.Nose_2_y) ** 2)) / currPixPerMM
csv_df['Movement_mouse_1_tail_base'] = (np.sqrt(
(csv_df_combined.Tail_base_1_x_shifted - csv_df_combined.Tail_base_1_x) ** 2 + (
csv_df_combined.Tail_base_1_y_shifted - csv_df_combined.Tail_base_1_y) ** 2)) / currPixPerMM
csv_df['Movement_mouse_2_tail_base'] = (np.sqrt(
(csv_df_combined.Tail_base_2_x_shifted - csv_df_combined.Tail_base_2_x) ** 2 + (
csv_df_combined.Tail_base_2_y_shifted - csv_df_combined.Tail_base_2_y) ** 2)) / currPixPerMM
csv_df['Movement_mouse_1_tail_end'] = (np.sqrt(
(csv_df_combined.Tail_end_1_x_shifted - csv_df_combined.Tail_end_1_x) ** 2 + (
csv_df_combined.Tail_end_1_y_shifted - csv_df_combined.Tail_end_1_y) ** 2)) / currPixPerMM
csv_df['Movement_mouse_2_tail_end'] = (np.sqrt(
(csv_df_combined.Tail_end_2_x_shifted - csv_df_combined.Tail_end_2_x) ** 2 + (
csv_df_combined.Tail_end_2_y_shifted - csv_df_combined.Tail_end_2_y) ** 2)) / currPixPerMM
csv_df['Movement_mouse_1_left_ear'] = (np.sqrt(
(csv_df_combined.Ear_left_1_x_shifted - csv_df_combined.Ear_left_1_x) ** 2 + (
csv_df_combined.Ear_left_1_x - csv_df_combined.Ear_left_1_y) ** 2)) / currPixPerMM
csv_df['Movement_mouse_2_left_ear'] = (np.sqrt(
(csv_df_combined.Ear_left_2_x_shifted - csv_df_combined.Ear_left_2_x) ** 2 + (
csv_df_combined.Ear_left_2_y_shifted - csv_df_combined.Ear_left_2_y) ** 2)) / currPixPerMM
csv_df['Movement_mouse_1_right_ear'] = (np.sqrt(
(csv_df_combined.Ear_right_1_x_shifted - csv_df_combined.Ear_right_1_x) ** 2 + (
csv_df_combined.Ear_right_1_x - csv_df_combined.Ear_right_1_y) ** 2)) / currPixPerMM
csv_df['Movement_mouse_2_right_ear'] = (np.sqrt(
(csv_df_combined.Ear_right_2_x_shifted - csv_df_combined.Ear_right_2_x) ** 2 + (
csv_df_combined.Ear_right_2_y_shifted - csv_df_combined.Ear_right_2_y) ** 2)) / currPixPerMM
csv_df['Movement_mouse_1_lateral_left'] = (np.sqrt(
(csv_df_combined.Lat_left_1_x_shifted - csv_df_combined.Lat_left_1_x) ** 2 + (
csv_df_combined.Lat_left_1_x - csv_df_combined.Lat_left_1_y) ** 2)) / currPixPerMM
csv_df['Movement_mouse_2_lateral_left'] = (np.sqrt(
(csv_df_combined.Lat_left_2_x_shifted - csv_df_combined.Lat_left_2_x) ** 2 + (
csv_df_combined.Lat_left_2_y_shifted - csv_df_combined.Lat_left_2_y) ** 2)) / currPixPerMM
csv_df['Movement_mouse_1_lateral_right'] = (np.sqrt(
(csv_df_combined.Lat_right_1_x_shifted - csv_df_combined.Lat_right_1_x) ** 2 + (
csv_df_combined.Lat_right_1_x - csv_df_combined.Lat_right_1_y) ** 2)) / currPixPerMM
csv_df['Movement_mouse_2_lateral_right'] = (np.sqrt(
(csv_df_combined.Lat_right_2_x_shifted - csv_df_combined.Lat_right_2_x) ** 2 + (
csv_df_combined.Lat_right_2_y_shifted - csv_df_combined.Lat_right_2_y) ** 2)) / currPixPerMM
csv_df['Mouse_1_polygon_size_change'] = (
csv_df_combined['Mouse_1_poly_area_shifted'] - csv_df_combined['Mouse_1_poly_area'])
csv_df['Mouse_2_polygon_size_change'] = (
csv_df_combined['Mouse_2_poly_area_shifted'] - csv_df_combined['Mouse_2_poly_area'])
print('Calculating hull variables...')
########### HULL - EUCLIDEAN DISTANCES ###########################################
for index, row in csv_df.iterrows():
M1_np_array = np.array(
[[row['Ear_left_1_x'], row["Ear_left_1_y"]], [row['Ear_right_1_x'], row["Ear_right_1_y"]],
[row['Nose_1_x'], row["Nose_1_y"]], [row['Center_1_x'], row["Center_1_y"]],
[row['Lat_left_1_x'], row["Lat_left_1_y"]], [row['Lat_right_1_x'], row["Lat_right_1_y"]],
[row['Tail_base_1_x'], row["Tail_base_1_y"]]]).astype(int)
M2_np_array = np.array(
[[row['Ear_left_2_x'], row["Ear_left_2_y"]], [row['Ear_right_2_x'], row["Ear_right_2_y"]],
[row['Nose_2_x'], row["Nose_2_y"]], [row['Center_2_x'], row["Center_2_y"]],
[row['Lat_left_2_x'], row["Lat_left_2_y"]], [row['Lat_right_2_x'], row["Lat_right_2_y"]],
[row['Tail_base_2_x'], row["Tail_base_2_y"]]]).astype(int)
M1_dist_euclidean = scipy.spatial.distance.cdist(M1_np_array, M1_np_array, metric='euclidean')
M1_dist_euclidean = M1_dist_euclidean[M1_dist_euclidean != 0]
M1_hull_large_euclidean = np.amax(M1_dist_euclidean)
M1_hull_small_euclidean = | np.min(M1_dist_euclidean) | numpy.min |
import torch
from torch import nn
from torch import distributions
import numpy as np
import pfrl
from pfrl import explorers
from pfrl.replay_buffer import high_level_batch_experiences_with_goal
from pfrl.agents import HIROHighLevelGoalConditionedTD3, GoalConditionedTD3
from pfrl.nn import ConstantsMult
from pfrl.nn.lmbda import Lambda
class HRLControllerBase():
def __init__(
self,
state_dim,
goal_dim,
action_dim,
scale,
replay_buffer,
actor_lr,
critic_lr,
expl_noise,
policy_noise,
noise_clip,
gamma,
policy_freq,
tau,
is_low_level,
buffer_freq,
minibatch_size,
gpu,
add_entropy,
burnin_action_func=None,
replay_start_size=2500):
self.scale = scale
# parameters
self.expl_noise = expl_noise
self.policy_noise = policy_noise
self.noise_clip = noise_clip
self.gamma = gamma
self.policy_freq = policy_freq
self.tau = tau
self.is_low_level = is_low_level
self.minibatch_size = minibatch_size
self.add_entropy = add_entropy
# create td3 agent
self.device = torch.device(f'cuda:{gpu}')
if self.add_entropy:
def squashed_diagonal_gaussian_head(x):
mean, log_scale = torch.chunk(x, 2, dim=-1)
log_scale = torch.clamp(log_scale, -20.0, 2.0)
var = torch.exp(log_scale * 2)
base_distribution = distributions.Independent(
distributions.Normal(loc=mean, scale=torch.sqrt(var)), 1
)
return base_distribution
policy = nn.Sequential(
nn.Linear(state_dim + goal_dim, 300),
nn.ReLU(),
nn.Linear(300, 300),
nn.ReLU(),
nn.Linear(300, action_dim * 2),
nn.Tanh(),
ConstantsMult(torch.cat((torch.tensor(self.scale), torch.ones(self.scale.size))).float().to(self.device)),
# pfrl.policies.DeterministicHead(),
Lambda(squashed_diagonal_gaussian_head),
)
else:
policy = nn.Sequential(
nn.Linear(state_dim + goal_dim, 300),
nn.ReLU(),
nn.Linear(300, 300),
nn.ReLU(),
nn.Linear(300, action_dim),
nn.Tanh(),
ConstantsMult(torch.tensor(self.scale).float().to(self.device)),
pfrl.policies.DeterministicHead(),
)
policy_optimizer = torch.optim.Adam(policy.parameters(), lr=actor_lr)
def make_q_func_with_optimizer():
q_func = nn.Sequential(
pfrl.nn.ConcatObsAndAction(),
nn.Linear(state_dim + goal_dim + action_dim, 300),
nn.ReLU(),
nn.Linear(300, 300),
nn.ReLU(),
nn.Linear(300, 1),
)
q_func_optimizer = torch.optim.Adam(q_func.parameters(), lr=critic_lr)
return q_func, q_func_optimizer
q_func1, q_func1_optimizer = make_q_func_with_optimizer()
q_func2, q_func2_optimizer = make_q_func_with_optimizer()
# TODO - have proper low and high values from action space.
# from the hiro paper, the scale is 1.0
explorer = explorers.AdditiveGaussian(
scale=self.expl_noise*1.0,
low=-self.scale,
high=self.scale
)
def default_target_policy_smoothing_func(batch_action):
"""Add noises to actions for target policy smoothing."""
noise = torch.clamp(self.policy_noise * torch.randn_like(batch_action), -self.noise_clip, self.noise_clip)
smoothed_action = batch_action + noise
smoothed_action = torch.min(smoothed_action, torch.tensor(self.scale).to(self.device).float())
smoothed_action = torch.max(smoothed_action, torch.tensor(-self.scale).to(self.device).float())
return smoothed_action
if self.is_low_level:
# standard goal conditioned td3
self.agent = GoalConditionedTD3(
policy,
q_func1,
q_func2,
policy_optimizer,
q_func1_optimizer,
q_func2_optimizer,
replay_buffer,
gamma=gamma,
soft_update_tau=tau,
explorer=explorer,
update_interval=1,
policy_update_delay=policy_freq,
replay_start_size=replay_start_size,
buffer_freq=buffer_freq,
minibatch_size=minibatch_size,
gpu=gpu,
add_entropy=self.add_entropy,
burnin_action_func=burnin_action_func,
target_policy_smoothing_func=default_target_policy_smoothing_func
)
else:
self.agent = HIROHighLevelGoalConditionedTD3(
policy,
q_func1,
q_func2,
policy_optimizer,
q_func1_optimizer,
q_func2_optimizer,
replay_buffer,
gamma=gamma,
soft_update_tau=tau,
explorer=explorer,
update_interval=1,
policy_update_delay=policy_freq,
replay_start_size=replay_start_size/buffer_freq,
buffer_freq=buffer_freq,
minibatch_size=minibatch_size,
gpu=gpu,
add_entropy=self.add_entropy,
burnin_action_func=burnin_action_func,
target_policy_smoothing_func=default_target_policy_smoothing_func
)
self.device = self.agent.device
def save(self, directory):
"""
save the internal state of the TD3 agent.
"""
self.agent.save(directory)
def load(self, directory):
"""
load the internal state of the TD3 agent.
"""
self.agent.load(directory)
def policy(self, state, goal):
"""
run the policy (actor).
"""
action = self.agent.act_with_goal(torch.FloatTensor(state), torch.FloatTensor(goal))
return np.clip(action, a_min=-self.scale, a_max=self.scale)
def _observe(self, states, goals, rewards, done, state_arr=None, action_arr=None):
"""
observe, and train (if we can sample from the replay buffer)
"""
self.agent.observe_with_goal(torch.FloatTensor(states), torch.FloatTensor(goals), rewards, done, None)
def observe(self, states, goals, rewards, done, iterations=1):
"""
get data from the replay buffer, and train.
"""
return self._observe(states, goals, rewards, goals, done)
# lower controller
class LowerController(HRLControllerBase):
def __init__(
self,
state_dim,
goal_dim,
action_dim,
scale,
replay_buffer,
add_entropy,
actor_lr=0.0001,
critic_lr=0.001,
expl_noise=0.1,
policy_noise=0.2,
noise_clip=0.5,
gamma=0.99,
policy_freq=2,
tau=0.005,
is_low_level=True,
buffer_freq=10,
minibatch_size=100,
gpu=None,
burnin_action_func=None):
super(LowerController, self).__init__(
state_dim=state_dim,
goal_dim=goal_dim,
action_dim=action_dim,
scale=scale,
replay_buffer=replay_buffer,
actor_lr=actor_lr,
critic_lr=critic_lr,
expl_noise=expl_noise,
policy_noise=policy_noise,
noise_clip=noise_clip,
gamma=gamma,
policy_freq=policy_freq,
tau=tau,
is_low_level=is_low_level,
buffer_freq=buffer_freq,
minibatch_size=minibatch_size,
gpu=gpu,
add_entropy=add_entropy,
burnin_action_func=burnin_action_func)
def observe(self, n_s, g, r, done):
return self._observe(n_s, g, r, done)
# higher controller
class HigherController(HRLControllerBase):
def __init__(
self,
state_dim,
goal_dim,
action_dim,
scale,
replay_buffer,
add_entropy,
actor_lr=0.0001,
critic_lr=0.001,
expl_noise=0.1,
policy_noise=0.2,
noise_clip=0.5,
gamma=0.99,
policy_freq=2,
tau=0.005,
is_low_level=False,
buffer_freq=10,
minibatch_size=100,
gpu=None,
burnin_action_func=None):
super(HigherController, self).__init__(
state_dim=state_dim,
goal_dim=goal_dim,
action_dim=action_dim,
scale=scale,
replay_buffer=replay_buffer,
actor_lr=actor_lr,
critic_lr=critic_lr,
expl_noise=expl_noise,
policy_noise=policy_noise,
noise_clip=noise_clip,
gamma=gamma,
policy_freq=policy_freq,
tau=tau,
is_low_level=is_low_level,
buffer_freq=buffer_freq,
minibatch_size=minibatch_size,
gpu=gpu,
add_entropy=add_entropy,
burnin_action_func=burnin_action_func)
self.action_dim = action_dim
def _off_policy_corrections(self, low_con, batch_size, sgoals, states, actions, candidate_goals=8):
"""
implementation of the novel off policy correction in the HIRO paper.
"""
first_s = [s[0] for s in states] # First x
last_s = [s[-1] for s in states] # Last x
# Shape: (batch_size, 1, subgoal_dim)
# diff = 1
# different in goals
diff_goal = (np.array(last_s) -
np.array(first_s))[:, np.newaxis, :self.action_dim]
# Shape: (batch_size, 1, subgoal_dim)
# original = 1
# random = candidate_goals
original_goal = | np.array(sgoals) | numpy.array |
"""TODO: Summary
"""
import numpy as np
import numba as nb
import numba.types as nt
from homog import is_homog_xform
from worms import util
from worms.bblock import chain_of_ires, _BBlock
from logging import warning
import concurrent.futures as cf
from worms.util import InProcessExecutor, jit
from worms.criteria import cyclic
vertex_xform_dtype = np.float32
@nb.jitclass(
(
("x2exit", nb.typeof(vertex_xform_dtype(0))[:, :, :]),
("x2orig", nb.typeof(vertex_xform_dtype(0))[:, :, :]),
("inout", nt.int32[:, :]),
("inbreaks", nt.int32[:]),
("ires", nt.int32[:, :]),
("isite", nt.int32[:, :]),
("ichain", nt.int32[:, :]),
("ibblock", nt.int32[:]),
("dirn", nt.int32[:]),
("min_seg_len", nt.int32),
)
) # yapf: disable
class _Vertex:
"""contains data for one topological vertex in the topological ssdag
Attributes:
dirn (TYPE): Description
ibblock (TYPE): Description
ichain (TYPE): Description
inout (TYPE): Description
ires (TYPE): Description
isite (TYPE): Description
x2exit (TYPE): Description
x2orig (TYPE): Description
"""
def __init__(
self,
x2exit,
x2orig,
ires,
isite,
ichain,
ibblock,
inout,
inbreaks,
dirn,
min_seg_len,
):
"""TODO: Summary
Args:
x2exit (TYPE): Description
x2orig (TYPE): Description
ires (TYPE): Description
isite (TYPE): Description
ichain (TYPE): Description
ibblock (TYPE): Description
inout (TYPE): Description
dirn (TYPE): Description
Deleted Parameters:
bblock (TYPE): Description
"""
self.x2exit = x2exit.astype(vertex_xform_dtype)
self.x2orig = x2orig.astype(vertex_xform_dtype)
self.ires = ires
self.isite = isite
self.ichain = ichain
self.ibblock = ibblock
self.inout = inout
self.inbreaks = inbreaks
self.dirn = dirn
self.min_seg_len = min_seg_len
@property
def entry_index(self):
return self.inout[:, 0]
@property
def exit_index(self):
return self.inout[:, 1]
def entry_range(self, ienter):
assert ienter >= 0, "vertex.py bad ienter, < 0"
assert ienter <= len(self.inbreaks), "vertex.py bad ienter"
return self.inbreaks[ienter], self.inbreaks[ienter + 1]
def reduce_to_only_one_inplace(self, idx):
self.x2exit = self.x2exit[idx:idx + 1]
self.x2orig = self.x2orig[idx:idx + 1]
self.ires = self.ires[idx:idx + 1]
self.isite = self.isite[idx:idx + 1]
self.ichain = self.ichain[idx:idx + 1]
self.ibblock = self.ibblock[idx:idx + 1]
self.inout = np.zeros((1, 2), dtype=np.int32)
self.inbreaks = np.zeros(2, dtype=np.int32)
self.inbreaks[1] = 1
@property
def len(self):
return len(self.ires)
@property
def _state(self):
return (
self.x2exit,
self.x2orig,
self.ires,
self.isite,
self.ichain,
self.ibblock,
self.inout,
self.inbreaks,
self.dirn,
self.min_seg_len,
)
@property
def memuse(self):
return (self.x2exit.size * self.x2exit.itemsize + self.x2orig.size * self.x2orig.itemsize)
# ('inout' , nt.int32[:, :]),
# ('inbreaks', nt.int32[:]),
# ('ires' , nt.int32[:, :]),
# ('isite' , nt.int32[:, :]),
# ('ichain' , nt.int32[:, :]),
# ('ibblock' , nt.int32[:]),
# ('dirn' , nt.int32[:]),
# ('min_seg_len', nt.int32),
@jit
def _check_inorder(ires):
for i in range(len(ires) - 1):
if ires[i] > ires[i + 1]:
return False
return True
def vertex_single(bbstate, bbid, din, dout, min_seg_len, verbosity=0):
"""build on bblock's worth of vertex"""
bb = _BBlock(*bbstate)
ires0, ires1 = [], []
isite0, isite1 = [], []
for i in range(bb.n_connections):
ires = bb.conn_resids(i)
if bb.conn_dirn(i) == din:
ires0.append(ires)
isite0.append(np.repeat(i, len(ires)))
if bb.conn_dirn(i) == dout:
ires1.append(ires)
isite1.append(np.repeat(i, len(ires)))
dirn = "NC_" [din] + "NC_" [dout]
if din < 2 and not ires0 or dout < 2 and not ires1:
if verbosity > 0:
warning("invalid vertex " + dirn + " " + bytes(bb.file).decode())
return None
dummy = [np.array([-1], dtype="i4")]
ires0 = np.concatenate(ires0 or dummy)
ires1 = np.concatenate(ires1 or dummy)
isite0 = np.concatenate(isite0 or dummy)
isite1 = np.concatenate(isite1 or dummy)
chain0 = chain_of_ires(bb, ires0)
chain1 = chain_of_ires(bb, ires1)
if ires0[0] == -1:
assert len(ires0) is 1
else:
assert np.all(ires0 >= 0)
if ires1[0] == -1:
assert len(ires1) is 1
else:
assert np.all(ires1 >= 0)
if ires0[0] == -1:
stub0inv = np.eye(4).reshape(1, 4, 4)
else:
stub0inv = np.linalg.inv(bb.stubs[ires0])
if ires1[0] == -1:
stub1 = np.eye(4).reshape(1, 4, 4)
else:
stub1 = bb.stubs[ires1]
assert _check_inorder(ires0)
assert _check_inorder(ires1)
stub0inv, stub1 = np.broadcast_arrays(stub0inv[:, None], stub1)
ires = np.stack(np.broadcast_arrays(ires0[:, None], ires1), axis=-1)
isite = np.stack(np.broadcast_arrays(isite0[:, None], isite1), axis=-1)
chain = np.stack(np.broadcast_arrays(chain0[:, None], chain1), axis=-1)
x2exit = stub0inv @ stub1
x2orig = stub0inv
# assert is_homog_xform(x2exit) # this could be slowish
# assert is_homog_xform(x2orig)
# min chain len, not same site
not_same_chain = chain[..., 0] != chain[..., 1]
not_same_site = isite[..., 0] != isite[..., 1]
seqsep = np.abs(ires[..., 0] - ires[..., 1])
# remove invalid in/out pairs (+ is or, * is and)
valid = not_same_site
valid *= not_same_chain + (seqsep >= min_seg_len)
valid = valid.reshape(-1)
if np.sum(valid) == 0:
return None
return (
x2exit.reshape(-1, 4, 4)[valid],
x2orig.reshape(-1, 4, 4)[valid],
ires.reshape(-1, 2)[valid].astype("i4"),
isite.reshape(-1, 2)[valid].astype("i4"),
chain.reshape(-1, 2)[valid].astype("i4"),
np.repeat(bbid, np.sum(valid)).astype("i4"),
)
@jit
def _check_bbires_inorder(ibblock, ires):
prev = -np.ones(np.max(ibblock) + 1, dtype=np.int32)
for i in range(len(ires)):
if ires[i] >= 0:
if ires[i] < prev[ibblock[i]]:
# print('_check_bbires_inorder err', i)
return False
prev[ibblock[i]] = ires[i]
return True
def Vertex(bbs, dirn, bbids=None, min_seg_len=1, verbosity=0):
dirn_map = {"N": 0, "C": 1, "_": 2}
din = dirn_map[dirn[0]]
dout = dirn_map[dirn[1]]
if bbids is None:
bbids = np.arange(len(bbs))
# exe = cf.ProcessPoolExecutor if parallel else InProcessExecutor
# with exe() as pool:
# futures = list()
# for bb, bid in zip(bbs, bbids):
# futures.append(
# pool.
# submit(vertex_single, bb._state, bid, din, dout, min_seg_len)
# )
# verts = [f.result() for f in futures]
verts = [
vertex_single(bb._state, bid, din, dout, min_seg_len, verbosity=verbosity)
for bb, bid in zip(bbs, bbids)
]
verts = [v for v in verts if v is not None]
if not verts:
raise ValueError("no way to make vertex: '" + dirn + "'")
tup = tuple(np.concatenate(_) for _ in zip(*verts))
assert len({x.shape[0] for x in tup}) == 1
ibblock, ires = tup[5], tup[2]
# print(np.stack((ibblock, ires[:, 1])).T)
assert _check_bbires_inorder(ibblock, ires[:, 0])
# not true as some pruned from validity checks
# assert _check_bbires_inorder(ibblock, ires[:, 1])
inout = np.stack(
[
util.unique_key_int32s(ibblock, ires[:, 0]),
util.unique_key_int32s(ibblock, ires[:, 1]),
],
axis=-1,
).astype(
"i4"
) # yapf: disable
# inout2 = np.stack([
# util.unique_key(ibblock, ires[:, 0]),
# util.unique_key(ibblock, ires[:, 1])
# ],
# axis=-1).astype('i4')
# if not np.all(inout == inout2):
# np.set_printoptions(threshold=np.nan)
# print(
# np.stack((
# inout[:, 0], inout2[:, 0], ibblock, ires[:, 0], inout[:, 1],
# inout2[:, 1], ibblock, ires[:, 1]
# )).T
# )
# assert inout.shape == inout2.shape
# assert np.all(inout == inout2)
inbreaks = util.contig_idx_breaks(inout[:, 0])
assert inbreaks.dtype == np.int32
assert np.all(inbreaks <= len(inout))
return _Vertex(*tup, inout, inbreaks, | np.array([din, dout], dtype="i4") | numpy.array |
import numpy as np
from sfsimodels.models.abstract_models import PhysicalObject
from sfsimodels.models.systems import TwoDSystem
from sfsimodels.functions import interp_left, interp2d, interp3d
from .fns import remove_close_items, build_ele2_node_array
import hashlib
def sort_slopes(sds):
"""Sort slopes from bottom to top then right to left"""
sds = np.array(sds)
scores = sds[:, 0, 1] + sds[:, 1, 1] * 1e6
inds = np.argsort(scores)
return sds[inds]
def adjust_slope_points_for_removals(sds, x, removed_y, retained_y):
for sd in sds:
for i in range(2):
if sd[0][i] == x and sd[1][i] == removed_y:
sd[1][i] = retained_y
def adj_slope_by_layers(xm, ym, sgn=1):
"""
Given mesh coordinates, adjust the mesh to be match the slope by adjust each layer
bottom left and top right coords of mesh are the slope
Parameters
----------
xm
ym
x_slope - NOT needed
y_slope
Returns
-------
"""
# TODO use centroid formula - and use o3plot to get ele-coords
ym = sgn * np.array(ym)
xm = sgn * np.array(xm)
if sgn == -1:
xm = xm[::-1]
ym = ym[::-1]
nh = len(ym[0]) - 1
# dy = min([(ym[0][-1] - ym[0][0]) / nh, (ym[-1][-1] - ym[-1][0]) / nh, 0.2])
dy1 = min([(ym[-1][-1] - ym[-1][0]) / nh])
dy0 = 0.2
y0s = ym[0][0] + np.arange(nh + 1) * dy0
y1s = ym[-1][-1] - np.arange(nh + 1) * dy1
y1s = y1s[::-1]
for i in range(nh + 1):
ym[:, i] = np.interp(xm[:, i], [xm[0][0], xm[-1][-1]], [y0s[i], y1s[i]])
xm[:, i] = xm[:, 0]
y_centres_at_xns = (ym[1:] + ym[:-1]) / 2
y_centres = (y_centres_at_xns[:, 1:] + y_centres_at_xns[:, :-1]) / 2
# get x-coordinates of centres of relevant elements
included_ele = []
dy_inds = len(ym[0, :]) - 1
for i in range(0, dy_inds):
# account for shift before assessing position of centroid
xcens = (xm[1:, i] + xm[:-1, i]) / 2 + 0.375 * (xm[1:, -1] - xm[:-1, -1])
y_surf_at_x_cens = np.interp(xcens, [xm[0][0], xm[-1][-1]], [ym[0][0], ym[-1][-1]])
inds = np.where(y_centres[:, i] < y_surf_at_x_cens)
if len(inds[0]):
included_ele.append(inds[0][0])
else:
included_ele.append(len(y_surf_at_x_cens))
included_ele.append(len(y_surf_at_x_cens))
new_xm = xm
new_ym = ym
for j in range(1, nh + 1):
new_ym[included_ele[0], j] += dy1
for i in range(1, dy_inds + 1):
x_ind_adj = included_ele[i - 1]
x_ind_adj_next = included_ele[i]
if x_ind_adj == x_ind_adj_next:
continue
# shift by half of the ele
dx = (xm[x_ind_adj + 1, i] - xm[x_ind_adj, i]) * 0.5
dxs = np.interp(xm[x_ind_adj:x_ind_adj_next, i], [xm[x_ind_adj, i], xm[x_ind_adj_next, i]], [dx, 0])
new_xm[x_ind_adj:x_ind_adj_next, i] = xm[x_ind_adj:x_ind_adj_next, i] + dxs
for j in range(i + 1, nh + 1):
new_ym[x_ind_adj_next, j] += dy1
if sgn == -1:
new_xm = new_xm[::-1]
new_ym = new_ym[::-1]
return new_xm * sgn, new_ym * sgn
def calc_centroid(xs, ys):
import numpy as np
x0 = np.array(xs)
y0 = np.array(ys)
x1 = np.roll(xs, 1, axis=-1)
y1 = np.roll(ys, 1, axis=-1)
a = x0 * y1 - x1 * y0
xc = np.sum((x0 + x1) * a, axis=-1)
yc = np.sum((y0 + y1) * a, axis=-1)
area = 0.5 * np.sum(a, axis=-1)
xc /= (6.0 * area)
yc /= (6.0 * area)
return xc, yc
def calc_mesh_centroids(fem):
x_inds = []
y_inds = []
if hasattr(fem.y_nodes[0], '__len__'): # can either have varying y-coordinates or single set
n_y = len(fem.y_nodes[0])
else:
n_y = 0
import numpy as np
for xx in range(len(fem.soil_grid)):
x_ele = [xx, xx + 1, xx + 1, xx]
x_inds += [x_ele for i in range(n_y - 1)]
for yy in range(len(fem.soil_grid[xx])):
y_ele = [yy, yy, yy + 1, yy + 1]
y_inds.append(y_ele)
n_eles = len(np.array(x_inds))
x_inds = np.array(x_inds).flatten()
y_inds = np.array(y_inds).flatten()
x0 = np.array(fem.x_nodes[x_inds, y_inds])
y0 = np.array(fem.y_nodes[x_inds, y_inds])
x0 = x0.reshape((n_eles, 4))
y0 = y0.reshape((n_eles, 4))
x1 = np.roll(x0, 1, axis=-1)
y1 = np.roll(y0, 1, axis=-1)
a = x0 * y1 - x1 * y0
xc = np.sum((x0 + x1) * a, axis=-1)
yc = np.sum((y0 + y1) * a, axis=-1)
area = 0.5 * np.sum(a, axis=-1)
xc /= (6.0 * area)
yc /= (6.0 * area)
return xc.reshape(len(fem.soil_grid), len(fem.soil_grid[0])), yc.reshape(len(fem.soil_grid), len(fem.soil_grid[0]))
class FiniteElementVary2DMeshConstructor(object): # maybe FiniteElementVertLine2DMesh
_soils = None
x_index_to_sp_index = None
_inactive_value = 1000000
def __init__(self, tds, dy_target, x_scale_pos=None, x_scale_vals=None, dp: int = None, fd_eles=0, auto_run=True,
use_3d_interp=False, smooth_surf=False, force_x2d=False, min_scale=0.5, max_scale=2.0,
allowable_slope=0.25, smooth_ratio=1.):
"""
Builds a finite element mesh of a two-dimension system
Parameters
----------
tds: TwoDSystem
A two dimensional system of models
dy_target: float
Target height of elements
x_scale_pos: array_like
x-positions used to provide scale factors for element widths
x_scale_vals: array_like
scale factors for element widths
dp: int
Number of decimal places
fd_eles: int
if =0 then elements corresponding to the foundation are removed, else provide element id
smooth_surf: bool
if true then changes in angle of the slope must be less than 90 degrees, builds VaryXY mesh
"""
self.min_scale = min_scale
self.max_scale = max_scale
self.allowable_slope = allowable_slope
self.smooth_ratio = smooth_ratio
assert isinstance(tds, TwoDSystem)
self.tds = tds
self.dy_target = dy_target
if x_scale_pos is None:
x_scale_pos = [0, tds.width]
if x_scale_vals is None:
x_scale_vals = [1., 1.]
self.x_scale_pos = np.array(x_scale_pos)
self.x_scale_vals = np.array(x_scale_vals)
self.dp = dp
self.xs = list(self.tds.x_sps)
self.smooth_surf = smooth_surf
self.xs.append(tds.width)
self.xs = np.array(self.xs)
inds = np.where(np.array(tds.x_surf) <= tds.width)
self.x_surf = np.array(tds.x_surf)[inds]
if tds.width not in self.x_surf:
self.x_surf = np.insert(self.x_surf, len(self.x_surf), tds.width)
self.y_surf = np.interp(self.x_surf, tds.x_surf, tds.y_surf)
self.y_surf_at_sps = np.interp(self.xs, tds.x_surf, tds.y_surf)
self._soils = []
self._soil_hashes = []
for i in range(len(self.tds.sps)):
for yy in range(1, self.tds.sps[i].n_layers + 1):
sl = self.tds.sps[i].layer(yy)
if sl.unique_hash not in self._soil_hashes:
self._soil_hashes.append(sl.unique_hash)
self._soils.append(sl)
self.y_surf_at_xcs = None
self.yd = None
self.xcs_sorted = None
self.sds = None
self.y_blocks = None
self.y_coords_at_xcs = None
self.x_nodes = None
self.y_nodes = None
self.x_nodes2d = None
self._femesh = None
if auto_run:
self.get_special_coords_and_slopes() # Step 1
self.set_init_y_blocks()
self.adjust_blocks_to_be_consistent_with_slopes()
self.trim_grid_to_target_dh()
self.build_req_y_node_positions()
self.set_x_nodes()
if use_3d_interp:
self.build_y_coords_grid_via_3d_interp()
else:
self.build_y_coords_grid_via_propagation()
if self.dp is not None:
self.set_to_decimal_places()
if smooth_surf:
self.adjust_for_smooth_surface()
self.set_soil_ids_to_vary_xy_grid()
elif force_x2d:
self.x_nodes2d = self.x_nodes[:, np.newaxis] * np.ones_like(self.y_nodes)
self.set_soil_ids_to_vary_xy_grid()
else:
self.set_soil_ids_to_vary_y_grid()
self.create_mesh()
if smooth_surf:
self.femesh.tidy_unused_mesh()
if not fd_eles:
self.exclude_fd_eles()
def get_special_coords_and_slopes(self):
"""Find the coordinates, layer boundaries and surface slopes that should be maintained in the FE mesh"""
fd_coords = []
x_off = 0.0
yd = {}
for i in range(len(self.x_surf)):
yd[self.x_surf[i]] = []
if self.tds.width not in yd:
yd[self.tds.width] = []
sds = [] # slope dict (stored left-to-right and bottom-to-top)
for i in range(len(self.tds.bds)):
x_bd = self.tds.x_bds[i]
bd = self.tds.bds[i]
fd_centre_x = x_bd + bd.x_fd
y_surf = np.interp(fd_centre_x, self.x_surf, self.y_surf)
if bd.fd.width > self.dy_target:
fd_coords.append(fd_centre_x)
x_left = fd_centre_x - bd.fd.width / 2
x_right = fd_centre_x + bd.fd.width / 2
if x_left not in yd:
yd[x_left] = []
yd[x_left] += [y_surf, -bd.fd.depth + y_surf]
if x_right not in yd:
yd[x_right] = []
yd[x_right] += [y_surf, -bd.fd.depth + y_surf]
sds.append([[x_left, x_right], [y_surf, y_surf]])
sds.append([[x_left, x_right], [-bd.fd.depth + y_surf, -bd.fd.depth + y_surf]])
for i in range(len(self.tds.sps)):
x_curr = self.tds.x_sps[i]
if x_curr > self.tds.width:
continue
if i == len(self.tds.sps) - 1:
x_next = self.tds.width
else:
x_next = self.tds.x_sps[i + 1] - x_off
# get important x-coordinates that are between two soil profiles
if x_curr not in yd:
yd[x_curr] = []
if x_next not in yd and x_next < self.tds.width:
yd[x_next] = []
x_coords = np.array(list(yd))
inds = np.where((x_coords >= x_curr) & (x_coords <= x_next))
xs = np.sort(x_coords[inds])
y_surf_at_xs = np.interp(xs, self.x_surf, self.y_surf)
y_curr_surf = y_surf_at_xs[0]
# Depths from defined soil profile
int_yy = []
angles = []
for yy in range(1, self.tds.sps[i].n_layers + 1):
# if self.tds.sps[i].layer_depth(yy) >= 0:
y = -self.tds.sps[i].layer_depth(yy) + y_curr_surf
if -y < self.tds.height:
int_yy.append(y)
angles.append(self.tds.sps[i].x_angles[yy - 1])
angles = np.array(angles)
if xs[0] not in yd:
yd[xs[0]] = []
for j in range(len(xs) - 1):
x0 = xs[j]
x_next = xs[j + 1]
if x_next not in yd:
yd[x_next] = []
x0_diff = x0 - x_curr
xn_diff = x_next - x_curr
if y_surf_at_xs[j] not in yd[x0]:
yd[x0].append(y_surf_at_xs[j])
if y_surf_at_xs[j + 1] not in yd[x_next]:
yd[x_next].append(y_surf_at_xs[j + 1])
for k in range(len(int_yy)):
if angles[k] is None or np.isnan(angles[k]):
continue
y_curr = int_yy[k] + angles[k] * x0_diff
if y_curr < y_surf_at_xs[j] and y_curr not in yd[x0]:
yd[x0].append(y_curr)
y_next = int_yy[k] + angles[k] * xn_diff
if y_next < y_surf_at_xs[j + 1] and y_next not in yd[x_next]:
yd[x_next].append(y_next)
if y_curr <= y_surf_at_xs[j] and y_next <= y_surf_at_xs[j + 1]:
sds.append([[x0, x_next], [y_curr, y_next]])
for x in yd:
yd[x].append(-self.tds.height)
yd[x].append(np.interp(x, self.x_surf, self.y_surf))
yd[x] = list(set(yd[x]))
yd[x].sort()
xcs = list(yd)
xcs.sort()
xcs = np.array(xcs)
for i in range(len(xcs) - 1):
xs = np.array([xcs[i], xcs[i + 1]])
slope = [list(xs), list(np.interp(xs, self.x_surf, self.y_surf))]
if abs(slope[1][1] - slope[1][0]) / (slope[0][1] - slope[0][0]) > 0.8:
continue
if slope not in sds:
sds.append(slope)
y_surf_max = max(self.y_surf)
# remove coordinates that are too close
min_y = self.dy_target * self.min_scale
tol = self.dy_target * self.min_scale
for x in yd:
yd[x], pairs = remove_close_items(yd[x], tol=tol)
for pair in pairs:
adjust_slope_points_for_removals(sds, x, pair[0], pair[1])
self.y_surf_at_xcs = {}
for x in yd:
self.y_surf_at_xcs[x] = yd[x][-1]
if y_surf_max not in yd[x] and abs(y_surf_max - max(yd[x])) > tol:
yd[x] = np.insert(yd[x], len(yd[x]), y_surf_max)
yd[x] = np.array(yd[x])
self.yd = yd
x_act = list(self.yd)
x_act.sort()
self.xcs_sorted = np.array(x_act)
self.sds = sort_slopes(sds)
def set_init_y_blocks(self):
"""For each significant vertical line, assign initial number of elements between each special y-coordinate"""
xcs = self.xcs_sorted
y_steps = []
y_blocks = {}
# Step 1: Define an initial set of y_node coordinates at each x-special-position
h_target = self.dy_target
yd_init_inds = []
for i in range(len(xcs)):
xc0 = xcs[i]
y_blocks[xc0] = []
y_steps.append([])
yd_init_inds.append([0])
for j in range(1, len(self.yd[xc0])):
h_diff = -(self.yd[xc0][j - 1] - self.yd[xc0][j])
n_blocks = int(np.round(h_diff / h_target))
if n_blocks == 0:
n_blocks = 1
y_blocks[xc0].append(n_blocks)
n_blocks = [sum(y_blocks[xcs]) for xcs in y_blocks]
n_max = max(n_blocks)
# Step 2: make sure that each column has same number of temp y positions
# - first check if n_blocks less than maximum,
# - if less then add extra elements to the largest thickness
for i in range(len(xcs)):
xc0 = xcs[i]
if len(y_steps[i]) < n_max:
n_extra = n_max - n_blocks[i] # number of blocks to add
h_diffs = np.diff(self.yd[xc0]) # thickness of each zone
for nn in range(n_extra):
dh_options = h_diffs / (np.array(y_blocks[xc0]) + 1)
# index of the zone with thickest average element, where new element will be added
ind_max = np.argmax(dh_options)
y_blocks[xc0][ind_max] += 1
self.y_blocks = y_blocks
def adjust_blocks_to_be_consistent_with_slopes(self):
"""Change the number of elements between special y-coords to try to maintain defined slopes"""
min_dh = self.min_scale * self.dy_target
max_dh = self.max_scale * self.dy_target
xcs = list(self.yd)
xcs.sort()
xcs = np.array(xcs)
yd_list = [self.yd[xc] for xc in xcs]
# yd_list = list(self.yd.values())
# Step 3: For each defined slope, check that the grid is consistent with the slope
# - cycle through moving left to right and bot to top
# - if not consistent then change thickness of elements in zones above and below on right side.
mdirs = [1, -1] # TODO: alternative between forward and reverse add
dd = 0
mdir = mdirs[dd]
old_hash = ''
for pp in range(100):
sds = self.sds[::mdir]
csum_y_blocks = [np.cumsum(self.y_blocks[xcs]) for xcs in self.y_blocks]
fblocks = np.array([j for i in csum_y_blocks for j in i], dtype=int)
new_hash = hashlib.md5(fblocks).hexdigest()
if new_hash == old_hash:
break
old_hash = new_hash
for qq, sd in enumerate(sds):
csum_y_blocks = [np.cumsum(self.y_blocks[xcs]) for xcs in self.y_blocks]
if mdir == 1:
x0 = sd[0][0]
x1 = sd[0][1]
y0 = sd[1][0]
y1 = sd[1][1]
else:
x0 = sd[0][1]
x1 = sd[0][0]
y0 = sd[1][1]
y1 = sd[1][0]
ind_x0 = int(np.argmin(abs(xcs - x0)))
ind_x1 = int(np.argmin(abs(xcs - x1)))
ind_y0 = int(np.argmin(abs(np.array(yd_list[ind_x0]) - y0)))
ind_y1 = int(np.argmin(abs(np.array(yd_list[ind_x1]) - y1)))
x1_c = xcs[ind_x1]
y1_c = yd_list[ind_x1][ind_y1]
nb0 = csum_y_blocks[ind_x0][ind_y0 - 1]
nb1 = csum_y_blocks[ind_x1][ind_y1 - 1]
sgn = int(np.sign(y1 - y0))
dh_dzone = y1 - y0
slope = dh_dzone / (x1 - x0)
if abs(slope) < self.allowable_slope and nb0 == nb1:
continue
if abs(slope) > self.allowable_slope and self.smooth_surf: # TODO: and on surface and n1 - n0 sign is same
y_surf0 = np.interp(x0, self.x_surf, self.y_surf)
y_surf1 = np.interp(x1, self.x_surf, self.y_surf)
if np.isclose(y_surf0, y0, atol=self.dy_target*0.1) and np.isclose(y_surf1, y1, atol=self.dy_target*0.1):
if nb1 >= nb1 and slope > 0:
continue
if nb1 <= nb1 and slope < 0:
continue
diff_nb = nb1 - nb0
y1_below = yd_list[ind_x1][ind_y1 - 1]
if y1_c == self.y_surf_at_xcs[x1_c]: # surface
y1_above = None
try:
x_next = xcs[ind_x1 + 1]
y_next_surf = self.y_surf_at_xcs[x_next]
ind_y_next = int(np.argmin(abs(np.array(yd_list[ind_x1 + 1]) - y_next_surf)))
nb_next = csum_y_blocks[ind_x1 + 1][ind_y_next - 1]
except IndexError:
x_next = None
y_next_surf = None
ind_y_next = None
else:
y1_above = yd_list[ind_x1][ind_y1 + 1]
x_next = None
y_next_surf = None
ind_y_next = None
while sgn != np.sign(diff_nb) and diff_nb != 0:
nb_below = self.y_blocks[x1_c][ind_y1 - 1]
if nb_below + np.sign(diff_nb) * -1 == 0:
break
new_dh_below = (y1_c - y1_below) / (nb_below + np.sign(diff_nb) * -1)
if not (min_dh < new_dh_below < max_dh):
break
nb1 += np.sign(diff_nb) * -1
if y1_c != self.y_surf_at_xcs[x1_c]:
nb_above = self.y_blocks[x1_c][ind_y1]
if nb_above + np.sign(diff_nb) * 1 == 0:
break
new_dh_above = (y1_above - y1_c) / (nb_above + np.sign(diff_nb) * 1)
if not (min_dh < new_dh_above < max_dh):
break
self.y_blocks[x1_c][ind_y1] += np.sign(diff_nb) * 1
else: # check slope of surface is appropriate
a = 1
# new_dh_next = (y_next_surf - y1_above) / (nb_next - (nb_above + np.sign(diff_nb) * 1))
# if not (min_dh < new_dh_above < max_dh):
# break
self.y_blocks[x1_c][ind_y1 - 1] += np.sign(diff_nb) * -1
diff_nb = nb1 - nb0
approx_grid_slope = (dh_dzone - diff_nb * self.dy_target) / (x1 - x0)
if sgn != np.sign(approx_grid_slope):
pass # this can be an issue if it cannot be adjusted
if sgn * approx_grid_slope > self.allowable_slope:
nn = 0
while sgn * approx_grid_slope > self.allowable_slope:
nn += 1
# if no issues then adjust blocks
self.y_blocks[x1_c][ind_y1 - 1] += sgn * 1
nb1 += sgn * 1
diff_nb = nb1 - nb0
if y1_c != self.y_surf_at_xcs[x1_c]:
self.y_blocks[x1_c][ind_y1] += sgn * -1
approx_grid_slope = (dh_dzone - diff_nb * self.dy_target) / (x1 - x0)
if nn > 10:
raise ValueError
diff_nb = nb1 - nb0
if diff_nb: # if zero then slope matches the line
# else check if an adjustment is possible
nnn = abs(diff_nb)
for nn in range(nnn):
diff_nb = nb1 - nb0
if diff_nb == 0:
break
nb_sgn = np.sign(diff_nb)
approx_new_slope = (dh_dzone - (diff_nb - nb_sgn * (nn + 1)) * self.dy_target) / (x1 - x0)
if sgn * approx_new_slope > self.allowable_slope:
break
nb_below = self.y_blocks[x1_c][ind_y1 - 1]
new_nb_below = nb_below + nb_sgn * -1
use_2_below = False
if new_nb_below == 0: # try bring from even lower layer
nb_2_below = self.y_blocks[x1_c][ind_y1 - 2]
new_nb_2_below = nb_2_below + nb_sgn * -1
y1_2_below = yd_list[ind_x1][ind_y1 - 2]
new_dh_2_below = (y1_below - y1_2_below) / new_nb_2_below
if min_dh < new_dh_2_below < max_dh:
use_2_below = True
else:
break
else:
new_dh_below = (y1_c - y1_below) / (nb_below + nb_sgn * -1)
if not (min_dh < new_dh_below < max_dh):
break
if y1_above is not None:
nb_above = self.y_blocks[x1_c][ind_y1]
new_dh_above = (y1_above - y1_c) / (nb_above + nb_sgn * 1)
if not (min_dh < new_dh_above < max_dh):
break
elif y_next_surf is not None:
if abs(nb_next - (nb1 + nb_sgn * -1)) < 2:
pass
else:
new_dh_on_next_surf = (y_next_surf - y1_c) / (nb_next - (nb1 + nb_sgn * -1))
if not (min_dh < new_dh_on_next_surf < max_dh):
break
# if no issues then adjust blocks
if use_2_below:
self.y_blocks[x1_c][ind_y1 - 2] += nb_sgn * -1
else:
self.y_blocks[x1_c][ind_y1 - 1] += nb_sgn * -1
nb1 += nb_sgn * -1
if y1_above is not None:
self.y_blocks[x1_c][ind_y1] += nb_sgn * 1
# Step 5: Set the total number of blocks to be equal to the column that uses the maximum number of
# blocks used to get to the surface
n_blocks = np.array([sum(self.y_blocks[xc]) for xc in xcs])
y_surfs = np.interp(xcs, self.x_surf, self.y_surf)
nbs_at_surf = []
surf_inds = []
for i in range(len(xcs)):
x0 = xcs[i]
nbs = np.cumsum(self.y_blocks[x0])
nbs = np.insert(nbs, 0, 0)
surf_inds.append(np.where(self.yd[x0] >= y_surfs[i] - 0.01)[0][0])
nbs_at_surf.append(nbs[np.where(self.yd[x0] >= y_surfs[i] - 0.01)][0])
# inds = np.where(np.interp(xcs, self.x_surf, self.y_surf) == h_max)[0]
i_max = np.argmax(nbs_at_surf) # maximum number of blocks at top
n_max = nbs_at_surf[i_max]
# create null nodes
for i in range(len(xcs)):
x0 = xcs[i]
if n_blocks[i] != n_max:
n_extra = n_max - n_blocks[i] # TODO: could improve this by minus eles more evenly from zones
if n_extra:
if surf_inds[i] == len(self.y_blocks[x0]):
self.y_blocks[x0].append(0)
self.yd[x0] = np.insert(self.yd[x0], len(self.yd[x0]), self.yd[x0][-1])
self.y_blocks[x0][-1] += n_extra
assert min(self.y_blocks[x0][:surf_inds[i]]) > 0, (x0, self.yd[x0], self.y_blocks[x0][-1])
def trim_grid_to_target_dh(self):
"""Check mesh for potential thin layers and try to remove rows of elements to get elements close to target dh"""
xcs = self.xcs_sorted
opt_low = self.dy_target * (self.min_scale + 1) / 2
opt_high = self.dy_target * (self.max_scale + 1) / 2
y_surfs_at_xcs = np.interp(xcs, self.x_surf, self.y_surf)
# try to trim mesh to be closer to target dh
# First try to remove blocks
opts_tried = []
for nn in range(10):
y_coords_at_xcs = [list(self.yd[xc]) for xc in xcs]
y_node_nums_at_xcs = [list(np.cumsum(self.y_blocks[xcs])) for xcs in self.y_blocks]
for i in range(len(y_node_nums_at_xcs)):
y_node_nums_at_xcs[i].insert(0, 0)
if y_node_nums_at_xcs[i][-2] == y_node_nums_at_xcs[i][-1]:
y_coords_at_xcs[i] = y_coords_at_xcs[i][:-1]
y_node_nums_at_xcs[i] = y_node_nums_at_xcs[i][:-1]
av_dhs = []
min_dhs = []
for i in range(len(y_node_nums_at_xcs)):
av_dhs.append([])
for j in range(len(y_node_nums_at_xcs[i]) - 1):
if (i, j) in opts_tried or y_coords_at_xcs[i][j + 1] > y_surfs_at_xcs[i]:
av_dhs[i].append(1000)
continue
nb = y_node_nums_at_xcs[i][j + 1] - y_node_nums_at_xcs[i][j]
av_dhs[i].append((y_coords_at_xcs[i][j + 1] - y_coords_at_xcs[i][j]) / nb)
min_dhs.append(min(av_dhs[i]))
if min(min_dhs) < self.dy_target: # favour slightly larger elements - could use opt_low
x_ind = min_dhs.index(min(min_dhs))
y_ind = av_dhs[x_ind].index(min_dhs[x_ind])
nb_lowest_p = y_node_nums_at_xcs[x_ind][y_ind] # range where element could be removed
nb_highest_p = y_node_nums_at_xcs[x_ind][y_ind + 1]
if nb_lowest_p >= nb_highest_p:
opts_tried.append((x_ind, y_ind))
continue
hzone_p = y_coords_at_xcs[x_ind][y_ind + 1] - y_coords_at_xcs[x_ind][y_ind]
found_opt = 0
max_new_dhs = []
for opt in range(nb_lowest_p, nb_highest_p):
max_new_dh = hzone_p / (nb_highest_p - nb_lowest_p - 1)
for w in range(len(y_node_nums_at_xcs)):
y_ind = interp_left(opt, y_node_nums_at_xcs[w])
if y_ind == len(y_node_nums_at_xcs[w]) - 1:
y_ind -= 1
nb_low = y_node_nums_at_xcs[w][y_ind]
nb_high = y_node_nums_at_xcs[w][y_ind + 1]
hzone = y_coords_at_xcs[w][y_ind + 1] - y_coords_at_xcs[w][y_ind]
new_dh = hzone / (nb_high - nb_low - 1)
if max_new_dh < new_dh:
max_new_dh = new_dh
max_new_dhs.append(max_new_dh)
max_new_dh = min(max_new_dhs)
yind = max_new_dhs.index(max_new_dh) + nb_lowest_p
if max_new_dh < opt_high:
for w in range(len(y_node_nums_at_xcs)):
y_ind = interp_left(yind, y_node_nums_at_xcs[w])
if y_ind == len(y_node_nums_at_xcs[w]) - 1:
y_ind -= 1
self.y_blocks[xcs[w]][y_ind] -= 1
found_opt = 1
if not found_opt:
opts_tried.append((x_ind, y_ind))
else:
break
# Then try to add blocks
opts_tried = []
for nn in range(20):
y_coords_at_xcs = [list(self.yd[xc]) for xc in xcs]
y_node_nums_at_xcs = [list(np.cumsum(self.y_blocks[xcs])) for xcs in self.y_blocks]
for i in range(len(y_node_nums_at_xcs)):
y_node_nums_at_xcs[i].insert(0, 0)
if y_node_nums_at_xcs[i][-2] == y_node_nums_at_xcs[i][-1]:
y_coords_at_xcs[i] = y_coords_at_xcs[i][:-1]
y_node_nums_at_xcs[i] = y_node_nums_at_xcs[i][:-1]
av_dhs = []
max_dhs = []
for i in range(len(y_node_nums_at_xcs)):
av_dhs.append([])
for j in range(len(y_node_nums_at_xcs[i]) - 1):
if (i, j) in opts_tried or y_coords_at_xcs[i][j + 1] > y_surfs_at_xcs[i]:
av_dhs[i].append(-1)
continue
nb = y_node_nums_at_xcs[i][j + 1] - y_node_nums_at_xcs[i][j]
av_dhs[i].append((y_coords_at_xcs[i][j + 1] - y_coords_at_xcs[i][j]) / nb)
max_dhs.append(max(av_dhs[i]))
if max(max_dhs) > opt_high:
x_ind = max_dhs.index(max(max_dhs))
y_ind = av_dhs[x_ind].index(max_dhs[x_ind])
nb_lowest = y_node_nums_at_xcs[x_ind][y_ind] # range where element could be added
nb_highest = y_node_nums_at_xcs[x_ind][y_ind + 1]
if nb_highest <= nb_lowest:
opts_tried.append((x_ind, y_ind))
continue
hzone_p = y_coords_at_xcs[x_ind][y_ind + 1] - y_coords_at_xcs[x_ind][y_ind]
found_opt = 0
min_new_dhs = []
for opt in range(nb_lowest, nb_highest):
min_new_dh = hzone_p / (nb_highest - nb_lowest + 1)
for w in range(len(y_node_nums_at_xcs)):
y_ind = interp_left(opt, y_node_nums_at_xcs[w])
nb_low = y_node_nums_at_xcs[w][y_ind]
nb_high = y_node_nums_at_xcs[w][y_ind + 1]
hzone = y_coords_at_xcs[w][y_ind + 1] - y_coords_at_xcs[w][y_ind]
new_dh = hzone / (nb_high - nb_low + 1)
if min_new_dh > new_dh:
min_new_dh = new_dh
min_new_dhs.append(min_new_dh)
min_new_dh = max(min_new_dhs)
yind = min_new_dhs.index(min_new_dh) + nb_lowest
if min_new_dh > opt_low:
for w in range(len(y_node_nums_at_xcs)):
y_ind0 = interp_left(yind, y_node_nums_at_xcs[w])
# y_ind1 = interp_left(nb_highest, y_node_nums_at_xcs[w])
self.y_blocks[xcs[w]][y_ind0] += 1
found_opt = 1
if not found_opt:
opts_tried.append((x_ind, y_ind))
else:
break
smallest = 0
for xcs in self.y_blocks:
if self.y_blocks[xcs][-1] < smallest:
smallest = self.y_blocks[xcs][-1]
if smallest != 0:
for xcs in self.y_blocks:
self.y_blocks[xcs][-1] += abs(smallest)
min_h = 1e6
max_h = 0
for xcs in self.y_blocks:
if max(self.y_blocks[xcs]) > max_h:
max_h = max(self.y_blocks[xcs])
if min(self.y_blocks[xcs]) < min_h:
min_h = min(self.y_blocks[xcs])
print('min_h: ', min_h)
print('max_h: ', max_h)
def build_req_y_node_positions(self):
"""
Creates lists of required positions and number of elements for each significant vertical line
Note: It also tries to make sure that steps in slopes are horizontal
"""
min_dh = self.min_scale * self.dy_target
max_dh = self.max_scale * self.dy_target
xcs = self.xcs_sorted
# Step 1: build lists containing required y element numbers and y-coords
req_y_coords_at_xcs = [list(self.yd[xc]) for xc in xcs]
y_node_nums_at_xcs = [list(np.cumsum(self.y_blocks[xcs])) for xcs in self.y_blocks]
for i in range(len(y_node_nums_at_xcs)):
y_node_nums_at_xcs[i].insert(0, 0)
if y_node_nums_at_xcs[i][-2] == y_node_nums_at_xcs[i][-1]:
req_y_coords_at_xcs[i] = req_y_coords_at_xcs[i][:-1]
y_node_nums_at_xcs[i] = y_node_nums_at_xcs[i][:-1]
# Step 2: For each slope that has a step, add additional requirement that slope does not decrease during step
# sds = self.sds
# for sd in sds:
# x0 = sd[0][0]
# x1 = sd[0][1]
# y0 = sd[1][0]
# y1 = sd[1][1]
# ind_x0 = int(np.argmin(abs(xcs - x0)))
# ind_x1 = int(np.argmin(abs(xcs - x1)))
# ind_y0 = int(np.argmin(abs(np.array(req_y_coords_at_xcs[ind_x0]) - y0)))
# ind_y1 = int(np.argmin(abs(np.array(req_y_coords_at_xcs[ind_x1]) - y1)))
# y0_c = req_y_coords_at_xcs[ind_x0][ind_y0]
# nb0 = y_node_nums_at_xcs[ind_x0][ind_y0]
# nb1 = y_node_nums_at_xcs[ind_x1][ind_y1]
# if nb0 != nb1:
# diff_nb = nb1 - nb0
# new_nb = y_node_nums_at_xcs[ind_x1][ind_y1] - diff_nb
# if new_nb not in y_node_nums_at_xcs[ind_x1]:
# dh_upper = (req_y_coords_at_xcs[ind_x1][ind_y1] - y0_c) / diff_nb
# if ind_y1 - 2 < 0:
# nb_lower = nb1 - diff_nb
# else:
# nb_lower = nb1 - y_node_nums_at_xcs[ind_x1][ind_y1 - 1] - diff_nb
# dh_lower = (y0_c - req_y_coords_at_xcs[ind_x1][ind_y1 - 1]) / nb_lower
# if min_dh < dh_upper < max_dh and min_dh < dh_lower < max_dh:
# y_node_nums_at_xcs[ind_x1].append(new_nb)
# y_node_nums_at_xcs[ind_x1].sort()
# req_y_coords_at_xcs[ind_x1].append(y0_c)
# req_y_coords_at_xcs[ind_x1].sort()
# Step 3: Build node number lists
req_y_nodes = []
for i, xc0 in enumerate(xcs):
req_y_nodes.append(list(np.array(y_node_nums_at_xcs[i]) + 1))
req_y_nodes[i][0] = 0
req_y_nodes[i] = | np.array(req_y_nodes[i]) | numpy.array |
#!/usr/bin/env python
# encoding: utf-8
#
# maskbit.py
#
# @Author: <NAME> <andrews>
# @Date: 2017-10-06 10:10:00
# @Last modified by: <NAME> (<EMAIL>)
# @Last modified time: 2018-11-26 11:51:50
from __future__ import absolute_import, division, print_function
import os
import numpy as np
import pandas as pd
import marvin
from marvin.extern.yanny import yanny
# Stores the maskbits yanny file structure so that we don't need to open it more than once.
_maskbits_from_yanny = None
def _read_maskbit_schemas():
"""Read all available SDSS maskbit schemas from yanny file.
Returns:
Record Array: all bits for all schemas.
"""
global _maskbits_from_yanny
if _maskbits_from_yanny is None:
path_maskbits = os.path.join(os.path.dirname(marvin.__file__), 'data', 'sdssMaskbits.par')
_maskbits_from_yanny = yanny(path_maskbits, np=True)
return _maskbits_from_yanny['MASKBITS']
def get_available_maskbits():
"""Get names of available maskbit schemas from yanny file.
Returns:
list: Names of available maskbits.
"""
maskbits = _read_maskbit_schemas()
return sorted(set([it[0] for it in maskbits]))
def get_manga_target(flag_id, bitmasks, header):
"""Get MANGA_TARGET[``flag_id``] flag.
Parameters:
flag_id (str):
Flag ID number (e.g., "1" for MANGA_TARGET1).
bitmasks (dict):
`Maskbit` objects.
header (`astropy.io.fits.header.Header`):
File header.
Returns:
`Maskbit`
"""
flag_id = str(int(flag_id))
manga_target = bitmasks['MANGA_TARGET{}'.format(flag_id)]
try:
manga_target.mask = int(header['MNGTRG{}'.format(flag_id)])
except KeyError:
manga_target.mask = int(header['MNGTARG{}'.format(flag_id)])
return manga_target
class Maskbit(object):
"""A class representing a maskbit.
Parameters:
schema (DataFrame):
Maskbit schema.
name (str):
Name of maskbit.
description (str):
Description of maskbit.
"""
def __init__(self, name, schema=None, description=None):
self.name = name
self.schema = schema if schema is not None else self._load_schema(name)
self.description = description if description is not None else None
self.mask = None
def __repr__(self):
if (isinstance(self.mask, int) or self.mask is None):
labels = self.labels
else:
labels = 'shape={}'.format(self.mask.shape)
return '<Maskbit {0!r} {1}>'.format(self.name, labels)
def _load_schema(self, flag_name):
"""Load SDSS Maskbit schema from yanny file.
Parameters:
flag_name (str):
Name of flag.
Returns:
DataFrame: Schema of flag.
"""
maskbits = _read_maskbit_schemas()
flag = maskbits[maskbits['flag'] == flag_name]
return pd.DataFrame(flag[['bit', 'label', 'description']])
@property
def bits(self):
return self.values_to_bits() if self.mask is not None else None
@property
def labels(self):
return self.values_to_labels() if self.mask is not None else None
def values_to_bits(self, values=None):
"""Convert mask values to a list of bits set.
Parameters:
values (int or array):
Mask values. If ``None``, apply to entire
``Maskbit.mask`` array. Default is ``None``.
Returns:
list:
Bits that are set.
Example:
>>> maps = Maps(plateifu='8485-1901')
>>> ha = maps['emline_gflux_ha_6564']
>>> ha.pixmask.values_to_bits()
[[[0, 1, 4, 30],
[0, 1, 4, 30],
...
[0, 1, 4, 30]]]
"""
# assert (self.mask is not None) or (values is not None), 'Must provide values.'
# values = np.array(self.mask) if values is None else np.array(values)
# ndim = values.ndim
# assert ndim <= 3, '`value` must be int, 1-D array, 2-D array, or 3-D array.'
# # expand up to 2 dimensions
# while values.ndim < 3:
# values = np.array([values])
# # create list of list of lists of bits set
# bits_set = []
# for ii in range(values.shape[0]):
# row_ii = []
# for jj in range(values.shape[1]):
# row_jj = []
# for kk in range(values.shape[2]):
# row_jj.append(self._value_to_bits(values[ii, jj, kk], self.schema.bit.values))
# row_ii.append(row_jj)
# bits_set.append(row_ii)
# # condense back down to initial dimensions
# for __ in range(3 - ndim):
# bits_set = bits_set[0]
bits_set = self._get_a_set(values, convert_to='bits')
return bits_set
def _get_uniq_bits(self, values):
''' Return a dictionary of unique bits
Parameters:
values (list):
A flattened list of mask values
Returns:
dict:
A unique dictionary of {mask value: bit list} as {key: value}
'''
uniqvals = set(values)
vdict = {v: self._value_to_bits(v, self.schema.bit.values) for v in uniqvals}
return vdict
def _get_uniq_labels(self, values):
''' Return a dictionary of unique labels
Parameters:
values (list):
A flattened list of mask values
Returns:
dict:
A unique dictionary of {mask value: labels list} as {key: value}
'''
uniqbits = self._get_uniq_bits(values)
uniqlabels = {k: self.schema.label[self.schema.bit.isin(v)].values.tolist() for k, v in uniqbits.items()}
return uniqlabels
def _get_a_set(self, values, convert_to='bits'):
''' Convert mask values to a list of either bit or label sets.
Parameters:
values (int or array):
Mask values. If ``None``, apply to entire
``Maskbit.mask`` array. Default is ``None``.
convert_to (str):
Indicates what to convert to. Either "bits" or "labels"
Returns:
list:
Bits/Labels that are set.
'''
assert (self.mask is not None) or (values is not None), 'Must provide values.'
values = np.array(self.mask) if values is None else np.array(values)
ndim = values.ndim
shape = values.shape
assert ndim <= 3, '`value` must be int, 1-D array, 2-D array, or 3-D array.'
flatmask = values.flatten()
if convert_to == 'bits':
uniqvals = self._get_uniq_bits(flatmask)
elif convert_to == 'labels':
uniqvals = self._get_uniq_labels(flatmask)
vallist = list(map(lambda x: uniqvals[x], flatmask))
if ndim > 0:
vals_set = np.reshape(vallist, shape).tolist()
else:
vals_set = vallist[0]
return vals_set
def _value_to_bits(self, value, bits_all):
"""Convert mask value to a list of bits.
Parameters:
value (int):
Mask value.
bits_all (array):
All bits for flag.
Returns:
list:
Bits that are set.
"""
return [it for it in bits_all if int(value) & (1 << it)]
def values_to_labels(self, values=None):
"""Convert mask values to a list of the labels of bits set.
Parameters:
values (int or array):
Mask values. If ``None``, apply to entire
``Maskbit.mask`` array. Default is ``None``.
Returns:
list:
Bits that are set.
Example:
>>> maps = Maps(plateifu='8485-1901')
>>> ha = maps['emline_gflux_ha_6564']
>>> ha.pixmask.values_to_labels()
[[['NOCOV', 'LOWCOV', 'NOVALUE', 'DONOTUSE'],
['NOCOV', 'LOWCOV', 'NOVALUE', 'DONOTUSE'],
...
['NOCOV', 'LOWCOV', 'NOVALUE', 'DONOTUSE']]]
"""
#bits_set = self.values_to_bits(values=values)
#labels_set = self._bits_to_labels(bits_set)
labels_set = self._get_a_set(values, convert_to='labels')
return labels_set
def _bits_to_labels(self, nested):
"""Recursively convert a nested list of bits to labels.
Parameters:
nested (list):
Nested list of bits.
Returns:
list: Nested list of labels.
"""
# Base condition
if isinstance(nested, (int, np.integer)):
return self.schema.label[self.schema.bit == nested].values[0]
return [self._bits_to_labels(it) for it in nested]
def labels_to_value(self, labels):
"""Convert bit labels into a bit value.
Parameters:
labels (str or list):
Labels of bits to set.
Returns:
int: Integer bit value.
Example:
>>> maps = Maps(plateifu='8485-1901')
>>> ha = maps['emline_gflux_ha_6564']
>>> ha.pixmask._labels_to_value('DONOTUSE')
1073741824
>>> ha.pixmask._labels_to_value(['NOCOV', 'LOWCOV'])
3
"""
if isinstance(labels, str):
labels = [labels]
bit_values = []
for label in labels:
bit = self.schema.bit[self.schema.label == label]
if not bit.empty:
bit_values.append(bit.values[0])
return np.sum([2**value for value in bit_values])
def labels_to_bits(self, labels):
"""Convert bit labels into bits.
Parameters:
labels (str or list):
Labels of bits.
Returns:
list: Bits that correspond to the labels.
Example:
>>> maps = Maps(plateifu='8485-1901')
>>> ha = maps['emline_gflux_ha_6564']
>>> ha.pixmask.labels_to_bits('DONOTUSE')
[30]
>>> ha.pixmask.labels_to_value(['NOCOV', 'LOWCOV'])
[0, 1]
"""
return self.values_to_bits(self.labels_to_value(labels))
def get_mask(self, labels, mask=None, dtype=int):
"""Create mask from a list of labels.
If ``dtype`` is ``int``, then ``get_mask`` can effectively
perform an OR or AND operation. However, if ``dtype`` is
``bool``, then ``get_mask`` does an OR.
Parameters:
labels (str or list):
Labels of bits.
mask (int or array):
User-defined mask. If ``None``, use ``self.mask``.
Default is ``None``.
dtype:
Output dtype, which must be either ``int`` or ``bool``.
Default is ``int``.
Returns:
array: Mask for given labels.
Example:
>>> maps = Maps(plateifu='8485-1901')
>>> ha = maps['emline_gflux_ha_6564']
>>> ha.pixmask.get_mask(['NOCOV', 'LOWCOV'])
array([[3, 3, 3, ..., 3, 3, 3],
...,
[3, 3, 3, ..., 3, 3, 3]])
>>> ha.pixmask.get_mask(['NOCOV', 'LOWCOV'], dtype=bool)
array([[ True, True, True, ..., True, True, True],
...,
[ True, True, True, ..., True, True, True]], dtype=bool)
"""
assert dtype in [int, bool], '``dtype`` must be either ``int`` or ``bool``.'
if isinstance(labels, str):
labels = [labels]
schema_labels = self.schema.label.tolist()
for label in labels:
if label not in schema_labels:
raise ValueError('label {0!r} not found in the maskbit schema.'.format(label))
bits = self.labels_to_bits(labels)
mask = mask if mask is not None else self.mask
if len(bits) == 0:
return | np.zeros(mask.shape, dtype=np.int) | numpy.zeros |
# -*- coding:utf-8 -*-
"""
@author: leonardo
@created time: 2020-07-01
@last modified time:2020-07-01
"""
import matplotlib.pyplot as plt
from matplotlib import cm, colors
from matplotlib.ticker import LinearLocator, FormatStrFormatter
from mpl_toolkits.mplot3d import axes3d
import numpy as np
from mpl_toolkits.axisartist.parasite_axes import HostAxes, ParasiteAxes
def plot_surface(x, y, z):
fig = plt.figure()
ax = fig.gca(projection='3d')
surf = ax.plot_surface(x, y, z, cmap=cm.coolwarm, linewidth=0, antialiased=False)
# ax.set_zlim(-1.01, 1.01)
ax.zaxis.set_major_locator(LinearLocator(10))
ax.zaxis.set_major_formatter(FormatStrFormatter('%.02f'))
fig.colorbar(surf, shrink=0.5, aspect=5)
plt.show()
def plot_surface2(x, y, z):
ax = plt.axes(projection='3d')
ax.plot_surface(x, y, z, rstride=1, cstride=1, cmap='viridis', edgecolor='none')
plt.show()
def plot_multi_y(line_series_list, line_label_list, scatter_series_list, scatter_label_list):
"""
第一条line做主轴,散点与主轴共用Y轴
:param line_series_list:
:param line_label_list:
:param scatter_series_list:
:param scatter_label_list:
:return:
"""
color_list = ['red', 'green', 'blue', 'yellow', 'pink', 'black', 'orange']
fig = plt.figure(1)
host_axes = HostAxes(fig, [0.1, 0.1, 0.6, 0.8])
fig.add_axes(host_axes)
host_axes.set_ylabel(line_label_list[0])
host_axes.axis['right'].set_visible(False)
host_axes.set_ylim(min(line_series_list[0][1]) * 0.9, max(line_series_list[0][1]) * 1.1)
host_axes.plot(line_series_list[0][0], line_series_list[0][1], label=line_label_list[0],
color=color_list[0])
label_offset = 0
# line_axes = []
for i in range(len(line_series_list) - 1):
axes = ParasiteAxes(host_axes, sharex=host_axes)
axes.set_ylabel(line_label_list[i + 1])
axis_line = axes.get_grid_helper().new_fixed_axis
axes.axis['right' + str(label_offset)] = axis_line(loc='right', axes=axes, offset=(label_offset, 0))
axes.axis['right' + str(label_offset)].label.set_color(color_list[i + 1])
axes.axis['right' + str(label_offset)].major_ticks.set_color(color_list[i + 1])
axes.axis['right' + str(label_offset)].major_ticklabels.set_color(color_list[i + 1])
axes.axis['right' + str(label_offset)].line.set_color(color_list[i + 1])
label_offset += 40
axes.set_ylim(min(line_series_list[i + 1][1]) * 0.9, max(line_series_list[i + 1][1]) * 1.1)
axes.plot(line_series_list[i + 1][0], line_series_list[i + 1][1], label=line_label_list[i + 1],
color=color_list[i + 1])
# line_axes.append(axes)
host_axes.parasites.append(axes)
# scatter_axes = []
for i in range(len(scatter_series_list)): # 与主轴共用Y轴
# axes = ParasiteAxes(host_axes, sharex=host_axes)
# axes.set_ylabel(scatter_label_list[i])
# axis_line = axes.get_grid_helper().new_fixed_axis
# axes.axis['right' + str(label_offset)] = axis_line(loc='right', axes=axes, offset=(label_offset, 0))
color_item = color_list[len(line_label_list) + i + 1]
# axes.axis['right' + str(label_offset)].label.set_color(color_item)
# axes.axis['right' + str(label_offset)].major_ticks.set_color(color_item)
# axes.axis['right' + str(label_offset)].major_ticklabels.set_color(color_item)
# axes.axis['right' + str(label_offset)].line.set_color(color_item)
# label_offset += 40
# axes.set_ylim(min(scatter_series_list[i][1]), max(scatter_series_list[i][1]))
host_axes.scatter(scatter_series_list[i][0], scatter_series_list[i][1], label=scatter_label_list[i],
color=color_item)
# scatter_axes.append(axes)
# host_axes.parasites.append(axes)
host_axes.legend()
plt.show()
if __name__ == '__main__':
import math
y_size = 30
x = | np.arange(0, y_size, 1) | numpy.arange |
# Copyright 2020 <NAME>, <NAME>, <NAME>, <NAME>
# 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 argparse
import os
import torch
import numpy as np
from tqdm import tqdm
from var_sep.data.taxibj import TaxiBJ
from var_sep.utils.helper import DotDict, load_json
from var_sep.test.utils import load_model
def get_min(test_loader):
mins, maxs = {}, {}
for zone in test_loader.zones:
mins[zone] = test_loader.data[zone].min()
maxs[zone] = test_loader.data[zone].max()
return mins, maxs
def load_dataset(args):
return TaxiBJ.make_datasets(args.data_dir, len_closeness=args.nt_cond + args.nt_pred, nt_cond=args.nt_cond)[1]
def compute_mse(args, test_set, sep_net):
all_mse = []
torch.set_grad_enabled(False)
for cond, target in tqdm(test_set):
cond, target = cond.unsqueeze(0).to(args.device), target.unsqueeze(0).to(args.device)
if args.offset:
forecasts = sep_net.get_forecast(cond, target.size(1) + args.nt_cond)[0]
forecasts = forecasts[:, args.nt_cond:]
else:
forecasts = sep_net.get_forecast(cond, target.size(1))[0]
mse = (forecasts - target).pow(2).mean(dim=-1).mean(dim=-1).mean(dim=-1)
all_mse.append(mse.cpu().numpy())
return all_mse
def main(args):
if args.device is None:
device = torch.device('cpu')
else:
os.environ["CUDA_VISIBLE_DEVICES"] = str(args.device)
device = torch.device('cuda:0')
torch.cuda.set_device(0)
# Load XP config
xp_config = load_json(os.path.join(args.xp_dir, 'params.json'))
xp_config.device = device
xp_config.data_dir = args.data_dir
xp_config.xp_dir = args.xp_dir
xp_config.nt_pred = 4
args.nt_pred = 4
test_set = load_dataset(xp_config)
sep_net = load_model(xp_config, args.epoch)
all_mse = compute_mse(xp_config, test_set, sep_net)
mse_array = | np.concatenate(all_mse, axis=0) | numpy.concatenate |
# Copyright 2020 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.
"""Tests for Lattice Layer."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import tempfile
from absl.testing import parameterized
import numpy as np
import tensorflow as tf
from tensorflow_lattice.python import linear_layer
from tensorflow_lattice.python import pwl_calibration_layer
from tensorflow_lattice.python import rtl_layer
class RTLTest(parameterized.TestCase, tf.test.TestCase):
def setUp(self):
super(RTLTest, self).setUp()
self.disable_all = False
def testRTLInputShapes(self):
if self.disable_all:
return
data_size = 100
# Dense input format.
a = np.random.random_sample(size=(data_size, 10))
b = np.random.random_sample(size=(data_size, 20))
target_ab = (
np.max(a, axis=1, keepdims=True) + np.min(b, axis=1, keepdims=True))
input_a = tf.keras.layers.Input(shape=(10,))
input_b = tf.keras.layers.Input(shape=(20,))
rtl_0 = rtl_layer.RTL(num_lattices=6, lattice_rank=5)
rtl_outputs = rtl_0({"unconstrained": input_a, "increasing": input_b})
outputs = tf.keras.layers.Dense(1)(rtl_outputs)
model = tf.keras.Model(inputs=[input_a, input_b], outputs=outputs)
model.compile(loss="mse")
model.fit([a, b], target_ab)
model.predict([a, b])
# Inputs to be calibrated.
c = np.random.random_sample(size=(data_size, 1))
d = np.random.random_sample(size=(data_size, 1))
e = np.random.random_sample(size=(data_size, 1))
f = | np.random.random_sample(size=(data_size, 1)) | numpy.random.random_sample |
import numpy as np
import scipy.sparse as sp
from pyspark import RDD
from splearn.rdd import ArrayRDD, BlockRDD, DictRDD, SparseRDD, block
from splearn.utils.testing import (SplearnTestCase, assert_almost_equal,
assert_array_almost_equal,
assert_array_equal, assert_equal,
assert_is_instance,
assert_multiple_tuples_equal, assert_raises,
assert_true, assert_tuple_equal)
from splearn.utils.validation import check_rdd_dtype
class TestBlocking(SplearnTestCase):
def test_empty(self):
n_partitions = 3
empty_data = self.sc.parallelize([], n_partitions)
assert_raises(ValueError, block, empty_data)
def test_dtype(self):
n_partitions = 10
n_samples = 100
data = self.sc.parallelize(["lorem" for i in range(n_samples)],
n_partitions)
blocked_data = block(data, dtype=list)
assert_array_equal(["lorem"] * 10, blocked_data.first())
blocks = blocked_data.collect()
assert_equal(len(blocks), n_partitions)
assert_array_equal(["lorem"] * 10, blocks[-1])
assert_equal(sum(len(b) for b in blocks), n_samples)
n_partitions = 17
data = self.sc.parallelize([1 for i in range(n_samples)],
n_partitions)
blocked_data = block(data, dtype=tuple)
assert_array_equal(tuple([1] * (n_samples // n_partitions)),
blocked_data.first())
blocks = blocked_data.collect()
assert_equal(len(blocks), n_partitions)
assert_equal(sum(len(b) for b in blocks), n_samples)
def test_array(self):
n_partitions = 10
n_samples = 100
data = self.sc.parallelize([np.array([1]) for i in range(n_samples)],
n_partitions)
blocked_data = block(data)
assert_array_equal(np.ones((10, 1)), blocked_data.first())
blocks = blocked_data.collect()
assert_equal(len(blocks), n_partitions)
assert_array_equal(np.ones((10, 1)), blocks[-1])
assert_equal(sum(len(b) for b in blocks), n_samples)
n_partitions = 17
data = self.sc.parallelize([np.array([1]) for i in range(n_samples)],
n_partitions)
blocked_data = block(data)
assert_array_equal(np.ones((n_samples // n_partitions, 1)),
blocked_data.first())
blocks = blocked_data.collect()
assert_equal(len(blocks), n_partitions)
assert_equal(sum(len(b) for b in blocks), n_samples)
def test_array_bsize(self):
n_partitions = 10
n_samples = 107
data = self.sc.parallelize([np.array([1]) for i in range(n_samples)],
n_partitions)
block_data_5 = block(data, bsize=5)
blocks = block_data_5.collect()
assert_true(all(len(b) <= 5 for b in blocks))
block_data_10 = block(data, bsize=10)
blocks = block_data_10.collect()
assert_true(all(len(b) <= 10 for b in blocks))
def test_sparse_matrix(self):
n_partitions = 10
n_samples = 100
sparse_row = sp.csr_matrix([[0, 0, 1, 0, 1]])
data = self.sc.parallelize([sparse_row for i in range(n_samples)],
n_partitions)
blocked_data = block(data)
assert_true(sp.issparse(blocked_data.first()))
expected_block = sp.vstack([sparse_row] * 10)
assert_array_almost_equal(expected_block.toarray(),
blocked_data.first().toarray())
def test_block_rdd_tuple(self):
n_partitions = 10
n_samples = 100
sparse_row = sp.csr_matrix([[0, 0, 1, 0, 1]])
data = self.sc.parallelize(
[(np.array([1., 2.]), 0, sparse_row) for i in range(n_samples)],
n_partitions)
blocked_data = block(data)
expected_first_block = np.array([[1., 2.]] * 10)
expected_second_block = np.zeros(10, dtype=np.int)
expected_third_block = sp.vstack([sparse_row] * 10)
first_block_tuple = blocked_data.first()
assert_array_almost_equal(expected_first_block, first_block_tuple[0])
assert_array_almost_equal(expected_second_block, first_block_tuple[1])
assert_array_almost_equal(expected_third_block.toarray(),
first_block_tuple[2].toarray())
tuple_blocks = blocked_data.collect()
assert_equal(len(tuple_blocks), n_partitions)
assert_equal(sum(len(b[0]) for b in tuple_blocks), n_samples)
assert_equal(sum(len(b[1]) for b in tuple_blocks), n_samples)
def test_block_rdd_dict(self):
n_partitions = 3
n_samples = 57
dicts = [{'a': i, 'b': float(i) ** 2} for i in range(n_samples)]
data = self.sc.parallelize(dicts, n_partitions)
block_data_5 = block(data, bsize=5)
blocks = block_data_5.collect()
assert_true(all(len(b) <= 5 for b in blocks))
assert_array_almost_equal(blocks[0][0], np.arange(5))
assert_array_almost_equal(blocks[0][1],
np.arange(5, dtype=np.float) ** 2)
class TestBlockRDD(SplearnTestCase):
def generate(self, n_samples=100, n_partitions=10):
return self.sc.parallelize(list(range(n_samples)), n_partitions)
def test_creation(self):
rdd = self.generate()
blocked = BlockRDD(rdd)
assert_is_instance(blocked, BlockRDD)
expected = tuple(range(10))
assert_equal(blocked.first(), expected)
expected = [tuple(v) for v in np.arange(100).reshape(10, 10)]
assert_equal(blocked.collect(), expected)
blocked = BlockRDD(rdd, bsize=4)
assert_is_instance(blocked, BlockRDD)
expected = tuple(range(4))
assert_equal(blocked.first(), expected)
expected = [4, 4, 2] * 10
assert_equal([len(x) for x in blocked.collect()], expected)
def test_dtypes(self):
rdd = self.generate()
blocked = BlockRDD(rdd, dtype=list)
assert_is_instance(blocked.first(), list)
blocked = BlockRDD(rdd, dtype=tuple)
assert_is_instance(blocked.first(), tuple)
blocked = BlockRDD(rdd, dtype=set)
assert_is_instance(blocked.first(), set)
blocked = BlockRDD(rdd, dtype=np.array)
assert_is_instance(blocked.first(), np.ndarray)
def test_length(self):
blocked = BlockRDD(self.generate(1000))
assert_equal(len(blocked), 1000)
blocked = BlockRDD(self.generate(100))
assert_equal(len(blocked), 100)
blocked = BlockRDD(self.generate(79))
assert_equal(len(blocked), 79)
blocked = BlockRDD(self.generate(89))
assert_equal(len(blocked), 89)
blocked = BlockRDD(self.generate(62))
assert_equal(len(blocked), 62)
def test_blocks_number(self):
blocked = BlockRDD(self.generate(1000), bsize=50)
assert_equal(blocked.blocks, 20)
blocked = BlockRDD(self.generate(621), bsize=45)
assert_equal(blocked.blocks, 20)
blocked = BlockRDD(self.generate(100), bsize=4)
assert_equal(blocked.blocks, 30)
blocked = BlockRDD(self.generate(79, 2), bsize=9)
assert_equal(blocked.blocks, 10)
blocked = BlockRDD(self.generate(89, 2), bsize=5)
assert_equal(blocked.blocks, 18)
def test_partition_number(self):
blocked = BlockRDD(self.generate(1000, 5), bsize=50)
assert_equal(blocked.partitions, 5)
blocked = BlockRDD(self.generate(621, 3), bsize=45)
assert_equal(blocked.partitions, 3)
blocked = BlockRDD(self.generate(100, 10))
assert_equal(blocked.partitions, 10)
def test_unblock(self):
blocked = BlockRDD(self.generate(1000, 5))
unblocked = blocked.unblock()
assert_is_instance(blocked, BlockRDD)
assert_equal(unblocked.collect(), list(range(1000)))
blocked = BlockRDD(self.generate(1000, 5), dtype=tuple)
unblocked = blocked.unblock()
assert_is_instance(blocked, BlockRDD)
assert_equal(unblocked.collect(), list(range(1000)))
def test_tolist(self):
blocked = BlockRDD(self.generate(1000, 5))
unblocked = blocked.tolist()
assert_is_instance(blocked, BlockRDD)
assert_equal(unblocked, list(range(1000)))
blocked = BlockRDD(self.generate(1000, 5), dtype=tuple)
unblocked = blocked.tolist()
assert_is_instance(blocked, BlockRDD)
assert_equal(unblocked, list(range(1000)))
blocked = BlockRDD(self.generate(1000, 5), dtype=np.array)
unblocked = blocked.tolist()
assert_is_instance(blocked, BlockRDD)
assert_equal(unblocked, list(range(1000)))
class TestArrayRDD(SplearnTestCase):
def test_initialization(self):
n_partitions = 4
n_samples = 100
data = [np.array([1, 2]) for i in range(n_samples)]
rdd = self.sc.parallelize(data, n_partitions)
assert_raises(TypeError, ArrayRDD, data)
assert_raises(TypeError, ArrayRDD, data, False)
assert_raises(TypeError, ArrayRDD, data, 10)
assert_is_instance(ArrayRDD(rdd), ArrayRDD)
assert_is_instance(ArrayRDD(rdd, 10), ArrayRDD)
assert_is_instance(ArrayRDD(rdd, None), ArrayRDD)
def test_partitions_number(self):
data = np.arange(400).reshape((100, 4))
rdd = self.sc.parallelize(data, 4)
assert_equal(ArrayRDD(rdd, 5).partitions, 4)
assert_equal(ArrayRDD(rdd, 10).partitions, 4)
assert_equal(ArrayRDD(rdd, 20).partitions, 4)
data = np.arange(400).reshape((100, 4))
rdd = self.sc.parallelize(data, 7)
assert_equal(ArrayRDD(rdd, 5).partitions, 7)
assert_equal(ArrayRDD(rdd, 10).partitions, 7)
assert_equal(ArrayRDD(rdd, 20).partitions, 7)
def test_blocks_number(self):
n_partitions = 10
n_samples = 1000
data = [np.array([1, 2]) for i in range(n_samples)]
rdd = self.sc.parallelize(data, n_partitions)
assert_equal(1000, ArrayRDD(rdd, noblock=True, bsize=1).blocks)
assert_equal(10, ArrayRDD(rdd).blocks)
assert_equal(20, ArrayRDD(rdd, 50).blocks)
assert_equal(20, ArrayRDD(rdd, 66).blocks)
assert_equal(10, ArrayRDD(rdd, 100).blocks)
assert_equal(10, ArrayRDD(rdd, 300).blocks)
assert_equal(200, ArrayRDD(rdd, 5).blocks)
assert_equal(100, ArrayRDD(rdd, 10).blocks)
def test_blocks_size(self):
n_partitions = 10
n_samples = 1000
data = [np.array([1, 2]) for i in range(n_samples)]
rdd = self.sc.parallelize(data, n_partitions)
shapes = ArrayRDD(rdd).map(lambda x: x.shape[0]).collect()
assert_true(all(np.array(shapes) == 100))
shapes = ArrayRDD(rdd, 5).map(lambda x: x.shape[0]).collect()
assert_true(all(np.array(shapes) == 5))
shapes = ArrayRDD(rdd, 50).map(lambda x: x.shape[0]).collect()
assert_true(all(np.array(shapes) == 50))
shapes = ArrayRDD(rdd, 250).map(lambda x: x.shape[0]).collect()
assert_true(all(np.array(shapes) == 100))
shapes = ArrayRDD(rdd, 66).map(lambda x: x.shape[0]).collect()
assert_true(all(np.in1d(shapes, [66, 34])))
def test_ndim(self):
data = np.arange(4000)
shapes = [(4000),
(1000, 4),
(200, 10, 2),
(100, 10, 2, 2)]
for shape in shapes:
reshaped = data.reshape(shape)
rdd = self.sc.parallelize(reshaped)
assert_equal(ArrayRDD(rdd).ndim, reshaped.ndim)
def test_shape(self):
data = np.arange(4000)
shapes = [(1000, 4),
(200, 20),
(100, 40),
(2000, 2)]
for shape in shapes:
reshaped = data.reshape(shape)
rdd = self.sc.parallelize(reshaped)
assert_equal(ArrayRDD(rdd).shape, shape)
def test_size(self):
data = | np.arange(4000) | numpy.arange |
# -*- coding: utf-8 -*-
from __future__ import division
import re
import numpy as np
from scipy import sparse
import pytest
from sklearn.exceptions import NotFittedError
from sklearn.utils.testing import assert_array_equal
from sklearn.utils.testing import assert_equal
from sklearn.utils.testing import assert_raises
from sklearn.utils.testing import assert_raises_regex
from sklearn.utils.testing import assert_allclose
from sklearn.utils.testing import ignore_warnings
from sklearn.utils.testing import assert_warns
from sklearn.utils.testing import assert_warns_message
from sklearn.utils.testing import assert_no_warnings
from sklearn.preprocessing import OneHotEncoder
from sklearn.preprocessing import OrdinalEncoder
def toarray(a):
if hasattr(a, "toarray"):
a = a.toarray()
return a
def test_one_hot_encoder_sparse():
# Test OneHotEncoder's fit and transform.
X = [[3, 2, 1], [0, 1, 1]]
enc = OneHotEncoder()
with ignore_warnings(category=(DeprecationWarning, FutureWarning)):
# discover max values automatically
X_trans = enc.fit_transform(X).toarray()
assert_equal(X_trans.shape, (2, 5))
assert_array_equal(enc.active_features_,
np.where([1, 0, 0, 1, 0, 1, 1, 0, 1])[0])
assert_array_equal(enc.feature_indices_, [0, 4, 7, 9])
# check outcome
assert_array_equal(X_trans,
[[0., 1., 0., 1., 1.],
[1., 0., 1., 0., 1.]])
# max value given as 3
# enc = assert_warns(DeprecationWarning, OneHotEncoder, n_values=4)
enc = OneHotEncoder(n_values=4)
with ignore_warnings(category=DeprecationWarning):
X_trans = enc.fit_transform(X)
assert_equal(X_trans.shape, (2, 4 * 3))
assert_array_equal(enc.feature_indices_, [0, 4, 8, 12])
# max value given per feature
# enc = assert_warns(DeprecationWarning, OneHotEncoder, n_values=[3, 2, 2])
enc = OneHotEncoder(n_values=[3, 2, 2])
with ignore_warnings(category=DeprecationWarning):
X = [[1, 0, 1], [0, 1, 1]]
X_trans = enc.fit_transform(X)
assert_equal(X_trans.shape, (2, 3 + 2 + 2))
assert_array_equal(enc.n_values_, [3, 2, 2])
# check that testing with larger feature works:
X = np.array([[2, 0, 1], [0, 1, 1]])
enc.transform(X)
# test that an error is raised when out of bounds:
X_too_large = [[0, 2, 1], [0, 1, 1]]
assert_raises(ValueError, enc.transform, X_too_large)
error_msg = r"unknown categorical feature present \[2\] during transform"
assert_raises_regex(ValueError, error_msg, enc.transform, X_too_large)
with ignore_warnings(category=DeprecationWarning):
assert_raises(
ValueError,
OneHotEncoder(n_values=2).fit_transform, X)
# test that error is raised when wrong number of features
assert_raises(ValueError, enc.transform, X[:, :-1])
# test that error is raised when wrong number of features in fit
# with prespecified n_values
with ignore_warnings(category=DeprecationWarning):
assert_raises(ValueError, enc.fit, X[:, :-1])
# test exception on wrong init param
with ignore_warnings(category=DeprecationWarning):
assert_raises(
TypeError, OneHotEncoder(n_values=np.int).fit, X)
enc = OneHotEncoder()
# test negative input to fit
with ignore_warnings(category=FutureWarning):
assert_raises(ValueError, enc.fit, [[0], [-1]])
# test negative input to transform
with ignore_warnings(category=FutureWarning):
enc.fit([[0], [1]])
assert_raises(ValueError, enc.transform, [[0], [-1]])
def test_one_hot_encoder_dense():
# check for sparse=False
X = [[3, 2, 1], [0, 1, 1]]
enc = OneHotEncoder(sparse=False)
with ignore_warnings(category=(DeprecationWarning, FutureWarning)):
# discover max values automatically
X_trans = enc.fit_transform(X)
assert_equal(X_trans.shape, (2, 5))
assert_array_equal(enc.active_features_,
np.where([1, 0, 0, 1, 0, 1, 1, 0, 1])[0])
assert_array_equal(enc.feature_indices_, [0, 4, 7, 9])
# check outcome
assert_array_equal(X_trans,
np.array([[0., 1., 0., 1., 1.],
[1., 0., 1., 0., 1.]]))
def test_one_hot_encoder_deprecationwarnings():
for X in [[[3, 2, 1], [0, 1, 1]],
[[3., 2., 1.], [0., 1., 1.]]]:
enc = OneHotEncoder()
assert_warns_message(FutureWarning, "handling of integer",
enc.fit, X)
enc = OneHotEncoder()
assert_warns_message(FutureWarning, "handling of integer",
enc.fit_transform, X)
# check it still works correctly as well
with ignore_warnings(category=FutureWarning):
X_trans = enc.fit_transform(X).toarray()
res = [[0., 1., 0., 1., 1.],
[1., 0., 1., 0., 1.]]
assert_array_equal(X_trans, res)
# check deprecated attributes
assert_warns(DeprecationWarning, lambda: enc.active_features_)
assert_warns(DeprecationWarning, lambda: enc.feature_indices_)
assert_warns(DeprecationWarning, lambda: enc.n_values_)
# check no warning is raised if keyword is specified
enc = OneHotEncoder(categories='auto')
assert_no_warnings(enc.fit, X)
enc = OneHotEncoder(categories='auto')
assert_no_warnings(enc.fit_transform, X)
X_trans = enc.fit_transform(X).toarray()
assert_array_equal(X_trans, res)
# check there is also a warning if the default is passed
enc = OneHotEncoder(n_values='auto', handle_unknown='ignore')
assert_warns(DeprecationWarning, enc.fit, X)
X = np.array([['cat1', 'cat2']], dtype=object).T
enc = OneHotEncoder(categorical_features='all')
assert_warns(DeprecationWarning, enc.fit, X)
def test_one_hot_encoder_force_new_behaviour():
# ambiguous integer case (non secutive range of categories)
X = np.array([[1, 2]]).T
X2 = np.array([[0, 1]]).T
# without argument -> by default using legacy behaviour with warnings
enc = OneHotEncoder()
with ignore_warnings(category=FutureWarning):
enc.fit(X)
res = enc.transform(X2)
exp = np.array([[0, 0], [1, 0]])
assert_array_equal(res.toarray(), exp)
# with explicit auto argument -> don't use legacy behaviour
# (so will raise an error on unseen value within range)
enc = OneHotEncoder(categories='auto')
enc.fit(X)
assert_raises(ValueError, enc.transform, X2)
def _run_one_hot(X, X2, cat):
# enc = assert_warns(
# DeprecationWarning,
# OneHotEncoder, categorical_features=cat)
enc = OneHotEncoder(categorical_features=cat)
with ignore_warnings(category=(DeprecationWarning, FutureWarning)):
Xtr = enc.fit_transform(X)
with ignore_warnings(category=(DeprecationWarning, FutureWarning)):
X2tr = enc.fit(X).transform(X2)
return Xtr, X2tr
def _check_one_hot(X, X2, cat, n_features):
ind = np.where(cat)[0]
# With mask
A, B = _run_one_hot(X, X2, cat)
# With indices
C, D = _run_one_hot(X, X2, ind)
# Check shape
assert_equal(A.shape, (2, n_features))
assert_equal(B.shape, (1, n_features))
assert_equal(C.shape, (2, n_features))
assert_equal(D.shape, (1, n_features))
# Check that mask and indices give the same results
assert_array_equal(toarray(A), toarray(C))
assert_array_equal(toarray(B), toarray(D))
def test_one_hot_encoder_categorical_features():
X = np.array([[3, 2, 1], [0, 1, 1]])
X2 = np.array([[1, 1, 1]])
cat = [True, False, False]
_check_one_hot(X, X2, cat, 4)
# Edge case: all non-categorical
cat = [False, False, False]
_check_one_hot(X, X2, cat, 3)
# Edge case: all categorical
cat = [True, True, True]
_check_one_hot(X, X2, cat, 5)
# check error raised if also specifying categories
oh = OneHotEncoder(categories=[range(3)],
categorical_features=[True, False, False])
assert_raises(ValueError, oh.fit, X)
def test_one_hot_encoder_handle_unknown():
X = np.array([[0, 2, 1], [1, 0, 3], [1, 0, 2]])
X2 = np.array([[4, 1, 1]])
# Test that one hot encoder raises error for unknown features
# present during transform.
oh = OneHotEncoder(handle_unknown='error')
assert_warns(FutureWarning, oh.fit, X)
assert_raises(ValueError, oh.transform, X2)
# Test the ignore option, ignores unknown features (giving all 0's)
oh = OneHotEncoder(handle_unknown='ignore')
oh.fit(X)
X2_passed = X2.copy()
assert_array_equal(
oh.transform(X2_passed).toarray(),
np.array([[0., 0., 0., 0., 1., 0., 0.]]))
# ensure transformed data was not modified in place
assert_allclose(X2, X2_passed)
# Raise error if handle_unknown is neither ignore or error.
oh = OneHotEncoder(handle_unknown='42')
assert_raises(ValueError, oh.fit, X)
def test_one_hot_encoder_not_fitted():
X = np.array([['a'], ['b']])
enc = OneHotEncoder(categories=['a', 'b'])
msg = ("This OneHotEncoder instance is not fitted yet. "
"Call 'fit' with appropriate arguments before using this method.")
with pytest.raises(NotFittedError, match=msg):
enc.transform(X)
def test_one_hot_encoder_no_categorical_features():
X = np.array([[3, 2, 1], [0, 1, 1]], dtype='float64')
cat = [False, False, False]
enc = OneHotEncoder(categorical_features=cat)
with ignore_warnings(category=(DeprecationWarning, FutureWarning)):
X_tr = enc.fit_transform(X)
expected_features = np.array(list(), dtype='object')
assert_array_equal(X, X_tr)
assert_array_equal(enc.get_feature_names(), expected_features)
assert enc.categories_ == []
def test_one_hot_encoder_handle_unknown_strings():
X = np.array(['11111111', '22', '333', '4444']).reshape((-1, 1))
X2 = np.array(['55555', '22']).reshape((-1, 1))
# Non Regression test for the issue #12470
# Test the ignore option, when categories are numpy string dtype
# particularly when the known category strings are larger
# than the unknown category strings
oh = OneHotEncoder(handle_unknown='ignore')
oh.fit(X)
X2_passed = X2.copy()
assert_array_equal(
oh.transform(X2_passed).toarray(),
np.array([[0., 0., 0., 0.], [0., 1., 0., 0.]]))
# ensure transformed data was not modified in place
assert_array_equal(X2, X2_passed)
@pytest.mark.parametrize("output_dtype", [np.int32, np.float32, np.float64])
@pytest.mark.parametrize("input_dtype", [np.int32, np.float32, np.float64])
def test_one_hot_encoder_dtype(input_dtype, output_dtype):
X = np.asarray([[0, 1]], dtype=input_dtype).T
X_expected = np.asarray([[1, 0], [0, 1]], dtype=output_dtype)
oh = OneHotEncoder(categories='auto', dtype=output_dtype)
assert_array_equal(oh.fit_transform(X).toarray(), X_expected)
assert_array_equal(oh.fit(X).transform(X).toarray(), X_expected)
oh = OneHotEncoder(categories='auto', dtype=output_dtype, sparse=False)
assert_array_equal(oh.fit_transform(X), X_expected)
assert_array_equal(oh.fit(X).transform(X), X_expected)
@pytest.mark.parametrize("output_dtype", [np.int32, np.float32, np.float64])
def test_one_hot_encoder_dtype_pandas(output_dtype):
pd = pytest.importorskip('pandas')
X_df = pd.DataFrame({'A': ['a', 'b'], 'B': [1, 2]})
X_expected = np.array([[1, 0, 1, 0], [0, 1, 0, 1]], dtype=output_dtype)
oh = OneHotEncoder(dtype=output_dtype)
assert_array_equal(oh.fit_transform(X_df).toarray(), X_expected)
assert_array_equal(oh.fit(X_df).transform(X_df).toarray(), X_expected)
oh = OneHotEncoder(dtype=output_dtype, sparse=False)
assert_array_equal(oh.fit_transform(X_df), X_expected)
assert_array_equal(oh.fit(X_df).transform(X_df), X_expected)
def test_one_hot_encoder_set_params():
X = np.array([[1, 2]]).T
oh = OneHotEncoder()
# set params on not yet fitted object
oh.set_params(categories=[[0, 1, 2, 3]])
assert oh.get_params()['categories'] == [[0, 1, 2, 3]]
assert oh.fit_transform(X).toarray().shape == (2, 4)
# set params on already fitted object
oh.set_params(categories=[[0, 1, 2, 3, 4]])
assert oh.fit_transform(X).toarray().shape == (2, 5)
def check_categorical_onehot(X):
enc = OneHotEncoder(categories='auto')
Xtr1 = enc.fit_transform(X)
enc = OneHotEncoder(categories='auto', sparse=False)
Xtr2 = enc.fit_transform(X)
assert_allclose(Xtr1.toarray(), Xtr2)
assert sparse.isspmatrix_csr(Xtr1)
return Xtr1.toarray()
@pytest.mark.parametrize("X", [
[['def', 1, 55], ['abc', 2, 55]],
np.array([[10, 1, 55], [5, 2, 55]]),
np.array([['b', 'A', 'cat'], ['a', 'B', 'cat']], dtype=object)
], ids=['mixed', 'numeric', 'object'])
def test_one_hot_encoder(X):
Xtr = check_categorical_onehot(np.array(X)[:, [0]])
assert_allclose(Xtr, [[0, 1], [1, 0]])
Xtr = check_categorical_onehot(np.array(X)[:, [0, 1]])
assert_allclose(Xtr, [[0, 1, 1, 0], [1, 0, 0, 1]])
Xtr = OneHotEncoder(categories='auto').fit_transform(X)
assert_allclose(Xtr.toarray(), [[0, 1, 1, 0, 1], [1, 0, 0, 1, 1]])
def test_one_hot_encoder_inverse():
for sparse_ in [True, False]:
X = [['abc', 2, 55], ['def', 1, 55], ['abc', 3, 55]]
enc = OneHotEncoder(sparse=sparse_)
X_tr = enc.fit_transform(X)
exp = np.array(X, dtype=object)
assert_array_equal(enc.inverse_transform(X_tr), exp)
X = [[2, 55], [1, 55], [3, 55]]
enc = OneHotEncoder(sparse=sparse_, categories='auto')
X_tr = enc.fit_transform(X)
exp = np.array(X)
assert_array_equal(enc.inverse_transform(X_tr), exp)
# with unknown categories
X = [['abc', 2, 55], ['def', 1, 55], ['abc', 3, 55]]
enc = OneHotEncoder(sparse=sparse_, handle_unknown='ignore',
categories=[['abc', 'def'], [1, 2],
[54, 55, 56]])
X_tr = enc.fit_transform(X)
exp = np.array(X, dtype=object)
exp[2, 1] = None
assert_array_equal(enc.inverse_transform(X_tr), exp)
# with an otherwise numerical output, still object if unknown
X = [[2, 55], [1, 55], [3, 55]]
enc = OneHotEncoder(sparse=sparse_, categories=[[1, 2], [54, 56]],
handle_unknown='ignore')
X_tr = enc.fit_transform(X)
exp = np.array(X, dtype=object)
exp[2, 0] = None
exp[:, 1] = None
assert_array_equal(enc.inverse_transform(X_tr), exp)
# incorrect shape raises
X_tr = np.array([[0, 1, 1], [1, 0, 1]])
msg = re.escape('Shape of the passed X data is not correct')
assert_raises_regex(ValueError, msg, enc.inverse_transform, X_tr)
@pytest.mark.parametrize("X, cat_exp, cat_dtype", [
([['abc', 55], ['def', 55]], [['abc', 'def'], [55]], np.object_),
(np.array([[1, 2], [3, 2]]), [[1, 3], [2]], np.integer),
(np.array([['A', 'cat'], ['B', 'cat']], dtype=object),
[['A', 'B'], ['cat']], np.object_),
(np.array([['A', 'cat'], ['B', 'cat']]),
[['A', 'B'], ['cat']], np.str_)
], ids=['mixed', 'numeric', 'object', 'string'])
def test_one_hot_encoder_categories(X, cat_exp, cat_dtype):
# order of categories should not depend on order of samples
for Xi in [X, X[::-1]]:
enc = OneHotEncoder(categories='auto')
enc.fit(Xi)
# assert enc.categories == 'auto'
assert isinstance(enc.categories_, list)
for res, exp in zip(enc.categories_, cat_exp):
assert res.tolist() == exp
assert np.issubdtype(res.dtype, cat_dtype)
@pytest.mark.parametrize("X, X2, cats, cat_dtype", [
(np.array([['a', 'b']], dtype=object).T,
np.array([['a', 'd']], dtype=object).T,
[['a', 'b', 'c']], np.object_),
(np.array([[1, 2]], dtype='int64').T,
np.array([[1, 4]], dtype='int64').T,
[[1, 2, 3]], np.int64),
(np.array([['a', 'b']], dtype=object).T,
np.array([['a', 'd']], dtype=object).T,
[np.array(['a', 'b', 'c'])], np.object_),
], ids=['object', 'numeric', 'object-string-cat'])
def test_one_hot_encoder_specified_categories(X, X2, cats, cat_dtype):
enc = OneHotEncoder(categories=cats)
exp = np.array([[1., 0., 0.],
[0., 1., 0.]])
assert_array_equal(enc.fit_transform(X).toarray(), exp)
assert list(enc.categories[0]) == list(cats[0])
assert enc.categories_[0].tolist() == list(cats[0])
# manually specified categories should have same dtype as
# the data when coerced from lists
assert enc.categories_[0].dtype == cat_dtype
# when specifying categories manually, unknown categories should already
# raise when fitting
enc = OneHotEncoder(categories=cats)
with pytest.raises(ValueError, match="Found unknown categories"):
enc.fit(X2)
enc = OneHotEncoder(categories=cats, handle_unknown='ignore')
exp = np.array([[1., 0., 0.], [0., 0., 0.]])
assert_array_equal(enc.fit(X2).transform(X2).toarray(), exp)
def test_one_hot_encoder_unsorted_categories():
X = np.array([['a', 'b']], dtype=object).T
enc = OneHotEncoder(categories=[['b', 'a', 'c']])
exp = np.array([[0., 1., 0.],
[1., 0., 0.]])
assert_array_equal(enc.fit(X).transform(X).toarray(), exp)
assert_array_equal(enc.fit_transform(X).toarray(), exp)
assert enc.categories_[0].tolist() == ['b', 'a', 'c']
assert | np.issubdtype(enc.categories_[0].dtype, np.object_) | numpy.issubdtype |
#! -*- coding: utf-8 -*-
import numpy as np
from keras.layers import *
from keras.models import Model
from keras import backend as K
import imageio,os
from keras.datasets import mnist
# from keras.datasets import fashion_mnist as mnist
batch_size = 100
latent_dim = 20
# epochs = 50
epochs = 5
num_classes = 10
img_dim = 28
filters = 16
intermediate_dim = 256
# Load MNIST dataset
(x_train, y_train_), (x_test, y_test_) = mnist.load_data()
x_train = x_train.astype('float32') / 255.
x_test = x_test.astype('float32') / 255.
x_train = x_train.reshape((-1, img_dim, img_dim, 1))
x_test = x_test.reshape((-1, img_dim, img_dim, 1))
# 搭建模型
x = Input(shape=(img_dim, img_dim, 1))
h = x
for i in range(2):
filters *= 2
h = Conv2D(filters=filters,
kernel_size=3,
strides=2,
padding='same')(h)
h = LeakyReLU(0.2)(h)
h = Conv2D(filters=filters,
kernel_size=3,
strides=1,
padding='same')(h)
h = LeakyReLU(0.2)(h)
h_shape = K.int_shape(h)[1:]
h = Flatten()(h)
z_mean = Dense(latent_dim)(h) # p(z|x)的均值
z_log_var = Dense(latent_dim)(h) # p(z|x)的方差
encoder = Model(x, z_mean) # 通常认为z_mean就是所需的隐变量编码
z = Input(shape=(latent_dim,))
h = z
h = Dense(np.prod(h_shape))(h)
h = Reshape(h_shape)(h)
for i in range(2):
h = Conv2DTranspose(filters=filters,
kernel_size=3,
strides=1,
padding='same')(h)
h = LeakyReLU(0.2)(h)
h = Conv2DTranspose(filters=filters,
kernel_size=3,
strides=2,
padding='same')(h)
h = LeakyReLU(0.2)(h)
filters //= 2
x_recon = Conv2DTranspose(filters=1,
kernel_size=3,
activation='sigmoid',
padding='same')(h)
decoder = Model(z, x_recon) # 解码器
generator = decoder
z = Input(shape=(latent_dim,))
y = Dense(intermediate_dim, activation='relu')(z)
y = Dense(num_classes, activation='softmax')(y)
classfier = Model(z, y) # 隐变量分类器
# 重参数技巧
def sampling(args):
z_mean, z_log_var = args
epsilon = K.random_normal(shape=(K.shape(z_mean)[0], latent_dim))
return z_mean + K.exp(z_log_var / 2) * epsilon
# 重参数层，相当于给输入加入噪声
z = Lambda(sampling, output_shape=(latent_dim,))([z_mean, z_log_var])
x_recon = decoder(z)
y = classfier(z)
class Gaussian(Layer):
"""这是个简单的层，定义q(z|y)中的均值参数，每个类别配一个均值。
然后输出“z - 均值”，为后面计算loss准备。
"""
def __init__(self, num_classes, **kwargs):
self.num_classes = num_classes
super(Gaussian, self).__init__(**kwargs)
def build(self, input_shape):
latent_dim = input_shape[-1]
self.mean = self.add_weight(name='mean',
shape=(self.num_classes, latent_dim),
initializer='zeros')
def call(self, inputs):
z = inputs # z.shape=(batch_size, latent_dim)
z = K.expand_dims(z, 1)
return z - K.expand_dims(self.mean, 0)
def compute_output_shape(self, input_shape):
return (None, self.num_classes, input_shape[-1])
gaussian = Gaussian(num_classes)
z_prior_mean = gaussian(z)
# 建立模型
vae = Model(x, [x_recon, z_prior_mean, y])
# 下面一大通都是为了定义loss
z_mean = K.expand_dims(z_mean, 1)
z_log_var = K.expand_dims(z_log_var, 1)
lamb = 2.5 # 这是重构误差的权重，它的相反数就是重构方差，越大意味着方差越小。
xent_loss = 0.5 * K.mean((x - x_recon)**2, 0)
kl_loss = - 0.5 * (z_log_var - K.square(z_prior_mean))
kl_loss = K.mean(K.batch_dot(K.expand_dims(y, 1), kl_loss), 0)
cat_loss = K.mean(y * K.log(y + K.epsilon()), 0)
vae_loss = lamb * K.sum(xent_loss) + K.sum(kl_loss) + K.sum(cat_loss)
vae.add_loss(vae_loss)
vae.compile(optimizer='adam')
vae.summary()
vae.fit(x_train,
shuffle=True,
epochs=epochs,
batch_size=batch_size,
validation_data=(x_test, None))
means = K.eval(gaussian.mean)
x_train_encoded = encoder.predict(x_train)
y_train_pred = classfier.predict(x_train_encoded).argmax(axis=1)
x_test_encoded = encoder.predict(x_test)
y_test_pred = classfier.predict(x_test_encoded).argmax(axis=1)
def cluster_sample(path, category=0):
"""观察被模型聚为同一类的样本
"""
n = 8
figure = np.zeros((img_dim * n, img_dim * n))
idxs = | np.where(y_train_pred == category) | numpy.where |
# -*- coding: utf-8 -*-
"""
Created on Sat Jun 06 09:49:33 2015
@author: JMS
"""
import random
from abc import ABCMeta, abstractmethod
import numpy as np
import pandas as pd
from scipy.linalg import orth
from occupancy_map import Map,ZMap
from ptp import LocalArea,PointToPoint,matrixrank, anglebetween
from math import degrees
import json
import threading
from multiprocessing.pool import ThreadPool
from contextlib import closing
import scipy.spatial as spt
class PointType:
calibrated = "CALIBRATED" # Points that have both map coordinates
non_calibrated = "NON_CALIBRATED" # Points with map1 coordinates but not with map2.
target = "TARGET" # Points with map1 but that only can be predicted to map2.
acquired = "ACQUIRED" # Points with only map2 but with no information about map1
unknown = "NA"
class State:
"""
The class State is a special feature that does not correspond to the PointType.
The PointType is a static situation that gives identity to the point.
The state is something temporary that can be altered.
"""
protected = "PROTECTED" # Point has been manually overwritten and cannot be modified
blocked = "BLOCKED"
zeroed = "" # No especial states
class virtualGridMap(object):
"""
A virtual map is a class that gets all the information of the grid and tries
to give a prediction of unknown positions.
It considers two homologous maps and establishes correspondences between them.
E.g.:
- Given a LM coordinate, returns the corresponding estimation of the SEM (not possible in LM map)
- Given a letter returns the corresponding coordinates of the estimated center
- Given a coordinate, estimate the letter where we are going to land
Representation of the points
We have selected 4 different kind of points:
- Non Calibrated NC: points coming from LM without assigned correspondence, used for calibration
- Calibrated C: points coming from LM, with the correspondent SEM coordinates, used for calibration
- Targets T: points coming from LM used for targeting
- Acquisition Acq: points acquired on the fly
Instead of saving the points in 4 different lists, we are saving all of them in one array and then
saving the indices for each categorie (Ind).
That allows having points belonging to more than one categorie, or easily to introduce
more category points.
Could be a 2D or a 3D
"""
__metaclass__ = ABCMeta
warning_transformation =""
map_lock = threading.Lock()
def __init__(self,logger, force2D =False, parent = None):
self.logger = logger
self.current_pos = "" # Landmark reference
self.last_point_added = ""
# LANDMARK
# Dataframe instead of class reason it is because the
# porting to a file is immediate and the managing of lists of arrays too.
# In design terms, having a Landmark class would be much better, but in practical terms
# slows down. The following is a mixture between class and database, linked by the landmark ID
self.columns = [ 'LANDMARK','TYPE', 'STATE',
'UPDATE_ORIGIN','UPDATE_DESTINY','UPDATE_TAG',
'COORDS_ORIGIN_X', 'COORDS_ORIGIN_Y', 'COORDS_ORIGIN_Z',
'COORDS_DESTINY_X', 'COORDS_DESTINY_Y', 'COORDS_DESTINY_Z']
#
self.rms_avg = []
self.rms_sd = []
self.columns_corigin = ['LANDMARK','BELIEF','COORDS_ORIGIN_X', 'COORDS_ORIGIN_Y', 'COORDS_ORIGIN_Z']
self.columns_cdestiny =['LANDMARK','BELIEF','COORDS_DESTINY_X', 'COORDS_DESTINY_Y', 'COORDS_DESTINY_Z']
if(force2D):
self.col_dim_coords_origin = ['COORDS_ORIGIN_X','COORDS_ORIGIN_Y']
self.col_dim_coords_destiny = ['COORDS_DESTINY_X','COORDS_DESTINY_Y']
else:
self.col_dim_coords_origin = ['COORDS_ORIGIN_X', 'COORDS_ORIGIN_Y','COORDS_ORIGIN_Z']
self.col_dim_coords_destiny = ['COORDS_DESTINY_X', 'COORDS_DESTINY_Y','COORDS_DESTINY_Z']
self.col_reset = ['RMS_AVG','RMS_SD']
self.map_df = pd.DataFrame(columns=self.columns)
self.cor_df = pd.DataFrame(columns=self.columns_corigin)
self.cde_df = pd.DataFrame(columns=self.columns_cdestiny)
self.list_local_area = {} # every point can have a radius of action
# List of error associated to each point
self.list_errorOrigin = {}
self.list_errorDestiny = {}
self.map_exists = False
self.map_id = "map1_map2"
self.CalibratedPtp = PointToPoint()
self.GlobalPtp = PointToPoint()
# Occupancy map
self.grid_map = Map(1)
self.orientation = 0
@staticmethod
def dist_microns(x, y):
return np.sqrt(np.sum((x - y) ** 2)) * 1000.0 ## Error in um
@staticmethod
def dist(x, y):
if (x[0] == np.inf or x[1] == np.inf or y[0] == np.inf or y[1] == np.inf):
return np.inf
else:
return np.sqrt(np.sum((x - y) ** 2))
def checkValidSystem(self, calculateOrientation = False):
# Get all calibration points
coordsOrigin, coordsDestiny, pids = self.getLandmarksByType(PointType.calibrated)
coordsDestiny = coordsDestiny[:,0:2]
if(matrixrank(coordsDestiny,1)>=2):
# TODO : calculate orientation based on data
# A = orth(coordsDestiny)
# angle = anglebetween(A[0],[1,0])
#if(calculateOrientation):
# self.orientation = np.rad2deg(angle) # this angle has to b
return True
def unit_vector(vector):
""" Returns the unit vector of the vector. """
eps = np.finfo(np.float32).eps
if (np.sum(np.linalg.norm(vector)) < eps):
return vector
return vector / np.linalg.norm(vector)
def collinear(p0, p1, p2):
x1, y1 = p1[0] - p0[0], p1[1] - p0[1]
x2, y2 = p2[0] - p0[0], p2[1] - p0[1]
val = x1 * y2 - x2 * y1
return abs(val) < 1e-2
def loadMap(self,dict_map):
# Split in 3 dictionaries
stmap = dict_map['MAP']
stcor = dict_map['COR']
stcde = dict_map['CDE']
self.map_df = pd.read_json(stmap)
self.cor_df = pd.read_json(stcor)
self.cde_df = pd.read_json(stcde)
for index, row in self.map_df.iterrows():
p_id = str(row['LANDMARK'])
self.list_local_area[p_id] = LocalArea()
def isEmpty(self,arr):
arr = np.array(arr)
if not | np.any(arr.shape) | numpy.any |
# Tests a gait recognizer CNN
# This version uses a custom DataGenerator
__author__ = '<NAME>'
__copyright__ = 'February 2021'
import os
import sys
import numpy as np
import os.path as osp
from os.path import expanduser
import pathlib
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
maindir = pathlib.Path(__file__).parent.absolute()
if sys.version_info[1] >= 6:
sys.path.insert(0, osp.join(maindir, ".."))
else:
sys.path.insert(0, str(maindir) + "/..")
homedir = expanduser("~")
sys.path.insert(0, homedir + "/gaitmultimodal")
sys.path.insert(0, homedir + "/gaitmultimodal/mains")
import deepdish as dd
from sklearn.metrics import confusion_matrix, top_k_accuracy_score
import statistics
from data.dataGenerator import DataGeneratorGait
from nets.mj_gaitcopy_model import GaitCopyModel
from sklearn.neighbors import KNeighborsClassifier
from utils.mj_netUtils import mj_epochOfModelFile
# --------------------------------
import tensorflow as tf
gpu_rate = 0.5
if "GPU_RATE" in os.environ:
gpu_rate = float(os.environ["GPU_RATE"])
theSEED = 232323
tf.random.set_seed(theSEED)
config = tf.compat.v1.ConfigProto()
# Don't pre-allocate memory; allocate as-needed
config.gpu_options.allow_growth = True
config.gpu_options.per_process_gpu_memory_fraction = gpu_rate # TODO
tf.executing_eagerly()
graph = tf.Graph()
graph.as_default()
session = tf.compat.v1.Session(graph=graph, config=config)
session.as_default()
# --------------------------------
def encodeData(data_generator, model, modality):
all_vids = []
all_gt_labs = []
all_feats = []
nbatches = len(data_generator)
if modality == "of":
reshape = True
else:
reshape = False
for bix in range(nbatches):
data, labels, videoId, cams, fname = data_generator.__getitemvideoid__(bix)
feats = model.encode(data, reshape)
all_feats.extend(feats)
all_vids.extend(videoId)
all_gt_labs.extend(labels[:, 0])
return all_feats, all_gt_labs, all_vids
def testData(data_generator, model, clf, outpath, outpathres="", save=False):
all_feats, all_gt_labs, all_vids = encodeData(data_generator, model, modality)
# Save CM
if save:
exper = {}
exper["feats"] = all_feats
exper["gtlabs"] = all_gt_labs
exper["vids"] = all_vids
dd.io.save(outpath, exper)
print("Data saved to: " + outpath)
all_pred_labs = clf.predict(all_feats)
all_pred_probs = clf.predict_proba(all_feats)
# Summarize per video
uvids = np.unique(all_vids)
# Majority voting per video
all_gt_labs_per_vid = []
all_pred_labs_per_vid = []
all_pred_probs_per_vid = []
for vix in uvids:
idx = np.where(all_vids == vix)[0]
try:
gt_lab_vid = statistics.mode(list(np.asarray(all_gt_labs)[idx]))
except:
gt_lab_vid = np.asarray(all_gt_labs)[idx][0]
try:
pred_lab_vid = statistics.mode(list( | np.asarray(all_pred_labs) | numpy.asarray |
from pypylon import pylon
from GhostScan.Camera import Camera
from abc import ABC
import numpy as np
import cv2
import os, time, math
from skimage import io
from io import BytesIO
from IPython.display import clear_output, Image, display, update_display
import PIL
from GhostScan.Cameras.liveDisplay import ptgCamStream, imgShow, patternDisplay
from GhostScan.Cameras.PySpinCapture import PySpinCapture as psc
import matplotlib.pyplot as plt
class Basler(Camera, ABC):
def __init__(self, exposure=0.01, white_balance=0, auto_focus=False, grayscale=True):
# TODO: pylon.FeaturePersistence.Save("test.txt", camera.GetNodeMap())
# Setting and initializing the Basler camera
self.cap = pylon.InstantCamera(pylon.TlFactory.GetInstance().CreateFirstDevice())
self.cap.Open()
if self.cap is None:
print('Warning: unable to open external Basler camera')
# Get framerate and resolution of camera
fps = self.getFPS()
resolution = self.getResolution()
# Init base class
super().__init__(exposure, white_balance, auto_focus, fps, resolution, grayscale)
self.hdr_exposures = None
def setDir(self, directory, sessionName):
self.directory = directory
self.sessionName = sessionName
self.sessionDir = os.path.join(self.directory, self.sessionName)
print(self.sessionDir)
if not os.path.exists(self.sessionDir):
os.makedirs(self.sessionDir)
def getAutoExposure(self):
# Returns if auto exposure is enabled
return self.cap.ExposureAuto.GetValue()
def setAutoExposure(self):
# Turn on auto exposure
self.cap.ExposureAuto.SetValue("Continuous")
def getFPS(self):
# Returns the frame rate
return self.cap.AcquisitionFrameRate.GetValue()
def setFPS(self, fps):
# Sets frame rate
self.cap.AcquisitionFrameRate.SetValue(fps)
self.fps = fps
def setAutoGain(self):
# Set auto gain
self.cap.GainAuto.SetValue("Once")
def getGain(self):
# Returns the set gain value
return self.cap.Gain.GetValue()
def setGain(self, gain):
# Turn off auto gain
self.cap.GainAuto.SetValue("Off")
# Set gain value
self.cap.Gain.SetValue(gain)
def getResolution(self):
# Returns a tuple resolution (width, height)
resolution = (self.cap.Width.GetValue(), self.cap.Height.GetValue())
return resolution
def setResolution(self, resolution):
# Sets the image resolution
self.cap.Width.SetValue(resolution[0])
self.cap.Height.SetValue(resolution[1])
self.resolution = resolution
def setSingleFrameCapture(self):
# Set single frame acquisition mode
self.cap.AcquisitionMode.SetValue('SingleFrame')
def setHDRExposureValues(self, exposures):
self.hdr_exposures = exposures
def setExposure(self, exposure):
# Set auto exposure off
self.cap.ExposureAuto.SetValue("Off")
# Set exposure value in microseconds
self.cap.ExposureTime.SetValue(exposure)
self.exposure = exposure
def getExposure(self):
# Returns exposure value in microseconds
return self.cap.ExposureTime.GetValue()
def getHDRImage(self, name='test', saveImage=True, saveNumpy=True, timeout=5000):
if self.calibration is None:
print("Initialize calibration object of camera class first")
self.cap.StartGrabbingMax(1)
img = pylon.PylonImage()
frames = []
for e in self.hdr_exposures:
self.setExposure(e)
while self.cap.IsGrabbing():
# Grabs photo from camera
grabResult = self.cap.RetrieveResult(timeout, pylon.TimeoutHandling_ThrowException)
if grabResult.GrabSucceeded():
# Access the image data.
frame = grabResult.Array
img.AttachGrabResultBuffer(grabResult)
grabResult.Release()
frames.append(frame)
hdr_frame = self.calibration.radio_calib.get_HDR_image(frames, self.hdr_exposures)
if saveNumpy:
np.save('CapturedNumpyData/' + name, hdr_frame)
if saveImage:
png_frame = (hdr_frame - np.min(hdr_frame)) / (np.max(hdr_frame) - np.min(hdr_frame))
png_frame *= 255.0
io.imsave('CapturedImages/' + name + '.PNG', png_frame.astype(np.uint8))
return hdr_frame
def getImage(self, name='test', saveImage=True, saveNumpy=True, calibration=False, timeout=5000):
try:
# Take and return current camera frame
self.cap.StartGrabbingMax(1)
img = pylon.PylonImage()
while self.cap.IsGrabbing():
# Grabs photo from camera
grabResult = self.cap.RetrieveResult(timeout, pylon.TimeoutHandling_ThrowException)
if grabResult.GrabSucceeded():
# Access the image data.
frame = grabResult.Array
img.AttachGrabResultBuffer(grabResult)
grabResult.Release()
# Save if desired
if saveImage:
if calibration:
filename = 'CalibrationImages/' + name + '.raw'
filenamePNG = 'CalibrationImages/' + name + '.PNG'
img.Save(pylon.ImageFileFormat_Raw, filename)
img.Save(pylon.ImageFileFormat_Png, filenamePNG)
else:
filename = 'CapturedImages/' + name + '.PNG'
img.Save(pylon.ImageFileFormat_Png, filename)
if saveNumpy:
if calibration:
np.save('CalibrationNumpyData/' + name, frame)
else:
np.save('CapturedNumpyData/' + name, frame)
img.Release()
self.cap.StopGrabbing()
return frame
except SystemError:
self.quit_and_open()
return None
def viewCameraStream(self):
# Display live view
while True:
cv2.namedWindow('Basler Machine Vision Stream', cv2.WINDOW_NORMAL)
img = self.getImage(saveImage=False, saveNumpy=False)
print("Max: ", np.max(img))
print("Min: ", np.min(img))
cv2.imshow('Basler Machine Vision Stream', img)
c = cv2.waitKey(1)
if c != -1:
# When everything done, release the capture
cv2.destroyAllWindows()
break
def viewCameraStreamSnapshots(self):
# Display live view
while True:
cv2.namedWindow('Basler Machine Vision Stream', cv2.WINDOW_NORMAL)
img = self.getImage(saveImage=False, saveNumpy=False)
cv2.imshow('Basler Machine Vision Stream', img)
c = cv2.waitKey(1)
if c != -1:
# When everything done, release the capture
cv2.destroyAllWindows()
self.quit_and_open()
break
def viewCameraStreamJupyter(self):
# Live view in a Jupyter Notebook
try:
start = self.getImage(saveImage=False, saveNumpy=False)
g = BytesIO()
PIL.Image.fromarray(start).save(g, 'jpeg')
obj = Image(data=g.getvalue())
dis = display(obj, display_id=True)
while True:
img = self.getImage(saveImage=False, saveNumpy=False)
if img is None:
break
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
f = BytesIO()
PIL.Image.fromarray(img).save(f, 'jpeg')
obj = Image(data=f.getvalue())
update_display(obj, display_id=dis.display_id)
clear_output(wait=True)
except KeyboardInterrupt:
self.quit_and_open()
def quit_and_close(self):
# Close camera
self.cap.Close()
def quit_and_open(self):
# Close camera
self.cap.Close()
# Create new capture
self.cap = pylon.InstantCamera(pylon.TlFactory.GetInstance().CreateFirstDevice())
self.cap.Open()
def getStatus(self):
pylon.FeaturePersistence.Save("Basler_Specs.txt", self.cap.GetNodeMap())
try:
from Cameras.PySpinCapture import PySpinCapture as psc
print('1')
except ImportError:
PySpinCapture = None
DISPLAY_HEIGHT = 1080
DISPLAY_WIDTH = 1920
NUM_PATTERN = 7
DEFLECTOMETRY_FREQ = 0.9
class Flir(Camera, ABC):
def __init__(self, exposure=0.01, white_balance=1, auto_focus=False, grayscale=False):
self.sessionDir = None
self._isMonochrome = True
self._is16bits = True
self.NumPatterns = NUM_PATTERN
self.displayWidth = DISPLAY_WIDTH
self.displayHeight = DISPLAY_HEIGHT
self.setDefPattern()
self.Cam = psc(0, self._isMonochrome, self._is16bits)
self.height = self.Cam.height
self.width = self.Cam.width
fps = self.getFPS()
resolution = self.getResolution()
super().__init__(exposure, white_balance, auto_focus, fps, resolution, grayscale)
self.hdr_exposures = None
def getImage(self, name='test', saveImage=True, saveNumpy=True, calibration=False, timeout=5000, calibrationName = None):
try:
# Take and return current camera frame
success, img = self.Cam.grabFrame()
# Save if desired
if saveImage:
if calibration:
#filename = 'CalibrationImages/' + name + '.raw'
filenamePNG = 'CalibrationImages/' + name + '.PNG'
cv2.imwrite(filenamePNG,cv2.cvtColor(img,cv2.COLOR_BGR2RGB))
else:
filename = 'CapturedImages/' + name + '.PNG'
cv2.imwrite(filename, cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
if saveNumpy:
if calibration:
np.save('CalibrationNumpyData/' + name, img)
else:
np.save('CapturedNumpyData/' + name, img)
# self.Cam.release()
return img
except SystemError:
self.quit_and_open()
return None
def setExposure(self, exposure):
self.Cam.setExposure(exposure)
def getExposure(self):
return self.Cam.getExposure()
def getFPS(self):
return self.Cam.getFPS()
def setFPS(self, fps):
self.Cam.setFPS(fps)
def setAutoGain(self):
self.Cam.setCamAutoProperty()
def getGain(self):
return self.Cam.getGain()
def setGain(self, gain):
self.Cam.setGain(gain)
def captureImage(self, fname):
if fname:
path = 'CapturedImages/' + fname + '.png'
#path = os.path.join(self.sessionDir, fname + ".png")
flag, img = self.Cam.grabFrame()
if not flag:
print("[ERROR]: Didn't get the image!!!")
else:
cv2.imwrite(path, img, [cv2.IMWRITE_PNG_COMPRESSION, 0])
else:
flag, img = self.Cam.grabFrame()
print("capture!!!!")
if not flag:
print("[ERROR]: Didn't get the image!!!")
return None
else:
return img
def sinePattern(self, x, y, nu_x, nu_y):
# Phase Shifts (first entry is white light modulation)
theta = [0, np.pi / 2, np.pi, 3 / 2 * np.pi]
[X, Y, Theta] = np.meshgrid(x, y, theta)
# Calculate Phase Shifts
phase = (nu_x * X + nu_y * Y) + Theta
# Simple formula to create fringes between 0 and 1:
pattern = (np.sin(phase) + 1) / 2
return pattern
def setPatternScale(self, mode=1):
patternSize = min(self.displayHeight, self.displayWidth)
boarderSize = math.floor((max(self.displayHeight, self.displayWidth) - patternSize)/2)
if mode == 0:
# Img sequences[7]: {gh, ch, gv, cv, g2h, g2v, black}
self.NumPatterns = 7
elif mode == 1:
# Img sequences[8]: {gh, ch, gv, cv, g2h, g2v, black, full}
self.NumPatterns = 8
elif mode == 2:
# Img sequences[9]: {h1, h2, h3, h4, v1, v2, v3, v4, black}
self.NumPatterns = 9
elif mode == 3:
# Img sequences[9]: {h1, h2, h3, h4, v1, v2, v3, v4, black, full}
self.NumPatterns = 10
else:
self.NumPatterns = 8
print("[WARNING]: Unrecognizable mode. Using Gradient Pattern!!")
self.patterns = np.zeros((self.displayHeight, self.displayWidth, self.NumPatterns), dtype=np.float32)
return patternSize, boarderSize
def setDefPattern(self):
#patternSize, boarderSize = self.setPatternScale(2)
patternSize, boarderSize = self.setPatternScale(2)
patternSize = max(self.displayHeight, self.displayWidth)
#patternSize = min(self.displayHeight, self.displayWidth)
# Create spatial coordinates
x = np.linspace(1, self.displayWidth, self.displayWidth)
y = np.linspace(1, self.displayHeight, self.displayHeight)
# Frequencies in x and y direction.
nu_x = DEFLECTOMETRY_FREQ * 2 * np.pi / patternSize
nu_y = DEFLECTOMETRY_FREQ * 2 * np.pi / patternSize
self.patterns[..., 0:4] = self.sinePattern(x, y, nu_x, 0)
self.patterns[..., 4:8] = self.sinePattern(x, y, 0, nu_y)
# self.patterns[..., 8] = 127 * np.ones((DISPLAY_HEIGHT,DISPLAY_WIDTH))
def captureSeqImages(self):
window_name = 'projector'
cv2.namedWindow(window_name, cv2.WND_PROP_FULLSCREEN)
# If projector is placed right to main screen (see windows properties in your operating system)
# if the pattern is displayed at the wrong monitor you need to play around with the coordinates here until the image is displayed at the right screen
cv2.moveWindow(window_name, self.displayWidth, 0)
cv2.setWindowProperty(window_name, cv2.WND_PROP_FULLSCREEN,cv2.WINDOW_FULLSCREEN)
cv2.imshow(window_name, self.patterns[..., 0].astype(np.float32))
if self._isMonochrome:
if self._is16bits:
imgs = np.zeros((self.NumPatterns, self.height, self.width), dtype=np.uint16)
else:
imgs = np.zeros((self.NumPatterns, self.height, self.width), dtype=np.uint8)
else:
if self._is16bits:
imgs = | np.zeros((self.NumPatterns, self.height, self.width, 3), dtype=np.uint16) | numpy.zeros |
import numpy as np
I = 100
J = 2
beta_0 = -1
beta_1 = 1
sigma_u = 0.5
sigma_eps = 1
iteration = 30
initial = [0, 0, 5, 5]
result = []
def xE(E_t):
return sum(sum(value_x * np.array([E_t, E_t]).T))
def eps_right(E_t, beta0, beta1):
return (sum(sum((value_y - beta0-beta1*value_x)**2)) + J * sum(E_t**2) - 2*sum(sum((value_y - beta0 - beta1*value_x) * np.array([E_t, E_t]).T)))/(I*J)
for i in range(500):
# data generation
np.random.seed(i)
value_x = np.random.normal(0, 1, (I, J))
u = np.random.normal(0, sigma_u, I)
value_u = np.ones((I, J))
value_u[:, 0] = u
value_u[:, 1] = u
value_eps = | np.random.normal(0, sigma_eps, (I, J)) | numpy.random.normal |
import tensorflow as tf
import numpy as np
import os
import cv2
from pyrr import Quaternion
import copy
object_names = ['ape','cam','cat','duck','glue','iron','phone',
'benchvise','can','driller','eggbox','holepuncher','lamp']
object_names_occlusion = ['ape','cat','duck','glue','can','driller','eggbox','holepuncher']
object_indeces = [it for it in range(len(object_names))]
camera_intrinsic_matrix_syn = np.array([[700., 0., 320.],
[0., 700., 240.],
[0., 0., 1.]])
camera_intrinsic_matrix_real = np.array([[572.41140, 0. , 325.26110],
[0. , 573.57043, 242.04899],
[0. , 0. , 1. ]])
R_init = np.array([
[1.0, 0.0, 0.0],
[0.0, 1.0, 0.0],
[0.0, 0.0, 1.0],
])
def save_tf_record_file(out_folder, it_tf_record, examples):
tf_num = "%06d" % it_tf_record
tfrecord_file_out = os.path.join(out_folder, tf_num + '.tfrecord')
with tf.python_io.TFRecordWriter(tfrecord_file_out) as writer:
for it_save in range(len(examples)):
it_example = examples[it_save]
writer.write(it_example.SerializeToString())
return None
def proccess_real_data_occlusion_linemod(in_folder_name, linemod_folder, init_pose_folder_name, out_folder_name, each_object_separate=False):
out_folder_name = os.path.join(out_folder_name, 'linemod_occlusion')
if not os.path.exists(out_folder_name):
os.mkdir(out_folder_name)
for it_obj in range(len(object_names)):
if not object_names[it_obj] in object_names_occlusion:
continue
print("Object name: " + object_names[it_obj] + ", object index num: " + str(it_obj))
folder_poses = os.path.join(in_folder_name, 'blender_poses', object_names[it_obj])
folder_images = os.path.join(in_folder_name, 'RGB-D', 'rgb_noseg')
out_folder_name_obj = os.path.join(out_folder_name, object_names[it_obj])
if not os.path.exists(out_folder_name_obj):
os.mkdir(out_folder_name_obj)
occlusion_test_file = os.path.join(linemod_folder, object_names[it_obj], 'test_occlusion.txt')
inds = np.loadtxt(occlusion_test_file, np.str)
inds = [int(os.path.basename(ind).replace('.jpg', '')) for ind in inds]
it_tf_record = 0
examples = []
for it_img, it_indx in enumerate(inds):
if each_object_separate:
if not (len(examples) == 0):
print(it_img)
save_tf_record_file(out_folder_name_obj, it_tf_record, examples)
it_tf_record += 1
examples = []
else:
if (it_img % 100) == 0:
if not (len(examples) == 0):
print(it_img)
save_tf_record_file(out_folder_name_obj, it_tf_record, examples)
it_tf_record += 1
examples = []
it_obj_name_pose = "pose" + str(it_indx) + ".npy"
it_obj_name_img = "color_" + "%05d" % it_indx + ".png"
poses_file = os.path.join(folder_poses, it_obj_name_pose)
image_file = os.path.join(folder_images, it_obj_name_img)
pos = np.zeros((1, 3))
quat = np.zeros((1, 4))
if os.path.exists(poses_file):
data = np.load(poses_file)
else:
data = np.array([[1.0, 0.0, 0.0, 1.0],
[0.0, 1.0, 0.0, 1.0],
[0.0, 0.0, 1.0, 1.0], ])
R_mat = data[:3, :3]
pos[0, :] = data[:3, 3]
quat[0, :] = Quaternion.from_matrix(R_mat)
cls_indexes = [object_indeces[it_obj]]
cls_indexes_num = [1]
# read image
img_name = os.path.join(folder_images, image_file)
out_img = cv2.imread(img_name)
encode_image = tf.compat.as_bytes(cv2.imencode(".png", out_img)[1].tostring())
# read init pose
it_obj_name_init = "%06d" % it_img + "_predict.npy"
init_pose_file = os.path.join(init_pose_folder_name, object_names[it_obj], it_obj_name_init)
predict_data = | np.load(init_pose_file, allow_pickle='TRUE') | numpy.load |
"""An implementation of the k-fingerprinting classifier from:
<NAME>, and <NAME>. "k-fingerprinting: A robust
scalable website fingerprinting technique." 25th {USENIX} Security
Symposium ({USENIX} Security 16). 2016.
Minor adjustments to the work of the original authors from the paper. The
original can be found at https://github.com/jhayes14/k-FP.
"""
import math
import logging
import itertools
import functools
import tempfile
from typing import Tuple, Union, Sequence, Optional
import multiprocessing
import h5py
import numpy as np
from lab.trace import Direction, Trace
DEFAULT_NUM_FEATURES = 165
_LOGGER = logging.getLogger(__name__)
# --------------------
# Non-feeder functions
# --------------------
def split_in_out(list_data: Trace, check: bool = True) -> Tuple[Trace, Trace]:
"""Returns a tuple of the packets in the (incoming, outgoing) subtraces.
Raise AssertionError if check is true and the trace has no incoming or no
outgoing packets.
"""
# Use a fast-path for np record arrays
if isinstance(list_data, np.recarray):
incoming = list_data[list_data["direction"] < 0]
outgoing = list_data[list_data["direction"] > 0]
else:
incoming = [pkt for pkt in list_data if pkt.direction == Direction.IN]
outgoing = [pkt for pkt in list_data if pkt.direction == Direction.OUT]
if check:
assert len(incoming) > 0 and len(outgoing) > 0
return (incoming, outgoing)
def _get_timestamps(array_like) -> np.ndarray:
if isinstance(array_like, np.recarray):
return array_like["timestamp"]
return np.array([x[0] for x in array_like])
# -------------
# TIME FEATURES
# -------------
def _inter_pkt_time(list_data):
if len(list_data) == 1:
return [0.0, ]
times = _get_timestamps(list_data)
return (np.concatenate((times[1:], [times[0]])) - times)[:-1]
def interarrival_times(list_data):
"""Return the interarrival times of the incoming, outgoing, and overall
packet sequences.
"""
incoming, outgoing = split_in_out(list_data)
inter_in = _inter_pkt_time(incoming)
inter_out = _inter_pkt_time(outgoing)
inter_overall = _inter_pkt_time(list_data)
return inter_in, inter_out, inter_overall
def _prefix_keys(mapping: dict, prefix: Union[str, Sequence[str]]) -> dict:
if not isinstance(prefix, str):
prefix = '::'.join(prefix)
return {f'{prefix}::{key}': mapping[key] for key in mapping}
def _interarrival_stats(times: Sequence[float]) -> dict:
return {
'mean': np.mean(times) if len(times) > 0 else 0,
'max': max(times, default=0),
'std': np.std(times) if len(times) > 0 else 0,
'percentile-75': np.percentile(times, 75) if len(times) > 0 else 0
}
def interarrival_stats(list_data: Trace) -> dict:
"""Extract the mean, std, max, 75th-percentile for the incoming,
outgoing, and overall traces.
"""
incoming, outgoing, overall = interarrival_times(list_data)
return {
**_prefix_keys(_interarrival_stats(incoming), ['interarrival', 'in']),
**_prefix_keys(_interarrival_stats(outgoing), ['interarrival', 'out']),
**_prefix_keys(_interarrival_stats(overall),
['interarrival', 'overall']),
}
def time_percentiles(overall: Trace) -> dict:
"""Return the 25th, 50th, 75th and 100th percentiles of the timestamps."""
incoming, outgoing = split_in_out(overall)
def _percentiles(trace):
times = _get_timestamps(trace)
return {f'percentile-{p}': (np.percentile(times, p)
if len(times) > 0 else 0)
for p in [25, 50, 75, 100]}
return {
**_prefix_keys(_percentiles(incoming), ['time', 'in']),
**_prefix_keys(_percentiles(outgoing), ['time', 'out']),
**_prefix_keys(_percentiles(overall), ['time', 'overall']),
}
def packet_counts(overall: Trace) -> dict:
"""Return the number of incoming, outgoing and combined packets."""
incoming, outgoing = split_in_out(overall, check=False)
return {
'packet-counts::in': len(incoming),
'packet-counts::out': len(outgoing),
'packet-counts::overall': len(overall)
}
def head_and_tail_concentration(overall: Trace, count: int) -> dict:
"""Return the number of incoming and outgoing packets in the first and last
'count' packets of the trace.
"""
assert count > 0
head = packet_counts(overall[:count])
del head['packet-counts::overall']
tail = packet_counts(overall[-count:])
del tail['packet-counts::overall']
return {
**_prefix_keys(head, f'first-{count}'),
**_prefix_keys(tail, f'last-{count}')
}
def packet_concentration_stats(overall: Trace, chunk_size: int) \
-> Tuple[dict, Sequence[int]]:
"""Return the std, mean, min, max and median of the number of
outgoing packets in each chunk of the trace; as well as the
sequence of outgoing concentrations.
Each chunk is created with 'chunk_size' packets.
"""
concentrations = []
for index in range(0, len(overall), chunk_size):
chunk = overall[index:(index + chunk_size)]
concentrations.append(packet_counts(chunk)['packet-counts::out'])
return _prefix_keys({
'std::out': np.std(concentrations),
'mean::out': np.mean(concentrations),
'median::out': np.median(concentrations),
'min::out': min(concentrations),
'max::out': max(concentrations),
}, 'concentration-stats'), concentrations
def alternate_concentration(concentration: Sequence[int], length: int) \
-> Sequence[int]:
"""Return a fixed length sequence of the number of outgoing packets.
The sequence of concentrations, where each value is the number of
outgoing packets in a set of 20, is then partitioned into 20 sequences
and each sequence is summed. This roughly equates to divide the original
sequence into 20 and counting the # of outgoing packets in each. They
differ as the resulting groups may slighly vary depending on the length
of the sequence. We therefore use the approach from the paper.
"""
# We use the array_split implementation as the chunkIt code was flawed and
# may return more chunks than requested.
result = [sum(group) for group in np.array_split(concentration, length)]
assert len(result) == length
return result
def alternate_packets_per_second(pps: Sequence[int], length: int) \
-> Tuple[dict, Sequence[int]]:
"""Return a fixed length sequence of the pps rate, as well as the sum of
the rate
"""
# We use the array_split implementation as the chunkIt code was flawed and
# may return more chunks than requested.
result = [sum(group) for group in np.array_split(pps, length)]
assert len(result) == length
return {'alt-pps::sum': sum(result)}, result
def packets_per_second_stats(overall: Trace) \
-> Tuple[dict, Sequence[int]]:
"""Return the mean, std, min, median and max number of packets per
second, as well as the number of packets each second.
"""
n_seconds = math.ceil(overall[-1].timestamp)
packets_per_sec, _ = np.histogram(
_get_timestamps(overall), bins=n_seconds, range=(0, n_seconds))
packets_per_sec = list(packets_per_sec)
return {
'pps::mean': np.mean(packets_per_sec),
'pps::std': np.std(packets_per_sec),
'pps::median': np.median(packets_per_sec),
'pps::min': min(packets_per_sec),
'pps::max': max(packets_per_sec)
}, packets_per_sec
def packet_ordering_stats(overall: Trace) -> dict:
"""Mean and std of a variant of the packet ordering features."""
# Note that the ordering here is different from the k-fingerprinting
# reference implementation. They have out and in swapped.
if isinstance(overall, np.recarray):
in_preceeding = np.nonzero(overall["direction"] < 0)[0]
out_preceeding = np.nonzero(overall["direction"] > 0)[0]
else:
in_preceeding = [i for i, pkt in enumerate(overall)
if pkt.direction == Direction.IN]
out_preceeding = [i for i, pkt in enumerate(overall)
if pkt.direction == Direction.OUT]
return {
'packet-order::out::mean': np.mean(out_preceeding),
'packet-order::in::mean': np.mean(in_preceeding),
'packet-order::out::std': np.std(out_preceeding),
'packet-order::in::std': np.std(in_preceeding),
}
def in_out_fraction(overall: Trace) -> dict:
"""Return the fraction of incoming and outgoing packets."""
counts = packet_counts(overall)
n_packets = counts['packet-counts::overall']
return {
'fraction-incoming': counts['packet-counts::in'] / n_packets,
'fraction-outgoing': counts['packet-counts::out'] / n_packets
}
# -------------
# SIZE FEATURES
# -------------
def _get_sizes(array_like):
if isinstance(array_like, np.recarray):
return array_like["size"]
return [x[2] for x in array_like]
def total_packet_sizes(overall: Trace) -> dict:
"""Return the total incoming, outgoing and overall packet sizes."""
incoming, outgoing = split_in_out(overall)
# Use absolute value in case the input sizes are signed
result = {
'total-size::in': np.sum(np.abs(_get_sizes(incoming))),
'total-size::out': np.sum(np.abs(_get_sizes(outgoing))),
}
result['total-size::overall'] = result['total-size::in'] \
+ result['total-size::out']
return result
def _packet_size_stats(trace: Trace) -> dict:
sizes = _get_sizes(trace)
return {
'mean': np.mean(sizes), 'var': np.var(sizes),
'std': np.std(sizes), 'max': np.max(sizes)
}
def packet_size_stats(overall: Trace) -> dict:
"""Return the mean, var, std, and max of the incoming, outgoing,
and overall packet traces.
"""
incoming, outgoing = split_in_out(overall)
return {
**_prefix_keys(_packet_size_stats(incoming), 'size-stats::in'),
**_prefix_keys(_packet_size_stats(outgoing), 'size-stats::out'),
**_prefix_keys(_packet_size_stats(overall), 'size-stats::overall'),
}
# ----------------
# FEATURE FUNCTION
# ----------------
def make_trace_array(
timestamps: Sequence[float], sizes: Sequence[float]
) -> np.ndarray:
"""Create a trace-like array from the sequence of timestamps and
signed sizes.
"""
assert len(timestamps) == len(sizes)
trace_array = np.recarray((len(timestamps), ), dtype=[
# Use i8 for sizes since we may be doing operations which overflow
("timestamp", "f8"), ("direction", "i1"), ("size", "i8")
])
trace_array["timestamp"] = timestamps
sizes = np.asarray(sizes, dtype=int)
np.sign(sizes, out=trace_array["direction"])
np.abs(sizes, out=trace_array["size"])
return trace_array
def _run_extraction(idx, directory: str, max_size: int):
# Use copies so that the original memory of the full file may be freed
with h5py.File(f"{directory}/data.hdf", mode="r") as h5file:
sizes = | np.asarray(h5file["sizes"][idx], dtype=np.object) | numpy.asarray |
import pytest
import numpy as np
from numpy.testing import assert_equal
import axopy.features as features
@pytest.fixture
def array_2d():
return np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
@pytest.fixture
def array_1d():
return np.array([1, 2, 3, 4, 5])
def test_ensure_2d(array_1d, array_2d):
assert_equal(features.util.ensure_2d(array_2d), array_2d)
assert features.util.ensure_2d(array_1d).ndim == 2
@pytest.mark.parametrize('func', [
features.util.inverted_t_window,
features.util.trapezoidal_window,
])
def test_window_func_length(func):
w = func(10)
assert len(w) == 10
def test_rolling_window_1d(array_1d):
out = np.array([[1, 2], [2, 3], [3, 4], [4, 5]])
assert_equal(features.util.rolling_window(array_1d, 2), out)
def test_rolling_window_2d(array_2d):
out = np.array([[[1, 2], [2, 3], [3, 4]], [[5, 6], [6, 7], [7, 8]]])
assert_equal(features.util.rolling_window(array_2d, 2), out)
def test_inverted_t_window():
# default params (n = 8)
truth = np.array([0.5, 1, 1, 1, 1, 1, 0.5, 0.5])
w = features.util.inverted_t_window(8)
assert_equal(w, truth)
# different amplitude (n = 9)
truth = np.array([0.3, 0.3, 1, 1, 1, 1, 0.3, 0.3, 0.3])
w = features.util.inverted_t_window(9, a=0.3)
assert_equal(w, truth)
# different notch time (n = 100)
truth = np.hstack([9*[0.5], np.ones(100-19), 10*[0.5]])
w = features.util.inverted_t_window(100, p=0.1)
assert_equal(w, truth)
def test_trapezoidal_window():
# default params
truth = np.array([0.5, 1, 1, 1, 1, 1, 0.5, 0])
w = features.util.trapezoidal_window(8)
assert_equal(w, truth)
# non-default ramp time
truth = np.array([1/3., 2/3., 1, 1, 1, 1, 2/3., 1/3., 0])
w = features.util.trapezoidal_window(9, p=1/3.)
assert_equal(w, truth)
@pytest.mark.parametrize('func', [
features.mean_absolute_value,
features.mean_value,
features.waveform_length,
features.wilson_amplitude,
features.zero_crossings,
features.slope_sign_changes,
features.root_mean_square,
features.integrated_emg,
features.var,
features.logvar,
features.skewness,
features.kurtosis,
features.sample_entropy
])
def test_feature_io(func):
"""Make sure feature function gets 1D and 2D IO correct."""
n = 100
c = 3
x_n = np.random.randn(n)
x_cn = np.random.randn(c, n)
x_nc = np.random.randn(n, c)
assert not isinstance(func(x_n), np.ndarray) # scalar
assert func(x_n, keepdims=True).shape == (1,)
assert func(x_cn).shape == (c,)
assert func(x_cn, keepdims=True).shape == (c, 1)
assert func(x_nc, axis=0).shape == (c,)
assert func(x_nc, axis=0, keepdims=True).shape == (1, c)
def test_mav():
x = np.array([[0, 2], [0, -4]])
truth = np.array([1, 2])
assert_equal(features.mean_absolute_value(x), truth)
def test_mav1():
x = np.vstack([np.ones(8), np.zeros(8)])
# weights should be [0.5, 1, 1, 1, 1, 1, 0.5, 0.5]
truth = np.array([0.8125, 0])
assert_equal(features.mean_absolute_value(x, weights='mav1'), truth)
def test_mav2():
x = np.vstack([np.ones(8), np.zeros(8)])
# weights should be [0.5, 1, 1, 1, 1, 1, 0.5, 0]
truth = np.array([0.75, 0])
assert_equal(features.mean_absolute_value(x, weights='mav2'), truth)
def test_mav_custom_weights():
x = np.ones((4, 10))
w = np.zeros(x.shape[1])
w[0:2] = 0.4
truth = (2*0.4/x.shape[1])*np.ones(x.shape[0])
assert_equal(features.mean_absolute_value(x, weights=w), truth)
def test_mav_bad_weights():
# weights not one of the built-in types of MAV
with pytest.raises(ValueError):
features.mean_absolute_value(np.zeros(2), weights='asdf')
def test_mav_bad_custom_weights():
# custom weights not the same length as the input data
x = np.zeros((4, 10))
w = np.zeros(5)
with pytest.raises(ValueError):
features.mean_absolute_value(x, weights=w)
def test_mv():
x = np.array([[0, 2], [0, -4]])
truth = np.array([1, -2])
assert_equal(features.mean_value(x), truth)
def test_wl():
x = np.array([[0, 1, 1, -1], [-1, 2.4, 0, 1]])
truth = np.array([3, 6.8])
assert_equal(features.waveform_length(x), truth)
def test_wamp():
x = np.array([[1., 1.3, 1.4, -0.4], [0.2, 0.8, -0.2, 0.2]])
thresh = 0.5
truth = np.array([1, 2])
assert_equal(features.wilson_amplitude(x, thresh), truth)
def test_zc():
x = np.array([[1, -1, -0.5, 0.2], [1, -1, 1, -1]])
# zero threshold
truth_nothresh = np.array([2, 3])
assert_equal(features.zero_crossings(x), truth_nothresh)
# threshold of 1
truth_thresh = np.array([1, 3])
assert_equal(features.zero_crossings(x, threshold=1), truth_thresh)
def test_ssc():
x = np.array([[1, 2, 1.1, 2, 1.2], [1, -1, -0.5, -1.2, 2]])
# zero threshold
truth_nothresh = np.array([3, 3])
assert_equal(features.slope_sign_changes(x), truth_nothresh)
# threshold of one
truth_thresh = np.array([0, 2])
assert_equal(features.slope_sign_changes(x, threshold=1), truth_thresh)
def test_rms():
x = np.array([[1, -1, 1, -1], [2, 4, 0, 0]])
truth = np.array([1., np.sqrt(5)])
assert_equal(features.root_mean_square(x), truth)
def test_integrated_emg():
x = np.array([[-1., 1., -1.], [0, 0, 0]])
truth = np.array([3.0, 0])
assert_equal(features.integrated_emg(x), truth)
def test_var():
x = np.array([[0, 2], [0, -4]])
truth = np.array([1., 4.])
assert_equal(features.var(x), truth)
def test_logvar():
features.logvar(np.random.randn(100))
features.logvar(np.random.randn(2, 100))
def test_skewness():
features.skewness(np.random.randn(100))
features.skewness(np.random.randn(2, 100))
def test_kurtosis():
features.kurtosis(np.random.randn(100))
features.kurtosis(np.random.randn(2, 100))
def test_ar_io():
n = 10
c = 4
p = 3 # AR order
x_n = np.random.randn(n)
x_cn = np.random.randn(c, n)
x_nc = np.random.randn(n, c)
assert(features.ar(x_n, order=p).shape == (p,))
assert(features.ar(x_n, order=p, axis=0, keepdims=True).shape == (1, p))
assert(features.ar(x_cn, order=p).shape == (p * c,))
assert(features.ar(x_cn, order=p, keepdims=True).shape == (p * c, 1))
assert(features.ar(x_nc, order=p, axis=0).shape == (p * c,))
assert(features.ar(x_nc, order=p, axis=0, keepdims=True).shape == (1, p * c))
def test_hjorth_io():
n = 10
c = 4
x_n = np.random.randn(n)
x_cn = | np.random.randn(c, n) | numpy.random.randn |
# Copyright (c) 2020 Idiap Research Institute, http://www.idiap.ch/
# Written by <NAME> <<EMAIL>>
#
# This file is part of CBI Toolbox.
#
# CBI Toolbox is free software: you can redistribute it and/or modify
# it under the terms of the 3-Clause BSD License.
#
# CBI Toolbox is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# 3-Clause BSD License for more details.
#
# You should have received a copy of the 3-Clause BSD License along
# with CBI Toolbox. If not, see https://opensource.org/licenses/BSD-3-Clause.
#
# SPDX-License-Identifier: BSD-3-Clause
import unittest
import numpy as np
import cbi_toolbox.splineradon as spl
class TestSplradon(unittest.TestCase):
def test_dimension(self):
image_dim = (50, 50, 3)
image_3d = np.random.default_rng().random(image_dim)
image_2d = np.copy(image_3d[..., 0])
spline_3d = spl.radon(image_3d)
spline_2d = spl.radon(image_2d)
np.testing.assert_allclose(
spline_2d, spline_3d[..., 0], rtol=1e-12, atol=1e-12)
out_3d = spl.iradon(image_3d)
out_2d = spl.iradon(image_2d)
np.testing.assert_allclose(
out_2d, out_3d[..., 0], rtol=1e-12, atol=1e-12)
def test_contiguous(self):
image_dim = (50, 50, 3)
image_3d = np.random.default_rng().random(image_dim)
image_3d = np.transpose(image_3d, (1, 0, 2))
image_2d = np.copy(image_3d[..., 0])
spline_3d = spl.radon(image_3d)
spline_2d = spl.radon(image_2d)
np.testing.assert_allclose(
spline_2d, spline_3d[..., 0], rtol=1e-9, atol=1e-12)
out_3d = spl.iradon(spline_3d)
out_2d = spl.iradon(spline_2d)
np.testing.assert_allclose(
out_2d, out_3d[..., 0], rtol=1e-9, atol=1e-12)
def test_padding(self):
theta = np.arange(10)
for size in range(5, 25):
shape = (size, size)
image = np.random.default_rng().random(shape)
for circle in (True, False):
rd = spl.radon(image, theta, circle=circle,
b_spline_deg=(0, 0))
ird = spl.iradon(rd, theta, circle=circle, b_spline_deg=(0, 0))
| np.testing.assert_array_equal(shape, ird.shape) | numpy.testing.assert_array_equal |
#!/usr/local/sci/bin/python
# PYTHON2.7
#
# Author: <NAME>
# Created: 7 April 2016
# Last update: 7 April 2016
# Location: /data/local/hadkw/HADCRUH2/MARINE/EUSTACEMDS/EUSTACE_SST_MAT/
# GitHub: https://github.com/Kate-Willett/HadISDH_Marine_Build/
# -----------------------
# CODE PURPOSE AND OUTPUT
# -----------------------
# This code provides tools to read new_suite files and write new_suite*extended and new_suite*uncertainty files.
# It reads the files into a dictionary where each column can be explored through its 'key'.
#
# -----------------------
# LIST OF MODULES
# -----------------------
# inbuilt:
# import numpy as np
# import copy
# import sys, os
# import pdb # pdb.set_trace() or c
#
# Kates:
#
# -----------------------
# DATA
# -----------------------
# /project/hadobs2/hadisdh/marine/ICOADS.2.5.1/*/new_suite_197312_ERAclimNBC.txt
#
# -----------------------
# HOW TO RUN THE CODE
# -----------------------
# python2.7
# import MDS_RWtools as MDStool
#
# MDSdict=MDStool.ReadMDSstandard('year', 'month', 'type')
# year='1973' # string
# month='01' # string
# type='ERAclimNBC' # which iteration of output?
#
# MDSdict=MDStool.ReadMDSextended('year', 'month', 'type')
# year='1973' # string
# month='01' # string
# type='ERAclimBC' # which iteration of output?
#
# MDSdict=MDStool.ReadMDSuncertainty('year', 'month', 'type')
# year='1973' # string
# month='01' # string
# type='ERAclimBC' # which iteration of output?
#
# Writing is slightly more complex
# Can't really think where this one would be used bu just in case
# MDStool.WriteMDSstandard('year', 'month', 'type',MDSDict)
# year='1973' # string
# month='01' # string
# type='ERAclimNBC' # which iteration of output - should also be the name of the directory the file sits in so the program can figure out the filename and path
# MDSDict = {} # A dictionary created by MakeExtDict()
#
# Writing is slightly more complex
# MDStool.WriteMDSextended('year', 'month', 'type',MDSDict)
# year='1973' # string
# month='01' # string
# type='ERAclimBC' # which iteration of output - should also be the name of the directory the file sits in so the program can figure out the filename and path
# MDSDict = {} # A dictionary created by MakeExtDict()
#
# MDStool.WriteMDSuncertainty('year', 'month', 'type',MDSDict)
# year='1973' # string
# month='01' # string
# type='ERAclimBC' # which iteration of output - should also be the name of the directory the file sits in so the program can figure out the filename and path
# MDSDict = {} # A dictionary created by MakeExtDict()
#
# MDSDict=MDStool.MakeStdDict()
#
# MDSDict=MDStool.MakeExtDict()
#
# MDSDict=MDStool.MakeUncDict()
#
#
#
# For reading this runs the code and stops mid-process so you can then interact with the
# data. You should be able to call this from another program too.
#
# -----------------------
# OUTPUT
# -----------------------
# a dictionary to play with
# -----------------------
# VERSION/RELEASE NOTES
# -----------------------
#
# Version 2 (25 June 2019)
# ---------
#
# Enhancements
#
# Changes
#
# Bug fixes
# For some reason this stopped working now I'm running on RHEL7 even though its stil python2.7
# This appears to be something with reading in the type for each element. SO now I read in everything as strings and later convert
#
#
# Version 1 (7 April 2016)
# ---------
#
# Enhancements
#
# Changes
#
# Bug fixes
#
# -----------------------
# OTHER INFORMATION
# -----------------------
#
#************************************************************************
# START
#************************************************************************
import numpy as np
import sys, os
import copy
import struct
import pdb # pdb.set_trace() or c
# first element is 9 characters lon with a space - so delimiters = 10.
#TheTypesStd=("|S9","|S8","int","int","int","int","int","int",
# "int","int","int","int","int",
# "int","int","int","int","int","int","int","int","int","int","int","int",
# "int","int","int","int","int","|S8",
# "int","int","int","int","int","int","int","int","int","int","int",
# "int","|S3","|S4","|S4","|S3","|S2","|S3","int","int","int","int","int","int",
# "int","int","int","int","int","int","int","int","int",
# "int","int","int","int","int","int","int","int","int",
# "int","int","int","int","int","int","int","int","int",
# "int","int","int","int","int","int","int","int","int",
# "int","int","int","int","int","int","int","int")
TheTypesStd=("str","str","int","int","int","int","int","int",
"int","int","int","int","int",
"int","int","int","int","int","int","int","int","int","int","int","int",
"int","int","int","int","int","str",
"int","int","int","int","int","int","int","int","int","int","int",
"int","str","str","str","str","str","str","int","int","int","int","int","int",
"int","int","int","int","int","int","int","int","int",
"int","int","int","int","int","int","int","int","int",
"int","int","int","int","int","int","int","int","int",
"int","int","int","int","int","int","int","int","int",
"int","int","int","int","int","int","int","int")
TheDelimitersStd=(10,8,8,8,8,8,8,8, # 8 8 ID, Location and time metadata
8,8,8,8,8, # 5 Temperature and pressure OBS values AT, SST and SLP
8,8,8,8,8,8,8,8,8,8,8,8, # 12 Humidity related OBS values DPT, SHU, VAP, CRH, CWB and DPD
8,8,8,8,8,9, # 6 Deck and Platform ID and other platform related metadata
4,3,3,3,8,3,8,3,8,3,8, # 11 OBS related metadata
4,3,4,4,3,2,3,5,5,5,5,5,7, # 13 Instrument related metadata
2,1,1,1,1,1,1,1,1, # 9 BASE QC
2,1,1,1,1,1,1,1,1, # 9 SST QC
2,1,1,1,1,1,1,1,1, # 9 AT QC
2,1,1,1,1,1,1,1,1, # 9 DPT QC
2,1,1,1,1,1,1,1) # 8 Additional QC
# first element is 9 characters lon with a space - so delimiters = 10.
TheTypesExt=("|S9","|S8","int","int","int","int","int","int",
"int","int","int","int",
"int","int","int","int","int","int","int","int","int","int","int","int","int","int",
"int","int","int","int","int","int","int","int","int","int","int","int","int","int",
"int","int","int","int","int","int","int","int","int","int","int","int","int","int",
"int","int","int","int","int","int","int","int","int","int","int","int","int","int",
"int","int","int","int","int","int","int","int","int","int","int","int","int","int",
"int","int","int",
"|S3","|S3","|S3","int","int","int","int","int","int",
"int","int","int","int","int","int","int","int",
"int","int","int","int","int",
"int","int","int","int","int",
"int","int","int","int","int","int")
TheDelimitersExt=(10,8,8,8,8,8,8,8,
8,8,8,8,
8,8,8,8,8,8,8,8,8,8,8,8,8,8,
8,8,8,8,8,8,8,8,8,8,8,8,8,8,
8,8,8,8,8,8,8,8,8,8,8,8,8,8,
8,8,8,8,8,8,8,8,8,8,8,8,8,8,
8,8,8,8,8,8,8,8,8,8,8,8,8,8,
8,8,9,
3,3,3,5,5,5,5,5,5,
2,1,1,1,1,1,1,1,
2,1,1,1,1,
2,1,1,1,1,
2,1,1,1,1,1)
# first element is 9 characters lon with a space - so delimiters = 10.
TheTypesUnc=("|S9","|S8","int","int","int","int","int","int",
"int","int","int","int","int","int","int","int","int","int","int","int","int","int",
"int","int","int","int","int","int","int","int","int","int","int","int","int","int",
"int","int","int","int","int","int","int","int","int","int","int","int","int","int",
"int","int","int","int","int","int","int","int","int","int","int","int","int","int",
"int","int","int","int","int","int","int","int","int","int","int","int","int","int",
"int","int","int","int","int","int","int","int","int","int","int","int","int","int",
"int","int","int","int","int","int","int","int","int","int","int","int","int","int",
"int","int","int","int","int","int","int","int","int","int","int","int","int","int",
"int","int","int",
"|S3","|S3","|S3","int","int","int","int","int","int",
"int","int","int","int","int","int","int","int",
"int","int","int","int","int",
"int","int","int","int","int",
"int","int","int","int","int","int")
TheDelimitersUnc=(10,8,8,8,8,8,8,8,
8,8,8,8,8,8,8,8,8,8,8,8,8,8,
8,8,8,8,8,8,8,8,8,8,8,8,8,8,
8,8,8,8,8,8,8,8,8,8,8,8,8,8,
8,8,8,8,8,8,8,8,8,8,8,8,8,8,
8,8,8,8,8,8,8,8,8,8,8,8,8,8,
8,8,8,8,8,8,8,8,8,8,8,8,8,8,
8,8,8,8,8,8,8,8,8,8,8,8,8,8,
8,8,8,8,8,8,8,8,8,8,8,8,8,8,
8,8,9,
3,3,3,5,5,5,5,5,5,
2,1,1,1,1,1,1,1,
2,1,1,1,1,
2,1,1,1,1,
2,1,1,1,1,1)
#************************************************************************
# ReadMDSstandard
#************************************************************************
def ReadMDSstandard(TheYear,TheMonth,TheType):
# InDir = '/project/hadobs2/hadisdh/marine/ICOADS.2.5.1/'+TheType+'/' # THRESH5_5
InDir = '/project/hadobs2/hadisdh/marine/ICOADS.3.0.0/'+TheType+'/' # THRESH5_5
InFil = 'new_suite_'+TheYear+TheMonth+'_'+TheType+'.txt'
TheFilee = InDir+InFil
print(TheFilee)
# RD - moved the TheTypes and TheDelimiters to outside of definition
# so I can call them from another routine
RawData=ReadData(TheFilee,TheTypesStd,TheDelimitersStd)
MDSDict=dict([])
MDSDict['shipid'] = np.array(RawData[:,0],dtype=TheTypesStd[0])
MDSDict['UID'] = np.array(RawData[:,1],dtype=TheTypesStd[1])
MDSDict['LAT'] = np.array(RawData[:,2],dtype=TheTypesStd[2])/100.
MDSDict['LON'] = np.array(RawData[:,3],dtype=TheTypesStd[3])/100.
MDSDict['YR'] = np.array(RawData[:,4],dtype=TheTypesStd[4])
MDSDict['MO'] = np.array(RawData[:,5],dtype=TheTypesStd[5])
MDSDict['DY'] = np.array(RawData[:,6],dtype=TheTypesStd[6])
MDSDict['HR'] = np.array(RawData[:,7],dtype=TheTypesStd[7])
MDSDict['AT'] =np.array(RawData[:,8],dtype=TheTypesStd[8])/10.
MDSDict['ATA'] =np.array(RawData[:,9],dtype=TheTypesStd[9])/100.
MDSDict['SST'] =np.array(RawData[:,10],dtype=TheTypesStd[10])/10.
MDSDict['SSTA'] =np.array(RawData[:,11],dtype=TheTypesStd[11])/100.
MDSDict['SLP'] =np.array(RawData[:,12],dtype=TheTypesStd[12])/10.
MDSDict['DPT'] =np.array(RawData[:,13],dtype=TheTypesStd[13])/10.
MDSDict['DPTA'] =np.array(RawData[:,14],dtype=TheTypesStd[14])/100.
MDSDict['SHU'] =np.array(RawData[:,15],dtype=TheTypesStd[15])/10.
MDSDict['SHUA'] =np.array(RawData[:,16],dtype=TheTypesStd[16])/100.
MDSDict['VAP'] =np.array(RawData[:,17],dtype=TheTypesStd[17])/10.
MDSDict['VAPA'] =np.array(RawData[:,18],dtype=TheTypesStd[18])/100.
MDSDict['CRH'] =np.array(RawData[:,19],dtype=TheTypesStd[19])/10.
MDSDict['CRHA'] =np.array(RawData[:,20],dtype=TheTypesStd[20])/100.
MDSDict['CWB'] =np.array(RawData[:,21],dtype=TheTypesStd[21])/10.
MDSDict['CWBA'] =np.array(RawData[:,22],dtype=TheTypesStd[22])/100.
MDSDict['DPD'] =np.array(RawData[:,23],dtype=TheTypesStd[23])/10.
MDSDict['DPDA'] =np.array(RawData[:,24],dtype=TheTypesStd[24])/100.
# MDSDict['DSVS']=np.array(RawData['f25'])
MDSDict['DCK'] =np.array(RawData[:,26],dtype=TheTypesStd[26])
MDSDict['SID'] =np.array(RawData[:,27],dtype=TheTypesStd[27])
MDSDict['PT'] =np.array(RawData[:,28],dtype=TheTypesStd[28])
# MDSDict['SI']=np.array(RawData['f29'])
# MDSDict['printsim']=np.array(RawData['f30'])
MDSDict['II'] =np.array(RawData[:,31],dtype=TheTypesStd[31])
MDSDict['IT'] =np.array(RawData[:,32],dtype=TheTypesStd[32])
MDSDict['DPTI'] =np.array(RawData[:,33],dtype=TheTypesStd[33])
MDSDict['WBTI'] =np.array(RawData[:,34],dtype=TheTypesStd[34])
MDSDict['WBT'] =np.array(RawData[:,35],dtype=TheTypesStd[35])/10.
# MDSDict['DI']=np.array(RawData['f36'])
# MDSDict['D']=np.array(RawData['f37'])
MDSDict['WI'] =np.array(RawData[:,38],dtype=TheTypesStd[38])
MDSDict['W'] =np.array(RawData[:,39],dtype=TheTypesStd[39])/10.
# MDSDict['VI']=np.array(RawData['f40'])
# MDSDict['VV']=np.array(RawData['f41'])
# MDSDict['DUPS']=np.array(RawData['f42'])
# MDSDict['COR']=np.array(RawData['f43'])
MDSDict['TOB'] =np.array(RawData[:,44],dtype=TheTypesStd[44])
MDSDict['TOT'] =np.array(RawData[:,45],dtype=TheTypesStd[45])
MDSDict['EOT'] =np.array(RawData[:,46],dtype=TheTypesStd[46])
MDSDict['TOH'] =np.array(RawData[:,47],dtype=TheTypesStd[47])
MDSDict['EOH'] =np.array(RawData[:,48],dtype=TheTypesStd[48])
MDSDict['LOV'] =np.array(RawData[:,49],dtype=TheTypesStd[49])
MDSDict['HOP'] =np.array(RawData[:,50],dtype=TheTypesStd[50])
MDSDict['HOT'] =np.array(RawData[:,51],dtype=TheTypesStd[51])
MDSDict['HOB'] =np.array(RawData[:,52],dtype=TheTypesStd[52])
MDSDict['HOA'] =np.array(RawData[:,53],dtype=TheTypesStd[53])
# MDSDict['SMF']=np.array(RawData['f54'])
MDSDict['day'] =np.array(RawData[:,55],dtype=TheTypesStd[55])
MDSDict['land'] =np.array(RawData[:,56],dtype=TheTypesStd[56])
MDSDict['trk'] =np.array(RawData[:,57],dtype=TheTypesStd[57])
MDSDict['date1'] =np.array(RawData[:,58],dtype=TheTypesStd[58])
MDSDict['date2'] =np.array(RawData[:,59],dtype=TheTypesStd[59])
MDSDict['pos'] =np.array(RawData[:,60],dtype=TheTypesStd[60])
MDSDict['blklst'] =np.array(RawData[:,61],dtype=TheTypesStd[61])
MDSDict['dup'] =np.array(RawData[:,62],dtype=TheTypesStd[62])
# MDSDict['POSblank1']=np.array(RawData['f63'])
MDSDict['SSTbud'] =np.array(RawData[:,64],dtype=TheTypesStd[64])
MDSDict['SSTclim']= | np.array(RawData[:,65],dtype=TheTypesStd[65]) | numpy.array |
# Copyright 2020 Huawei Technologies Co., Ltd
#
# 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 random
from multiprocessing import Process, Queue
import numpy as np
import pytest
from resnet import resnet50
import mindspore.common.dtype as mstype
import mindspore.dataset as ds
import mindspore.dataset.transforms.c_transforms as C
import mindspore.dataset.transforms.vision.c_transforms as vision
import mindspore.nn as nn
import mindspore.ops.functional as F
from mindspore import Tensor
from mindspore import context
from mindspore.communication.management import init
from mindspore.nn.optim.momentum import Momentum
from mindspore.ops import operations as P
from mindspore.parallel._auto_parallel_context import auto_parallel_context
from mindspore.train.callback import Callback
from mindspore.train.model import Model, ParallelMode
random.seed(1)
| np.random.seed(1) | numpy.random.seed |
"""
Created: 2020-07-02
Author: <NAME>
Licence: MIT
Tests for the gap_statistics module.
These tests were extracted from code used in the paper
"Non-invasive profiling of advanced prostate cancer via multi-parametric liquid biopsy and radiomic analysis"
Authors: <NAME>, <NAME>, <NAME>, <NAME>,
<NAME>, <NAME>, <NAME>, <NAME>, <NAME>,
<NAME>, <NAME>, <NAME>, <NAME>, <NAME>,
<NAME>
Molecular Pathology, Diagnostics, and Therapeutics 2022
"""
import numpy as np
import pandas as pd
from sklearn import cluster
import pytest
from typing import List, Tuple, Union
from gap_statistic import gap_statistic
def make_gaussian_test_data(cluster_info: List[Tuple[np.ndarray, np.ndarray, int]]):
data_points = []
for means, stds, num in cluster_info:
data_points.append(np.random.normal(means, stds, size=num))
return np.vstack(data_points)
def test_calculate_cluster_D():
# D is just the sum of all pairwise distances (in both directionss i,j and j,i)
points = np.array([[0, 0, 0], [-2, 0, 4], [0, 0, 5]])
d = gap_statistic.calculate_cluster_D(pd.DataFrame(points))
assert np.isclose(d, 2*(np.sqrt(4+16) + 5 + np.sqrt(4+1)))
points = np.array([[0, 0, 0], [0, 0, 1], [0, 0, 0]])
d = gap_statistic.calculate_cluster_D(pd.DataFrame(points))
assert np.isclose(d, 2*(1 + 0 + 1))
def test_calculate_W():
# W is the sum of all the cluster Ds divided by two * number of points
points = np.array([[0, 0, 0], [-2, 0, 4], [0, 0, 5]])
df = pd.DataFrame(np.vstack((points, points + | np.atleast_2d([0, 0, 100]) | numpy.atleast_2d |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.