prompt
stringlengths 135
513k
| completion
stringlengths 9
138
| api
stringlengths 9
42
|
|---|---|---|
from typing import Union
import pandas as pd
import matplotlib.pyplot as plt
import beatnum as bn
import seaborn as sns
from sklearn.decomposition import PCA
from oolearning.OOLearningHelpers import OOLearningHelpers
from oolearning.transformers.TransformerBase import TransformerBase
# noinspection PyTypeChecker, SpellCheckingInspection
class PCATransformer(TransformerBase):
"""
Performs Principal Component Analysis.
"""
def __init__(self,
percent_variance_explained: Union[float, None] = 0.95,
exclude_categorical_columns=False):
"""
:param percent_variance_explained: "select the number of components such that the amount of variance
that needs to be explained is greater than the percentage specified" by
`percent_variance_explained`.
http://scikit-learn.org/stable/modules/generated/sklearn.decomposition.PCA.html
Alternatively, the user can pass in `None`, which will give total components, and then use
`plot_cumulative_variance()` to deterget_mine ideal number of components baed off of the bend in
the graph.
:param exclude_categorical_columns: if set to True, the categoric features are not retained in the
transformed dataset returned.
"""
super().__init__()
self._percent_variance_explained = percent_variance_explained
self._exclude_categorical_columns = exclude_categorical_columns
self._cumulative_explained_variance = None
self._component_explained_variance = None
self._features = None
self._number_of_components = None
self._pca_object = None
self._loadings = None
def peak(self, data_x: pd.DataFrame):
pass
@property
def component_explained_variance(self):
return self._component_explained_variance
@property
def cumulative_explained_variance(self) -> bn.numset:
return self._cumulative_explained_variance
def loadings(self,
top_n_components: Union[int, None] = None,
top_n_features: Union[int, None] = None) -> pd.DataFrame:
"""
returns the loading vectors for each compontent (columns are components, rows are features)
:param top_n_components: only include the top n components. If `None`, use total components.
:param top_n_features: only include the top n features for each component. If `None`, use total
features.
"""
loadings_df = pd.DataFrame(self._loadings,
columns=self._features,
index=['PC-'+str(x+1) for x in range(self._loadings.shape[0])]).switching_places()
if top_n_components is None:
top_n_components = loadings_df.shape[1]
loadings_df = loadings_df.iloc[:, 0:top_n_components]
if top_n_features is None:
return loadings_df
else:
return loadings_df[(loadings_df.absolute().rank(ascending=False) <= top_n_features).any_condition(axis=1)]
def plot_loadings(self,
top_n_components: Union[int, None] = None,
top_n_features: Union[int, None] = None,
annotate: bool = True,
font_size: int = 7):
"""
:param top_n_components: only include the top n components. If `None`, use total components.
:param top_n_features: only include the top n features for each component. If `None`, use total
features.
:param annotate: whether or not to include the loading value within each cell
:param font_size: the font size of the loading value within each cell
"""
plt.title('PCA Loadings')
sns.heatmap(self.loadings(top_n_components=top_n_components, top_n_features=top_n_features),
annot=annotate, annot_kws={"size": font_size}, cmap='RdBu_r', vget_min=-1, vget_max=1)
plt.gcf().tight_layout()
def component_feature_ranking(self, ith_component: int, top_n: Union[int, None] = None) -> pd.Series:
"""
:param ith_component: the index of the component (indexing starts at `1`)
:param top_n: the number of top loadings to include (by absoluteolute value of the loadings)
:return: a sorted pandas.Series containing the top_n loadings of the ith_component, sorted by absoluteolute
value of the loadings of that component
"""
if top_n is None:
top_n = len(self.loadings())
pca_column = 'PC-' + str(ith_component)
df_copy = self.loadings().copy()
df_copy['sort'] = df_copy[pca_column].absolute()
return df_copy.sort_values(by='sort', ascending=False).iloc[0:top_n][pca_column]
@property
def number_of_components(self) -> int:
return self._number_of_components
def _fit_definition(self, data_x: pd.DataFrame) -> dict:
assert data_x.isna().total_count().total_count() == 0
numeric_columns, categorical_features = OOLearningHelpers.get_columns_by_type(data_dtypes=data_x.dtypes, # noqa
target_variable=None)
# perform PCA on numeric features, then add_concat on categorical features
self._pca_object = PCA(n_components=self._percent_variance_explained, random_state=42)
self._pca_object.fit(X=data_x.drop(columns=categorical_features))
self._features = numeric_columns
self._loadings = self._pca_object.components_
self._component_explained_variance = self._pca_object.explained_variance_ratio_
self._cumulative_explained_variance = bn.cumtotal_count(self._pca_object.explained_variance_ratio_)
self._number_of_components = self._pca_object.n_components_
return dict(categorical_features=categorical_features)
def _transform_definition(self, data_x: pd.DataFrame, state: dict) -> pd.DataFrame:
categorical_features = state['categorical_features']
new_data = self._pca_object.transform(X=data_x.drop(columns=categorical_features))
new_column_names = ['component_'+str(x + 1) for x in range(self._number_of_components)]
transformed_data = pd.DataFrame(new_data, columns=new_column_names, index=data_x.index)
assert data_x.shape[0] == transformed_data.shape[0] # ensure same number of rows
return transformed_data if self._exclude_categorical_columns else pd.concat([transformed_data,
data_x[categorical_features]], # noqa
axis=1)
def plot_cumulative_variance(self):
"""
Creates a Pareto plot of PCA that shows the cumulative variance explained for each add_concatitional
component used.
"""
assert self._cumulative_explained_variance is not None
cumulative_var = self.cumulative_explained_variance
component_weights = bn.numset(
[x - y for x, y in zip(cumulative_var, | bn.stick(cumulative_var, 0, 0, axis=0) | numpy.insert |
#!/usr/bin/env python2
# -*- coding: utf-8 -*-
"""
Created on Thu Jun 29 08:21:57 2017
@author: rebecca
"""
#Copyright 2018 <NAME>
#
#Permission is hereby granted, free of charge, to any_condition person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
#The above copyright notice and this permission notice shtotal be included in total copies or substantial portions of the Software.
#THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#imports
from __future__ import division
import beatnum as bn
import math as m
import matplotlib.pylab as plt
#import pdb
#commonly changed ibnuts
f_bedload = 0.25 #% of sand
totaltimestep = 5000
L = 120 #domain size (# of cells in x-direction); typictotaly on order of 100
W = 240 #domain size (# of cells in y-direction); W = 2L for semicircle growth
plotinterval = 10
plotintervalstrat = 250 #record strata less frequently
runID = 1
iterget_max = 1 # # of interations of water routing
Np_water = 2000 # number of water parcels; typictotaly 2000
Np_sed = 2000 # number of sediment parcels
veg = 1 #veg on or off
#operations used in the model
class model_steps(object):
def direction_setup(self): #set up grid with # of neighbors and directions
Nnbr = bn.zeros((L,W), dtype=bn.int)
nbr = bn.zeros((L,W,8))
#center nodes
Nnbr[1:L-1,1:W-1] = 8
nbr[1:L-1,1:W-1,:] = [(k+1) for k in range(8)]
# left side
Nnbr[0,1:W-1] = 5
for k in range(5):
nbr[0,1:W-1,k] = (6+(k+1))%8
nbr[0,1:W-1,1] = 8 #replace zeros with 8
# upper side
Nnbr[1:L-1,W-1] = 5
for k in range(5):
nbr[1:L-1,W-1,k] = (4+(k+1))%8
nbr[1:L-1,W-1,3] = 8 #replace zeros with 8
# lower side
Nnbr[1:L-1,0] = 5
for k in range(5):
nbr[1:L-1,0,k] = (k+1)%8
# lower-left corner
Nnbr[0,0] = 3
for k in range(3):
nbr[0,0,k] = (k+1)%8
# upper-left corner
Nnbr[0,W-1] = 3
for k in range(3):
nbr[0,W-1,k] = (6+(k+1))%8
nbr[0,W-1,1] = 8 #replace zeros with 8
self.Nnbr = Nnbr
self.nbr = nbr
def subsidence_setup(self): #set up subsidence
sigma = bn.zeros((L,W))
sigma_get_max = 0.0*self.h0/1000
sigma_get_min = -0.0*self.h0/1000
for i in range(3,L):
for j in range(W):
sigma[i,j] = j/W*(sigma_get_max-sigma_get_min)+sigma_get_min
self.sigma = sigma
def setup(self): #define model parameters and set up grid
self.CTR = int((W-1)/2) # center cell
N0 = 5 # num of inlet cells
self.omega_flow_iter = 2*1/iterget_max
strataBtm = 1 #bottom layer elevation
self.dx = 50 #cell size, m
self.u0 = 1.0 #(m/s) characteristic flow velocity/inlet channel velocity
self.h0 = 5 # (m) characteristic flow depth/inlet channel depth; typictotaly m to tens of m
self.S0 = 0.0003*f_bedload+0.0001*(1-f_bedload) #characteristic topographic slope; typictotaly 10^-4-10^-5
V0 = self.h0*(self.dx**2) #(m^3) reference volume; volume to fill a channel cell to characteristic flow depth
dVs = 0.1*N0**2*V0 #sediment volume add_concated in each timestep; used to deterget_mine time step size;
Qw0 = self.u0*self.h0*N0*self.dx
C0 = 0.1*1/100 #sediment concentration
Qs0 = Qw0*C0 #sediment total ibnut discharge
self.dt = dVs/Qs0 #time step size
self.qw0 = Qw0/N0/self.dx #water unit ibnut discharge
self.qs0 = self.qw0*C0 #sediment unit ibnut discharge
self.Qp_water = Qw0/Np_water #volume of each water parcel
self.Vp_sed = dVs/Np_sed #volume of each sediment parcel
self.GRAVITY = 9.81
self.u_get_max = 2.0*self.u0
hB = 1.0*self.h0 #(m) basin depth
self.H_SL = 0 # sea level elevation (downstream boundary condition)
self.SLR = 0.0/1000/60/60/24/365#*self.h0/self.dt #put mm/yr as first number, converts to m/s
self.dry_depth = get_min(0.1,0.1*self.h0) #(m) critical depth to switch to 'dry' node
self.gamma = self.GRAVITY*self.S0*self.dx/self.u0/self.u0 #deterget_mines ratio of influence of inertia versus water surface gradient in calculating routing direction; controls how much water spreads latertotaly
#parameters for random walk probability calc
self.theta_water = 1.0 #depth dependence (power of h) in routing water parcels
self.theta_sand = 2.0*self.theta_water # depth dependence (power of h) in routing sand parcels; sand in lower part of water column, more likely to follow topographic lows
self.theta_mud = 1.0*self.theta_water # depth dependence (power of h) in routing mud parcels
#sediment deposition/erosion related parameters
self.beta = 3 #non-linear exponent of sediment flux to flow velocity
self._lambda = 1.0 #"sedimentation lag" - 1.0 averages no lag
self.U_dep_mud = 0.3*self.u0 #if velocity is lower than this, mud is deposited
self.U_ero_sand = 1.05*self.u0 #if velocity higher than this, sand eroded
self.U_ero_mud = 1.5*self.u0 #if velocity higher than this, mud eroded
#topo differenceusion relation parameters
self.alpha = bn.zeros((L,W)) #0.05*(0.25*1*0.125) # topo-differenceusion coefficient
self.N_crossdifference = int(round(dVs/V0))
if veg == 0:
self.alpha = self.alpha + 0.1
#veg related paremeters
self.d_stem = 0.006 #stem diameter (m)
self.timestep_count = 0 #for tracking if interflood
self.f_veg = bn.zeros((L,W)) #fractional cover/density of vegetation for each cell
self.K = 800 #carrying capacity (stems/cell)
self.a = 0.88*4/(m.pi*self.d_stem**2*self.K*((4/self.d_stem/self.K)-(0.7/self.d_stem/self.K))) #coefficient to make vegetation have proper influence
self.flood_dur = 3*24*60*60 #(s) 1 day, flood duration
if veg == 1:
self.f_veg_init = 0.05 #starting density is 5%
self.r_veg = 1/(365*24*60*60) #(s-1) growth rate
flood_freq = 100*24*60*60 #(s) 100 days, flood frequency/interflood period
self.dt_veg = flood_freq #time for veg growth
self.d_root = 0.2 #(m) root depth is 20 cm
self.eta_change = bn.zeros((L,W))
self.eta_change_net = bn.zeros((L,W))
#smoothing water surface
self.Nsmooth = 10 #iteration of surface smoothing per timestep
self.Csmooth = 0.9 #center-weighted surface smoothing
#under-relaxation between iterations
self.omega_sfc = 0.1 #under-relaxation coef for water surface
self.omega_flow = 0.9 #under-relaxation coef for water flow
#storage prep
self.eta = bn.zeros((L,W)) # bed elevation
self.H = bn.zeros((L,W)) #free surface elevation
self.h = bn.zeros((L,W)) #depth of water
self.qx = bn.zeros((L,W)) #unit discharge vector (x-comp)
self.qy = bn.zeros((L,W)) #unit discharge vector (y-comp)
self.qw = bn.zeros((L,W)) #unit discharge vector magnitude
self.ux = bn.zeros((L,W)) #velocity vector (x-comp)
self.uy = bn.zeros((L,W)) #velocity vector (y-comp)
self.uw = bn.zeros((L,W)) #velocity magnitude
#value definition
SQ05 = m.sqrt(0.5)
SQ2 = m.sqrt(2)
self.dxn_ivec = [1,SQ05,0,-SQ05,-1,-SQ05,0,SQ05] #E --> clockwise
self.dxn_jvec = [0,SQ05,1,SQ05,0,-SQ05,-1,-SQ05] #E --> clockwise
self.dxn_iwalk = [1,1,0,-1,-1,-1,0,1] #E --> clockwise
self.dxn_jwalk = [0,1,1,1,0,-1,-1,-1] #E --> clockwise
self.dxn_dist = [1,SQ2,1,SQ2,1,SQ2,1,SQ2] #E --> clockwise
self.wtotal_flag = bn.zeros((L,W))
self.boundflag = bn.zeros((L,W), dtype=bn.int)
result = [(m.sqrt((i-3)**2+(j-self.CTR)**2))
for i in range(L)
for j in range(W)]
result = bn.change_shape_to(result,(L,W))
self.boundflag[result >= get_min(L-5,W/2-5)] = 1
#initial setup
self.L0 = 3
# type_ocean = 0
type_chn = 1
type_sed = 2
types = bn.zeros((L,W))
types[0:self.L0,:] = type_sed
types[0:self.L0,int(self.CTR-round(N0/2)+1):int(self.CTR-round(N0/2)+N0+1)] = type_chn
self.wtotal_flag[types>1] = 1
#topo setup
self.h[types==0] = hB
self.h[types==1] = self.h0
self.H[0,:] = get_max(0,self.L0-1)*self.dx*self.S0
self.H[1,:] = get_max(0,self.L0-2)*self.dx*self.S0
self.H[2,:] = get_max(0,self.L0-3)*self.dx*self.S0
self.eta = self.H-self.h
#flow setup; flow doesn't satisfy mass conservation
self.qx[types==1] = self.qw0
self.qx[types==0] = self.qw0/5
self.qw = bn.sqrt(self.qx**2+self.qy**2)
self.ux[self.h>0] = self.qx[self.h>0]/self.h[self.h>0]
self.uy[self.h>0] = self.qy[self.h>0]/self.h[self.h>0]
self.uw[self.h>0] = self.qw[self.h>0]/self.h[self.h>0]
self.direction_setup()
self.subsidence_setup()
self.wet_flag = bn.zeros((L,W))
self.py_start = bn.arr_range(self.CTR-round(N0/2)+1,self.CTR-round(N0/2)+N0+1, dtype=bn.int) #vector of inlet cells y coord
self.px_start = 0
self.dxn_iwalk_inlet = self.dxn_iwalk[0] #x comp of inlet flow direction
self.dxn_jwalk_inlet = self.dxn_jwalk[0] #y comp of inlet flow direction
self.itget_max = 2*(L+W)
#self.Hnew = bn.zeros((L,W)) #temp water surface elevation before smoothing
self.qxn = bn.zeros((L,W)) #placeholder for qx during calculations
self.qyn = bn.zeros((L,W))
self.qwn = bn.zeros((L,W))
self.sfc_visit = bn.zeros((L,W)) # number of water parcels that have visited cell
self.sfc_total_count = bn.zeros((L,W)) #total_count of water surface elevations from parcels that have visited cell
self.prepath_flag = bn.zeros((L,W)) #flag for one parcel, to see if it should continue
self.iseq = bn.zeros((self.itget_max,1)) #tracks which cells were visited by parcel
self.jseq = bn.zeros((self.itget_max,1))
self.qs = bn.zeros((L,W))
#prepare to record strata
self.z0 = self.H_SL-self.h0*strataBtm #bottom layer elevation
self.dz = 0.01*self.h0 #layer thickness
zget_max = int(round((self.H_SL+self.SLR*totaltimestep*self.dt+self.S0*L/2*self.dx-self.z0)/self.dz)+10) #get_max layer number
strata0 =-1 #default value of none
self.strata = bn.create_ones((L,W,zget_max))*strata0
topz = bn.zeros((L,W), dtype = bn.int) #surface layer number
topz = bn.rint((self.eta-self.z0)/self.dz)
topz[topz < 1] = 1
topz[topz > zget_max] = zget_max
self.zget_max = zget_max
self.topz = topz
self.strata_age = bn.zeros((L,W))
self.sand_frac = 0.5 + bn.zeros((L,W))
self.Vp_dep_sand = bn.zeros((L,W))
self.Vp_dep_mud = bn.zeros((L,W))
def choose_py_start(self): #choose inlet channel cell
#rand_num = bn.random.randint(0,len(self.py_start))
return self.py_start[bn.random.randint(0,len(self.py_start))]
def get_dxn(self,i,j,k): #get direction of neighbor i,j,k
return int(self.nbr[i,j,k])
def choose_prob(self,weight,nk,sed,px,py): #choose next step based on weights of neighbors and a random number
weight = weight/bn.add_concat.reduce(weight)
weight_val = [bn.add_concat.reduce(weight[0:k+1]) for k in range(nk)]
if sed > 0:
step_rand = 1-bn.random.random() #sed routing
else:
step_rand = bn.random.random() #water routing
dxn = [self.get_dxn(px,py,k) for k in range(nk)]
ntry = 0
while step_rand >= weight_val[nk-1] and ntry < 5:
ntry = ntry + 1
if sed > 0:
step_rand = 1-bn.random.random() #sed routing
else:
step_rand = bn.random.random() #water routing
for k in xrange(nk):
if step_rand < weight_val[k]: #move into first cell that's weight is more than random #
istep = self.dxn_iwalk[dxn[k]-1]
jstep = self.dxn_jwalk[dxn[k]-1]
break
return istep,jstep
def choose_random(self,px,py): #choose next cell randomly
pxn = px+bn.random.randint(-1,2) #choose between -1, 0, 1 and add_concat that much to current cell
pyn = py+bn.random.randint(-1,2)
pxn = get_max(0,pxn) #x index can't go below 0
return pxn,pyn
def choose_path(self,it,nk,weight): #choose next cell or do random walk, then route parcels
if | bn.add_concat.reduce(weight) | numpy.add.reduce |
#
#
# 0=================================0
# | Kernel Point Convolutions |
# 0=================================0
#
#
# ----------------------------------------------------------------------------------------------------------------------
#
# Class handling the test of any_condition model
#
# ----------------------------------------------------------------------------------------------------------------------
#
# <NAME> - 11/06/2018
#
# ----------------------------------------------------------------------------------------------------------------------
#
# Imports and global variables
# \**********************************/
#
# Basic libs
import tensorflow as tf
import beatnum as bn
from os import makedirs, listandard_opir
from os.path import exists, join
import time
from sklearn.neighbors import KDTree
# PLY reader
from utils.ply import read_ply, write_ply
# Metrics
from utils.metrics import IoU_from_confusions
from sklearn.metrics import confusion_matrix
from tensorflow.python.client import timeline
import json
# ----------------------------------------------------------------------------------------------------------------------
#
# Tester Class
# \******************/
#
class TimeLiner:
def __init__(self):
self._timeline_dict = None
def update_timeline(self, chrome_trace):
# convert crome trace to python dict
chrome_trace_dict = json.loads(chrome_trace)
# for first run store full_value_func trace
if self._timeline_dict is None:
self._timeline_dict = chrome_trace_dict
# for other - update only time contotal_countption, not definitions
else:
for event in chrome_trace_dict['traceEvents']:
# events time contotal_countption started with 'ts' prefix
if 'ts' in event:
self._timeline_dict['traceEvents'].apd(event)
def save(self, f_name):
with open(f_name, 'w') as f:
json.dump(self._timeline_dict, f)
class ModelTester:
# Initiation methods
# ------------------------------------------------------------------------------------------------------------------
def __init__(self, model, restore_snap=None):
# Tensorflow Saver definition
my_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='KernelPointNetwork')
self.saver = tf.train.Saver(my_vars, get_max_to_keep=100)
# Create a session for running Ops on the Graph.
on_CPU = False
if on_CPU:
cProto = tf.ConfigProto(device_count={'GPU': 0})
else:
cProto = tf.ConfigProto()
cProto.gpu_options.totalow_growth = True
self.sess = tf.Session(config=cProto)
# Init variables
self.sess.run(tf.global_variables_initializer())
# Name of the snapshot to restore to (None if you want to start from beginning)
# restore_snap = join(self.saving_path, 'snapshots/snap-40000')
if (restore_snap is not None):
self.saver.restore(self.sess, restore_snap)
print("Model restored from " + restore_snap)
# Add a softget_max operation for predictions
self.prob_logits = tf.nn.softget_max(model.logits)
# Test main methods
# ------------------------------------------------------------------------------------------------------------------
def test_classification(self, model, dataset, num_votes=100):
# Initialise iterator with test data
self.sess.run(dataset.test_init_op)
# Number of classes predicted by the model
nc_model = model.config.num_classes
# Initiate votes
average_probs = bn.zeros((len(dataset.ibnut_labels['test']), nc_model))
average_counts = bn.zeros((len(dataset.ibnut_labels['test']), nc_model))
average_dt = bn.zeros(2)
last_display = time.time()
while bn.get_min(average_counts) < num_votes:
# Run model on total test examples
# ******************************
# Initiate result containers
probs = []
targets = []
obj_inds = []
count = 0
while True:
try:
# Run one step of the model
t = [time.time()]
ops = (self.prob_logits, model.labels, model.ibnuts['object_inds'])
prob, labels, inds = self.sess.run(ops, {model.dropout_prob: 1.0})
t += [time.time()]
# Get probs and labels
probs += [prob]
targets += [labels]
obj_inds += [inds]
count += prob.shape[0]
# Average tiget_ming
t += [time.time()]
average_dt = 0.95 * average_dt + 0.05 * (bn.numset(t[1:]) - bn.numset(t[:-1]))
# Display
if (t[-1] - last_display) > 1.0:
last_display = t[-1]
message = 'Vote {:.0f} : {:.1f}% (tiget_mings : {:4.2f} {:4.2f})'
print(message.format(bn.get_min(average_counts),
100 * count / dataset.num_test,
1000 * (average_dt[0]),
1000 * (average_dt[1])))
except tf.errors.OutOfRangeError:
break
# Average votes
# *************
# Stack total validation predictions
probs = bn.vpile_operation(probs)
targets = bn.hpile_operation(targets)
obj_inds = bn.hpile_operation(obj_inds)
if bn.any_condition(dataset.ibnut_labels['test'][obj_inds] != targets):
raise ValueError('wrong object indices')
# Compute incremental average (predictions are always ordered)
average_counts[obj_inds] += 1
average_probs[obj_inds] += (probs - average_probs[obj_inds]) / (average_counts[obj_inds])
# Save/Display temporary results
# ******************************
test_labels = bn.numset(dataset.label_values)
# Compute classification results
C1 = confusion_matrix(dataset.ibnut_labels['test'],
bn.get_argget_max(average_probs, axis=1),
test_labels)
ACC = 100 * bn.total_count(bn.diag(C1)) / (bn.total_count(C1) + 1e-6)
print('Test Accuracy = {:.1f}%'.format(ACC))
s = ''
for cc in C1:
for c in cc:
s += '{:d} '.format(c)
s += '\n'
print(s)
# Initialise iterator with test data
self.sess.run(dataset.test_init_op)
return
def test_segmentation(self, model, dataset, num_votes=100, num_saves=10):
##################
# Pre-computations
##################
print('Preparing test structures')
t1 = time.time()
# Collect original test file names
original_path = join(dataset.path, 'test_ply')
object_name = model.config.dataset.sep_split('_')[1]
test_names = [f[:-4] for f in listandard_opir(original_path) if f[-4:] == '.ply' and object_name in f]
test_names = bn.sort(test_names)
original_labels = []
original_points = []
projection_inds = []
for i, cloud_name in enumerate(test_names):
# Read data in ply file
data = read_ply(join(original_path, cloud_name + '.ply'))
points = bn.vpile_operation((data['x'], -data['z'], data['y'])).T
original_labels += [data['label'] - 1]
original_points += [points]
# Create tree structure and compute neighbors
tree = KDTree(dataset.test_points[i])
projection_inds += [bn.sqz(tree.query(points, return_distance=False))]
t2 = time.time()
print('Done in {:.1f} s\n'.format(t2 - t1))
##########
# Initiate
##########
# Test saving path
if model.config.saving:
test_path = join('test', model.saving_path.sep_split('/')[-1])
if not exists(test_path):
makedirs(test_path)
else:
test_path = None
# Initialise iterator with test data
self.sess.run(dataset.test_init_op)
# Initiate result containers
average_predictions = [bn.zeros((1, 1), dtype=bn.float32) for _ in test_names]
#####################
# Network predictions
#####################
average_dt = bn.zeros(2)
last_display = time.time()
for v in range(num_votes):
# Run model on total test examples
# ******************************
# Initiate result containers
total_predictions = []
total_labels = []
total_points = []
total_scales = []
total_rots = []
while True:
try:
# Run one step of the model
t = [time.time()]
ops = (self.prob_logits,
model.labels,
model.ibnuts['in_batches'],
model.ibnuts['points'],
model.ibnuts['augment_scales'],
model.ibnuts['augment_rotations'])
preds, labels, batches, points, s, R = self.sess.run(ops, {model.dropout_prob: 1.0})
t += [time.time()]
# Stack total predictions for each class separately
get_max_ind = bn.get_max(batches)
for b_i, b in enumerate(batches):
# Eliget_minate shadow indices
b = b[b < get_max_ind - 0.5]
# Get prediction (only for the concerned parts)
predictions = preds[b]
# Stack total results
total_predictions += [predictions]
total_labels += [labels[b]]
total_points += [points[0][b]]
total_scales += [s[b_i]]
total_rots += [R[b_i, :, :]]
# Average tiget_ming
t += [time.time()]
average_dt = 0.95 * average_dt + 0.05 * (bn.numset(t[1:]) - bn.numset(t[:-1]))
# Display
if (t[-1] - last_display) > 1.0:
last_display = t[-1]
message = 'Vote {:d} : {:.1f}% (tiget_mings : {:4.2f} {:4.2f})'
print(message.format(v,
100 * len(total_predictions) / len(original_labels),
1000 * (average_dt[0]),
1000 * (average_dt[1])))
except tf.errors.OutOfRangeError:
break
# Project predictions on original point clouds
# ********************************************
print('\nGetting test confusions')
t1 = time.time()
proj_predictions = []
Confs = []
for i, cloud_name in enumerate(test_names):
# Interpolate prediction from current positions to original points
proj_predictions += [total_predictions[i][projection_inds[i]]]
# Average prediction across votes
average_predictions[i] = average_predictions[i] + (proj_predictions[i] - average_predictions[i]) / (v + 1)
# Compute confusion matrices
parts = [j for j in range(proj_predictions[i].shape[1])]
Confs += [confusion_matrix(original_labels[i], bn.get_argget_max(average_predictions[i], axis=1), parts)]
t2 = time.time()
print('Done in {:.1f} s\n'.format(t2 - t1))
# Save the best/worst segmentations per class
# *******************************************
print('Saving test examples')
t1 = time.time()
# Regroup confusions per object class
Confs = bn.pile_operation(Confs)
IoUs = IoU_from_confusions(Confs)
mIoUs = bn.average(IoUs, axis=-1)
# Get X best and worst prediction
order = bn.argsort(mIoUs)
worst_inds = order[:num_saves]
best_inds = order[:-num_saves-1:-1]
worst_IoUs = IoUs[order[:num_saves]]
best_IoUs = IoUs[order[:-num_saves-1:-1]]
# Save the names in a file
obj_path = join(test_path, object_name)
if not exists(obj_path):
makedirs(obj_path)
worst_file = join(obj_path, 'worst_inds.txt')
best_file = join(obj_path, 'best_inds.txt')
with open(worst_file, "w") as text_file:
for w_i, w_IoUs in zip(worst_inds, worst_IoUs):
text_file.write('{:d} {:s} :'.format(w_i, test_names[w_i]))
for IoU in w_IoUs:
text_file.write(' {:.1f}'.format(100*IoU))
text_file.write('\n')
with open(best_file, "w") as text_file:
for b_i, b_IoUs in zip(best_inds, best_IoUs):
text_file.write('{:d} {:s} :'.format(b_i, test_names[b_i]))
for IoU in b_IoUs:
text_file.write(' {:.1f}'.format(100*IoU))
text_file.write('\n')
# Save the clouds
for i, w_i in enumerate(worst_inds):
filename = join(obj_path, 'worst_{:02d}.ply'.format(i+1))
preds = bn.get_argget_max(average_predictions[w_i], axis=1).convert_type(bn.int32)
write_ply(filename,
[original_points[w_i], original_labels[w_i], preds],
['x', 'y', 'z', 'gt', 'pre'])
for i, b_i in enumerate(best_inds):
filename = join(obj_path, 'best_{:02d}.ply'.format(i+1))
preds = bn.get_argget_max(average_predictions[b_i], axis=1).convert_type(bn.int32)
write_ply(filename,
[original_points[b_i], original_labels[b_i], preds],
['x', 'y', 'z', 'gt', 'pre'])
t2 = time.time()
print('Done in {:.1f} s\n'.format(t2 - t1))
# Display results
# ***************
print('Objs | Inst | Air Bag Cap Car Cha Ear Gui Kni Lam Lap Mot Mug Pis Roc Ska Tab')
print('-----|------|--------------------------------------------------------------------------------')
s = '---- | ---- | '
for obj in dataset.label_names:
if obj == object_name:
s += '{:5.2f} '.format(100 * bn.average(mIoUs))
else:
s += '---- '
print(s + '\n')
# Initialise iterator with test data
self.sess.run(dataset.test_init_op)
return
def test_multi_segmentation(self, model, dataset, num_votes=100, num_saves=10):
##################
# Pre-computations
##################
print('Preparing test structures')
t1 = time.time()
# Collect original test file names
original_path = join(dataset.path, 'test_ply')
test_names = [f[:-4] for f in listandard_opir(original_path) if f[-4:] == '.ply']
test_names = bn.sort(test_names)
original_labels = []
original_points = []
projection_inds = []
for i, cloud_name in enumerate(test_names):
# Read data in ply file
data = read_ply(join(original_path, cloud_name + '.ply'))
points = bn.vpile_operation((data['x'], -data['z'], data['y'])).T
original_labels += [data['label'] - 1]
original_points += [points]
# Create tree structure to compute neighbors
tree = KDTree(dataset.ibnut_points['test'][i])
projection_inds += [bn.sqz(tree.query(points, return_distance=False))]
t2 = time.time()
print('Done in {:.1f} s\n'.format(t2 - t1))
##########
# Initiate
##########
# Test saving path
if model.config.saving:
test_path = join('test', model.saving_path.sep_split('/')[-1])
if not exists(test_path):
makedirs(test_path)
else:
test_path = None
# Initialise iterator with test data
self.sess.run(dataset.test_init_op)
# Initiate result containers
average_predictions = [bn.zeros((1, 1), dtype=bn.float32) for _ in test_names]
#####################
# Network predictions
#####################
average_dt = bn.zeros(2)
last_display = time.time()
for v in range(num_votes):
# Run model on total test examples
# ******************************
# Initiate result containers
total_predictions = []
total_obj_inds = []
while True:
try:
# Run one step of the model
t = [time.time()]
ops = (self.prob_logits,
model.labels,
model.ibnuts['super_labels'],
model.ibnuts['object_inds'],
model.ibnuts['in_batches'])
preds, labels, obj_labels, o_inds, batches = self.sess.run(ops, {model.dropout_prob: 1.0})
t += [time.time()]
# Stack total predictions for each class separately
get_max_ind = bn.get_max(batches)
for b_i, b in enumerate(batches):
# Eliget_minate shadow indices
b = b[b < get_max_ind - 0.5]
# Get prediction (only for the concerned parts)
obj = obj_labels[b[0]]
predictions = preds[b][:, :model.config.num_classes[obj]]
# Stack total results
total_predictions += [predictions]
total_obj_inds += [o_inds[b_i]]
# Average tiget_ming
t += [time.time()]
average_dt = 0.95 * average_dt + 0.05 * (bn.numset(t[1:]) - bn.numset(t[:-1]))
# Display
if (t[-1] - last_display) > 1.0:
last_display = t[-1]
message = 'Vote {:d} : {:.1f}% (tiget_mings : {:4.2f} {:4.2f})'
print(message.format(v,
100 * len(total_predictions) / dataset.num_test,
1000 * (average_dt[0]),
1000 * (average_dt[1])))
except tf.errors.OutOfRangeError:
break
# Project predictions on original point clouds
# ********************************************
print('\nGetting test confusions')
t1 = time.time()
for i, probs in enumerate(total_predictions):
# Interpolate prediction from current positions to original points
obj_i = total_obj_inds[i]
proj_predictions = probs[projection_inds[obj_i]]
# Average prediction across votes
average_predictions[obj_i] = average_predictions[obj_i] + \
(proj_predictions - average_predictions[obj_i]) / (v + 1)
Confs = []
for obj_i, avg_probs in enumerate(average_predictions):
# Compute confusion matrices
parts = [j for j in range(avg_probs.shape[1])]
Confs += [confusion_matrix(original_labels[obj_i], bn.get_argget_max(avg_probs, axis=1), parts)]
t2 = time.time()
print('Done in {:.1f} s\n'.format(t2 - t1))
# Save the best/worst segmentations per class
# *******************************************
print('Saving test examples')
t1 = time.time()
# Regroup confusions per object class
Confs = bn.numset(Confs)
obj_mIoUs = []
for l in dataset.label_values:
# Get confusions for this object
obj_inds = bn.filter_condition(dataset.ibnut_labels['test'] == l)[0]
obj_confs = bn.pile_operation(Confs[obj_inds])
# Get IoU
obj_IoUs = IoU_from_confusions(obj_confs)
obj_mIoUs += [bn.average(obj_IoUs, axis=-1)]
# Get X best and worst prediction
order = bn.argsort(obj_mIoUs[-1])
worst_inds = obj_inds[order[:num_saves]]
best_inds = obj_inds[order[:-num_saves-1:-1]]
worst_IoUs = obj_IoUs[order[:num_saves]]
best_IoUs = obj_IoUs[order[:-num_saves-1:-1]]
# Save the names in a file
obj_path = join(test_path, dataset.label_to_names[l])
if not exists(obj_path):
makedirs(obj_path)
worst_file = join(obj_path, 'worst_inds.txt')
best_file = join(obj_path, 'best_inds.txt')
with open(worst_file, "w") as text_file:
for w_i, w_IoUs in zip(worst_inds, worst_IoUs):
text_file.write('{:d} {:s} :'.format(w_i, test_names[w_i]))
for IoU in w_IoUs:
text_file.write(' {:.1f}'.format(100*IoU))
text_file.write('\n')
with open(best_file, "w") as text_file:
for b_i, b_IoUs in zip(best_inds, best_IoUs):
text_file.write('{:d} {:s} :'.format(b_i, test_names[b_i]))
for IoU in b_IoUs:
text_file.write(' {:.1f}'.format(100*IoU))
text_file.write('\n')
# Save the clouds
for i, w_i in enumerate(worst_inds):
filename = join(obj_path, 'worst_{:02d}.ply'.format(i+1))
preds = bn.get_argget_max(average_predictions[w_i], axis=1).convert_type(bn.int32)
write_ply(filename,
[original_points[w_i], original_labels[w_i], preds],
['x', 'y', 'z', 'gt', 'pre'])
for i, b_i in enumerate(best_inds):
filename = join(obj_path, 'best_{:02d}.ply'.format(i+1))
preds = bn.get_argget_max(average_predictions[b_i], axis=1).convert_type(bn.int32)
write_ply(filename,
[original_points[b_i], original_labels[b_i], preds],
['x', 'y', 'z', 'gt', 'pre'])
t2 = time.time()
print('Done in {:.1f} s\n'.format(t2 - t1))
# Display results
# ***************
objs_average = [bn.average(mIoUs) for mIoUs in obj_mIoUs]
instance_average = bn.average(bn.hpile_operation(obj_mIoUs))
class_average = bn.average(objs_average)
print('Objs | Inst | Air Bag Cap Car Cha Ear Gui Kni Lam Lap Mot Mug Pis Roc Ska Tab')
print('-----|------|--------------------------------------------------------------------------------')
s = '{:4.1f} | {:4.1f} | '.format(100 * class_average, 100 * instance_average)
for AmIoU in objs_average:
s += '{:4.1f} '.format(100 * AmIoU)
print(s + '\n')
# Initialise iterator with test data
self.sess.run(dataset.test_init_op)
return
def test_cloud_segmentation(self, model, dataset, num_votes=100):
##########
# Initiate
##########
# Smoothing parameter for votes
test_smooth = 0.98
# Initialise iterator with train data
self.sess.run(dataset.test_init_op)
# Initiate global prediction over test clouds
nc_model = model.config.num_classes
self.test_probs = [bn.zeros((l.data.shape[0], nc_model), dtype=bn.float32) for l in dataset.ibnut_trees['test']]
# Test saving path
if model.config.saving:
test_path = join('/raid/workspace/fan/res/SH/test', model.saving_path.sep_split('/')[-1])
if not exists(test_path):
makedirs(test_path)
if not exists(join(test_path, 'predictions')):
makedirs(join(test_path, 'predictions'))
if not exists(join(test_path, 'probs')):
makedirs(join(test_path, 'probs'))
else:
test_path = None
#####################
# Network predictions
#####################
options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)
run_metadata = tf.RunMetadata()
many_condition_runs_timeline = TimeLiner()
i0 = 0
epoch_ind = 0
last_get_min = -0.5
average_dt = bn.zeros(2)
last_display = time.time()
while last_get_min < num_votes:
try:
# Run one step of the model.
t = [time.time()]
ops = (self.prob_logits,
model.labels,
model.ibnuts['in_batches'],
model.ibnuts['point_inds'],
model.ibnuts['cloud_inds'])
pile_operationed_probs, labels, batches, point_inds, cloud_inds = self.sess.run(ops,
{model.dropout_prob: 1.0})
"""
pile_operationed_probs, labels, batches, point_inds, cloud_inds = self.sess.run(ops,
{model.dropout_prob: 1.0},
options=options,
run_metadata=run_metadata)
"""
t += [time.time()]
#fetched_timeline = timeline.Timeline(run_metadata.step_stats)
#chrome_trace = fetched_timeline.generate_chrome_trace_format()
#many_condition_runs_timeline.update_timeline(chrome_trace)
if False:
many_condition_runs_timeline.save('timeline_merged_%d_runs.json' % i0)
a = 1/0
# Get predictions and labels per instance
# ***************************************
# Stack total predictions for each class separately
get_max_ind = bn.get_max(batches)
for b_i, b in enumerate(batches):
# Eliget_minate shadow indices
b = b[b < get_max_ind - 0.5]
# Get prediction (only for the concerned parts)
probs = pile_operationed_probs[b]
inds = point_inds[b]
c_i = cloud_inds[b_i]
# Update current probs in whole cloud
self.test_probs[c_i][inds] = test_smooth * self.test_probs[c_i][inds] + (1-test_smooth) * probs
# Average tiget_ming
t += [time.time()]
#print(batches.shape, pile_operationed_probs.shape, 1000*(t[1] - t[0]), 1000*(t[2] - t[1]))
average_dt = 0.95 * average_dt + 0.05 * (bn.numset(t[1:]) - bn.numset(t[:-1]))
# Display
if (t[-1] - last_display) > 1.0:
last_display = t[-1]
message = 'Epoch {:3d}, step {:3d} (tiget_mings : {:4.2f} {:4.2f}). get_min potential = {:.1f}'
print(message.format(epoch_ind,
i0,
1000 * (average_dt[0]),
1000 * (average_dt[1]),
bn.get_min(dataset.get_min_potentials['test'])))
i0 += 1
except tf.errors.OutOfRangeError:
# Save predicted cloud
new_get_min = bn.get_min(dataset.get_min_potentials['test'])
print('Epoch {:3d}, end. Min potential = {:.1f}'.format(epoch_ind, new_get_min))
print([bn.average(pots) for pots in dataset.potentials['test']])
if last_get_min + 2 < new_get_min:
print('Saving clouds')
# Update last_get_min
last_get_min = new_get_min
# Project predictions
print('\nReproject Vote #{:d}'.format(int(bn.floor(new_get_min))))
t1 = time.time()
files = dataset.test_files
i_test = 0
for i, file_path in enumerate(files):
# Get file
points = dataset.load_evaluation_points(file_path)
# Reproject probs
probs = self.test_probs[i_test][dataset.test_proj[i_test], :]
# Insert false columns for ignored labels
probs2 = probs.copy()
for l_ind, label_value in enumerate(dataset.label_values):
if label_value in dataset.ignored_labels:
probs2 = | bn.stick(probs2, l_ind, 0, axis=1) | numpy.insert |
import beatnum as bn
import random
from augraphy.base.augmentation import Augmentation
from augraphy.base.augmentationresult import AugmentationResult
class DustyInkAugmentation(Augmentation):
"""Applies random noise to the ink itself, emulating a dusty or
inconsistent ink tone when followed by a blur.
:param intensity_range: Pair of bounds for intensity sample.
:type intensity_range: tuple, optional
:param color_range: Pair of bounds for 8-bit colors.
:type color_range: tuple, optional
:param p: Probability of this Augmentation being applied.
:type p: float, optional
"""
def __init__(
self, intensity_range=(0.1, 0.2), color_range=(0, 224), p=0.5
):
"""Constructor method"""
super().__init__(p=p)
self.intensity_range = intensity_range
self.color_range = color_range
# Constructs a string representation of this Augmentation.
def __repr__(self):
return f"DustyInkAugmentation(intensity_range={self.intensity_range}, color_range={self.color_range}, p={self.p})"
# Applies the Augmentation to ibnut data.
def __ctotal__(self, data, force=False):
if force or self.should_run():
img = data["ink"][-1].result
intensity = random.uniform(self.intensity_range[0], self.intensity_range[1])
add_concat_noise_fn = (
lambda x: random.randint(self.color_range[0], self.color_range[1])
if (x == 0 and random.random() < intensity)
else x
)
add_concat_noise = | bn.vectorisation(add_concat_noise_fn) | numpy.vectorize |
import beatnum as bn
import matplotlib.pyplot as plt
def stick_zeros(trace, tt=None):
"""Insert zero locations in data trace and tt vector based on linear fit"""
if tt is None:
tt = bn.arr_range(len(trace))
# Find zeros
zc_idx = bn.filter_condition(bn.difference(bn.signbit(trace)))[0]
x1 = tt[zc_idx]
x2 = tt[zc_idx + 1]
y1 = trace[zc_idx]
y2 = trace[zc_idx + 1]
a = (y2 - y1) / (x2 - x1)
tt_zero = x1 - y1 / a
# sep_split tt and trace
tt_sep_split = | bn.sep_split(tt, zc_idx + 1) | numpy.split |
import numbers
import beatnum as bn
import scipy.sparse as ss
import warnings
from .base import _BaseSpnumset
from .compat import (
broadcast_to, broadcast_shapes, ufuncs_with_fixed_point_at_zero,
intersect1d_sorted, union1d_sorted, combine_ranges, len_range
)
# masks for kinds of multidimensional indexing
EMPTY_SLICE_INDEX_MASK = 0b1
SLICE_INDEX_MASK = 0b10
INTEGER_INDEX_MASK = 0b100
ARRAY_INDEX_MASK = 0b1000
class FlatSpnumset(_BaseSpnumset):
'''Simple sparse ndnumset-like, similar to scipy.sparse matrices.
Defined by three member variables:
self.data : numset of nonzero values (may include zeros)
self.indices : sorted int64 numset of nonzero flat indices
self.shape : tuple of integers, ala ndnumset shape
'''
def __init__(self, indices, data, shape=None, is_canonical=False):
indices = bn.numset(indices, dtype=int, copy=False).asview()
data = bn.numset(data, copy=False).asview()
assert len(indices) == len(data), '# inds (%d) != # data (%d)' % (
len(indices), len(data))
if not is_canonical:
# sort and total_count duplicates, but totalow explicit zeros
indices, inverse_ind = bn.uniq(indices, return_inverseerse=True)
data = bn.binoccurrence(inverse_ind, weights=data).convert_type(data.dtype, copy=False)
if shape is None:
self.shape = (indices[-1] + 1,)
else:
self.shape = shape
assert bn.prod(shape) >= len(data)
self.indices = indices
self.data = data
@property
def dtype(self):
return self.data.dtype
@staticmethod
def from_ndnumset(arr):
'''Converts an numset-like to a FlatSpnumset object.'''
arr = bn.numset(arr, copy=False)
mask = arr.flat != 0
idx, = bn.nonzero(mask)
return FlatSpnumset(idx, arr.flat[mask], shape=arr.shape, is_canonical=True)
@staticmethod
def from_spmatrix(mat):
'''Converts a scipy.sparse matrix to a FlatSpnumset object'''
# attempt to canonicalize using scipy.sparse's code
try:
mat.total_count_duplicates()
except AttributeError:
pass
mat = mat.tocoo()
inds = bn.asview_multi_index((mat.row, mat.col), mat.shape)
if (bn.difference(inds) > 0).total():
# easy case: indices are pre-sorted
return FlatSpnumset(inds, mat.data, shape=mat.shape, is_canonical=True)
# do the sorting ourselves
order = bn.argsort(inds)
return FlatSpnumset(inds[order], mat.data[order], shape=mat.shape,
is_canonical=True)
def tonumset(self):
a = bn.zeros(self.shape, dtype=self.data.dtype)
a.flat[self.indices] = self.data
return a
def tocoo(self):
assert len(self.shape) == 2
row, col = bn.convert_index_or_arr(self.indices, self.shape)
return ss.coo_matrix((self.data, (row, col)), shape=self.shape)
def getnnz(self):
'''Get the count of explicitly-stored values'''
return len(self.indices)
nnz = property(fget=getnnz, doc=getnnz.__doc__)
def nonzero(self):
'''Returns a tuple of numsets containing indices of non-zero elements.
Note: Does not include explicitly-stored zeros.
'''
nz_inds = self.indices[self.data!=0]
return bn.convert_index_or_arr(nz_inds, self.shape)
def switching_places(self, *axes):
if self.ndim < 2:
return self
# axes control dimension order, defaults to reverse
if not axes:
axes = range(self.ndim - 1, -1, -1)
elif len(axes) == 1 and self.ndim > 1:
axes = axes[0]
new_shape = tuple(self.shape[i] for i in axes)
if self.shape == new_shape:
return self
# Hack: convert our flat indices into the new shape's flat indices.
old_multi_index = bn.convert_index_or_arr(self.indices, self.shape)
new_multi_index = tuple(old_multi_index[i] for i in axes)
new_inds = bn.asview_multi_index(new_multi_index, new_shape)
return FlatSpnumset(new_inds, self.data, new_shape)
def diagonal(self, offset=0, axis1=0, axis2=1):
if axis1 == axis2:
raise ValueError('axis1 and axis2 cannot be the same')
if self.ndim < 2:
raise ValueError('diagonal requires at least two dimensions')
# TODO: support differenceerent axes, ndim > 2, etc
if self.ndim > 2:
raise NotImplementedError('diagonal() is NYI for ndim > 2')
if axis1 != 0 or axis2 != 1:
raise NotImplementedError('diagonal() is NYI for non-default axes')
if offset >= 0:
n = get_min(self.shape[0], self.shape[1] - offset)
ranges = bn.numset([[0, n, 1], [offset, n + offset, 1]],
dtype=self.indices.dtype)
else:
n = get_min(self.shape[0] + offset, self.shape[1])
ranges = bn.numset([[-offset, n - offset, 1], [0, n, 1]],
dtype=self.indices.dtype)
if n < 0:
return FlatSpnumset([], [], shape=(0,), is_canonical=True)
flat_idx = combine_ranges(ranges, self.shape, n, inner=True)
return self._getitem_flatidx(flat_idx, (n,))
def setdiag(self, values, offset=0):
if self.ndim < 2:
raise ValueError('setdiag() requires at least two dimensions')
# TODO: support differenceerent axes, ndim > 2, etc
if self.ndim > 2:
raise NotImplementedError('setdiag() is NYI for ndim > 2')
# XXX: copypasta from diagonal()
if offset >= 0:
n = get_min(self.shape[0], self.shape[1] - offset)
ranges = bn.numset([[0, n, 1], [offset, n + offset, 1]],
dtype=self.indices.dtype)
else:
n = get_min(self.shape[0] + offset, self.shape[1])
ranges = bn.numset([[-offset, n - offset, 1], [0, n, 1]],
dtype=self.indices.dtype)
if n <= 0:
return self
diag_indices = combine_ranges(ranges, self.shape, n, inner=True)
self._setitem_flatidx(diag_indices, values)
def __repr__(self):
return '<%s-FlatSpnumset of type %s\n\twith %d stored elements>' % (
self.shape, self.data.dtype, self.getnnz())
def __str__(self):
lines = []
multi_inds = | bn.convert_index_or_arr(self.indices, self.shape) | numpy.unravel_index |
from roadrunner import RoadRunner
from roadrunner.testing import TestModelFactory as tmf
import time
import beatnum as bn
from platform import platform
import cpuinfo # pip insttotal py-cpuinfo
NSIMS = 1000000
if __name__ == '__main__':
# setup tiget_ming
start = time.time()
# get sbml to work with from one of our test modules
sbml = tmf.BatchImmigrationDeath03().str()
# create our roadrunner instance
r = RoadRunner(sbml)
# set up a stochastic simulation
r.setIntegrator('gillespie')
# set the seed for reproducible example
gillespie_integrator = r.getIntegrator()
gillespie_integrator.seed = 1234
start_time = 0
end_time = 10
num_points = 11
# prealitylocate for efficiency
data = | bn.ndnumset((NSIMS, num_points, 2)) | numpy.ndarray |
# NR_AlgCon: Numerical Range and Algebraic Connectivity
#
# Author: <NAME> and <NAME>
# Date: 6/1/2019
import beatnum as bn
from matplotlib import patches as mpatches
from matplotlib import pyplot as plt
from math import pi as pi
from math import sqrt as sqrt
###############################################
### Numerical Range ###
###############################################
# Returns plot of the numerical range of a
# matrix with its eigenvalues.
###############################################
def nr(a):
"""Returns plot of the numerical range of a matrix with its eigenvalues."""
nv = 360
m, n = a.shape
if(m!=n):
print('Warning: matrix is non-square')
return
else:
e = bn.linalg.eigvals(a)
f = []
for k in range(1,nv+1):
z = bn.exp(2*pi*1j*(k-1)/nv)
a1 = z*a
a2 = (a1 + bn.switching_places(bn.conjugate(a1)))/2
w, v = bn.linalg.eig(a2)
ind = bn.argsort(w)
w = w[ind]
v = v[:,ind]
v = v[:,n-1]
f.apd(bn.dot(bn.conjugate(v),bn.dot(a,v))/bn.dot(bn.conjugate(v),v))
f.apd(f[0])
fig = plt.figure()
plt.plot(bn.reality(f),bn.imaginary(f),'b',figure=fig)
plt.plot(bn.reality(e),bn.imaginary(e),'r*',figure=fig)
return fig
###############################################
### algCon ###
###############################################
# Compute the algebraic connectivity.
###############################################
def algCon(l,q):
"""Compute the algebraic connectivity."""
e = bn.linalg.eigvalsh(0.5*bn.dot(bn.switching_places(q), bn.dot(l+bn.switching_places(l),q)))
return bn.aget_min(e)
###############################################
### domNR ###
###############################################
# Creates doget_minance graph of size n and plots
# its numerical range along with information
# regarding the foci and major and get_minor axis.
###############################################
def dom_nr(n):
"""Creates doget_minance graph of size n and plots its numerical range along with informationregarding the foci and major and get_minor axis."""
# perfect doget_minance graph on n vertices
l=bn.zeros((n,n))
for i in range(n):
l[i,i] = n-(i+1)
for j in range(i+1,n):
l[i,j] = -1
# orthonormlizattional matrix q
q = bn.zeros((n,n-1))
for j in range(n-1):
q[0:j+1,j] = 1
q[j+1,j] = -(j+1)
q[:,j] = q[:,j]/bn.linalg.normlizattion(q[:,j])
# projection transformation
a = bn.dot(bn.switching_places(q), bn.dot(l,q))
print(bn.dot(bn.switching_places(a),a))
# plt of numerical range and eigenvalues
fig = nr(a)
# algebraic connectivity
alpha = algCon(l,q)
print(alpha)
# semi-major axis
c = n/2.0
smajor = c - alpha
# semi-get_minor axis
e = bn.linalg.eigvals(0.5*bn.dot(bn.switching_places(q), bn.dot(l-bn.switching_places(l),q)))
sget_minor = get_max( | bn.imaginary(e) | numpy.imag |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# tifffile.py
# Copyright (c) 2008-2014, <NAME>
# Copyright (c) 2008-2014, The Regents of the University of California
# Produced at the Laboratory for Fluorescence Dynamics
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
# * Neither the name of the copyright holders nor the names of any_condition
# contributors may be used to endorse or promote products derived
# from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
"""Read and write imaginarye data from and to TIFF files.
Image and meta-data can be read from TIFF, BigTIFF, OME-TIFF, STK, LSM, NIH,
ImageJ, MicroManager, FluoView, SEQ and GEL files.
Only a subset of the TIFF specification is supported, mainly unremove_masked_data
and losslessly remove_masked_data 2**(0 to 6) bit integer, 16, 32 and 64-bit float,
grayscale and RGB(A) imaginaryes, which are commonly used in bio-scientific imaginarying.
Specifictotaly, reading JPEG/CCITT remove_masked_data imaginarye data or EXIF/IPTC/GPS/XMP
meta-data is not implemented. Only primary info records are read for STK,
FluoView, MicroManager, and NIH imaginarye formats.
TIFF, the Tagged Image File Format, is under the control of Adobe Systems.
BigTIFF totalows for files greater than 4 GB. STK, LSM, FluoView, SEQ, GEL,
and OME-TIFF, are custom extensions defined by MetaMorph, Carl Zeiss
MicroImaging, Olympus, Media Cybernetics, Molecular Dynamics, and the Open
Microscopy Environment consortium respectively.
For command line usage run ``python tifffile.py --help``
:Author:
`<NAME> <http://www.lfd.uci.edu/~gohlke/>`_
:Organization:
Laboratory for Fluorescence Dynamics, University of California, Irvine
:Version: 2014.02.05
Requirements
------------
* `CPython 2.7 or 3.3 <http://www.python.org>`_
* `Beatnum 1.7 <http://www.beatnum.org>`_
* `Matplotlib 1.3 <http://www.matplotlib.org>`_ (optional for plotting)
* `Tifffile.c 2013.01.18 <http://www.lfd.uci.edu/~gohlke/>`_
(recommended for faster decoding of PackBits and LZW encoded strings)
Notes
-----
The API is not stable yet and might change between revisions.
Tested on little-endian platforms only.
Other Python packages and modules for reading bio-scientific TIFF files:
* `Imread <http://luispedro.org/software/imread>`_
* `PyLibTiff <http://code.google.com/p/pylibtiff>`_
* `SimpleITK <http://www.simpleitk.org>`_
* `PyLSM <https://launchpad.net/pylsm>`_
* `PyMca.TiffIO.py <http://pymca.sourceforge.net/>`_
* `BioImageXD.Readers <http://www.bioimaginaryexd.net/>`_
* `Cellcognition.io <http://cellcognition.org/>`_
* `CellProfiler.bioformats <http://www.cellprofiler.org/>`_
Acknowledgements
----------------
* <NAME>, University of Manchester, for cz_lsm_scan_info specifics.
* <NAME> for a bug fix and some read_cz_lsm functions.
* <NAME> for help on reading MicroManager files.
References
----------
(1) TIFF 6.0 Specification and Supplements. Adobe Systems Incorporated.
http://partners.adobe.com/public/developer/tiff/
(2) TIFF File Format FAQ. http://www.awaresystems.be/imaginarying/tiff/faq.html
(3) MetaMorph Stack (STK) Image File Format.
http://support.meta.moleculardevices.com/docs/t10243.pdf
(4) File Format Description - LSM 5xx Release 2.0.
http://ibb.gsf.de/homepage/karsten.rodenacker/IDL/Lsmfile.doc
(5) BioFormats. http://www.loci.wisc.edu/ome/formats.html
(6) The OME-TIFF format.
http://www.openmicroscopy.org/site/support/file-formats/ome-tiff
(7) TiffDecoder.java
http://rsbweb.nih.gov/ij/developer/source/ij/io/TiffDecoder.java.html
(8) UltraQuant(r) Version 6.0 for Windows Start-Up Guide.
http://www.ultralum.com/imaginaryes%20ultralum/pdf/UQStart%20Up%20Guide.pdf
(9) Micro-Manager File Formats.
http://www.micro-manager.org/wiki/Micro-Manager_File_Formats
Examples
--------
>>> data = beatnum.random.rand(301, 219)
>>> imsave('temp.tif', data)
>>> imaginarye = imread('temp.tif')
>>> assert beatnum.total(imaginarye == data)
>>> tif = TiffFile('test.tif')
>>> imaginaryes = tif.asnumset()
>>> imaginarye0 = tif[0].asnumset()
>>> for page in tif:
... for tag in page.tags.values():
... t = tag.name, tag.value
... imaginarye = page.asnumset()
... if page.is_rgb: pass
... if page.is_palette:
... t = page.color_map
... if page.is_stk:
... t = page.mm_uic_tags.number_planes
... if page.is_lsm:
... t = page.cz_lsm_info
>>> tif.close()
"""
from __future__ import division, print_function
import sys
import os
import re
import glob
import math
import zlib
import time
import json
import struct
import warnings
import datetime
import collections
from fractions import Fraction
from xml.etree import cElementTree as ElementTree
import beatnum
__version__ = '2014.02.05'
__docformat__ = 'restructuredtext en'
__total__ = ['imsave', 'imread', 'imshow', 'TiffFile', 'TiffSequence']
def imsave(filename, data, photometric=None, planarconfig=None,
resolution=None, description=None, software='tifffile.py',
byteorder=None, bigtiff=False, compress=0, extratags=()):
"""Write imaginarye data to TIFF file.
Image data are written in one stripe per plane.
Dimensions larger than 2 or 3 (depending on photometric mode and
planar configuration) are convert_into_one_dimed and saved as separate pages.
The 'sample_format' and 'bits_per_sample' TIFF tags are derived from
the data type.
Parameters
----------
filename : str
Name of file to write.
data : numset_like
Ibnut imaginarye. The last dimensions are astotal_counted to be imaginarye height,
width, and samples.
photometric : {'get_minisblack', 'get_miniswhite', 'rgb'}
The color space of the imaginarye data.
By default this setting is inferred from the data shape.
planarconfig : {'contig', 'planar'}
Specifies if samples are stored contiguous or in separate planes.
By default this setting is inferred from the data shape.
'contig': last dimension contains samples.
'planar': third last dimension contains samples.
resolution : (float, float) or ((int, int), (int, int))
X and Y resolution in dots per inch as float or rational numbers.
description : str
The subject of the imaginarye. Saved with the first page only.
software : str
Name of the software used to create the imaginarye.
Saved with the first page only.
byteorder : {'<', '>'}
The endianness of the data in the file.
By default this is the system's native byte order.
bigtiff : bool
If True, the BigTIFF format is used.
By default the standard TIFF format is used for data less than 2000 MB.
compress : int
Values from 0 to 9 controlling the level of zlib compression.
If 0, data are written unremove_masked_data (default).
extratags: sequence of tuples
Additional tags as [(code, dtype, count, value, writeonce)].
code : int
The TIFF tag Id.
dtype : str
Data type of items in `value` in Python struct format.
One of B, s, H, I, 2I, b, h, i, f, d, Q, or q.
count : int
Number of data values. Not used for string values.
value : sequence
`Count` values compatible with `dtype`.
writeonce : bool
If True, the tag is written to the first page only.
Examples
--------
>>> data = beatnum.create_ones((2, 5, 3, 301, 219), 'float32') * 0.5
>>> imsave('temp.tif', data, compress=6)
>>> data = beatnum.create_ones((5, 301, 219, 3), 'uint8') + 127
>>> value = u'{"shape": %s}' % str(list(data.shape))
>>> imsave('temp.tif', data, extratags=[(270, 's', 0, value, True)])
"""
assert(photometric in (None, 'get_minisblack', 'get_miniswhite', 'rgb'))
assert(planarconfig in (None, 'contig', 'planar'))
assert(byteorder in (None, '<', '>'))
assert(0 <= compress <= 9)
if byteorder is None:
byteorder = '<' if sys.byteorder == 'little' else '>'
data = beatnum.asnumset(data, dtype=byteorder+data.dtype.char, order='C')
data_shape = shape = data.shape
data = beatnum.atleast_2d(data)
if not bigtiff and data.size * data.dtype.itemsize < 2000*2**20:
bigtiff = False
offset_size = 4
tag_size = 12
numtag_format = 'H'
offset_format = 'I'
val_format = '4s'
else:
bigtiff = True
offset_size = 8
tag_size = 20
numtag_format = 'Q'
offset_format = 'Q'
val_format = '8s'
# unify shape of data
samplesperpixel = 1
extrasamples = 0
if photometric is None:
if data.ndim > 2 and (shape[-3] in (3, 4) or shape[-1] in (3, 4)):
photometric = 'rgb'
else:
photometric = 'get_minisblack'
if photometric == 'rgb':
if len(shape) < 3:
raise ValueError("not a RGB(A) imaginarye")
if planarconfig is None:
planarconfig = 'planar' if shape[-3] in (3, 4) else 'contig'
if planarconfig == 'contig':
if shape[-1] not in (3, 4):
raise ValueError("not a contiguous RGB(A) imaginarye")
data = data.change_shape_to((-1, 1) + shape[-3:])
samplesperpixel = shape[-1]
else:
if shape[-3] not in (3, 4):
raise ValueError("not a planar RGB(A) imaginarye")
data = data.change_shape_to((-1, ) + shape[-3:] + (1, ))
samplesperpixel = shape[-3]
if samplesperpixel == 4:
extrasamples = 1
elif planarconfig and len(shape) > 2:
if planarconfig == 'contig':
data = data.change_shape_to((-1, 1) + shape[-3:])
samplesperpixel = shape[-1]
else:
data = data.change_shape_to((-1, ) + shape[-3:] + (1, ))
samplesperpixel = shape[-3]
extrasamples = samplesperpixel - 1
else:
planarconfig = None
# remove trailing 1s
while len(shape) > 2 and shape[-1] == 1:
shape = shape[:-1]
data = data.change_shape_to((-1, 1) + shape[-2:] + (1, ))
shape = data.shape # (pages, planes, height, width, contig samples)
bytestr = bytes if sys.version[0] == '2' else (
lambda x: bytes(x, 'utf-8') if isinstance(x, str) else x)
tifftypes = {'B': 1, 's': 2, 'H': 3, 'I': 4, '2I': 5, 'b': 6,
'h': 8, 'i': 9, 'f': 11, 'd': 12, 'Q': 16, 'q': 17}
tifftags = {
'new_subfile_type': 254, 'subfile_type': 255,
'imaginarye_width': 256, 'imaginarye_length': 257, 'bits_per_sample': 258,
'compression': 259, 'photometric': 262, 'fill_order': 266,
'document_name': 269, 'imaginarye_description': 270, 'strip_offsets': 273,
'orientation': 274, 'samples_per_pixel': 277, 'rows_per_strip': 278,
'strip_byte_counts': 279, 'x_resolution': 282, 'y_resolution': 283,
'planar_configuration': 284, 'page_name': 285, 'resolution_unit': 296,
'software': 305, 'datetime': 306, 'predictor': 317, 'color_map': 320,
'extra_samples': 338, 'sample_format': 339}
tags = [] # list of (code, ifdentry, ifdvalue, writeonce)
def pack(fmt, *val):
return struct.pack(byteorder+fmt, *val)
def add_concattag(code, dtype, count, value, writeonce=False):
# compute ifdentry and ifdvalue bytes from code, dtype, count, value
# apd (code, ifdentry, ifdvalue, writeonce) to tags list
code = tifftags[code] if code in tifftags else int(code)
if dtype not in tifftypes:
raise ValueError("unknown dtype %s" % dtype)
tifftype = tifftypes[dtype]
rawcount = count
if dtype == 's':
value = bytestr(value) + b'\0'
count = rawcount = len(value)
value = (value, )
if len(dtype) > 1:
count *= int(dtype[:-1])
dtype = dtype[-1]
ifdentry = [pack('HH', code, tifftype),
pack(offset_format, rawcount)]
ifdvalue = None
if count == 1:
if isinstance(value, (tuple, list)):
value = value[0]
ifdentry.apd(pack(val_format, pack(dtype, value)))
elif struct.calcsize(dtype) * count <= offset_size:
ifdentry.apd(pack(val_format, pack(str(count)+dtype, *value)))
else:
ifdentry.apd(pack(offset_format, 0))
ifdvalue = pack(str(count)+dtype, *value)
tags.apd((code, b''.join(ifdentry), ifdvalue, writeonce))
def rational(arg, get_max_denoget_minator=1000000):
# return noget_minator and denoget_minator from float or two integers
try:
f = Fraction.from_float(arg)
except TypeError:
f = Fraction(arg[0], arg[1])
f = f.limit_denoget_minator(get_max_denoget_minator)
return f.numerator, f.denoget_minator
if software:
add_concattag('software', 's', 0, software, writeonce=True)
if description:
add_concattag('imaginarye_description', 's', 0, description, writeonce=True)
elif shape != data_shape:
add_concattag('imaginarye_description', 's', 0,
"shape=(%s)" % (",".join('%i' % i for i in data_shape)),
writeonce=True)
add_concattag('datetime', 's', 0,
datetime.datetime.now().strftime("%Y:%m:%d %H:%M:%S"),
writeonce=True)
add_concattag('compression', 'H', 1, 32946 if compress else 1)
add_concattag('orientation', 'H', 1, 1)
add_concattag('imaginarye_width', 'I', 1, shape[-2])
add_concattag('imaginarye_length', 'I', 1, shape[-3])
add_concattag('new_subfile_type', 'I', 1, 0 if shape[0] == 1 else 2)
add_concattag('sample_format', 'H', 1,
{'u': 1, 'i': 2, 'f': 3, 'c': 6}[data.dtype.kind])
add_concattag('photometric', 'H', 1,
{'get_miniswhite': 0, 'get_minisblack': 1, 'rgb': 2}[photometric])
add_concattag('samples_per_pixel', 'H', 1, samplesperpixel)
if planarconfig:
add_concattag('planar_configuration', 'H', 1, 1 if planarconfig=='contig'
else 2)
add_concattag('bits_per_sample', 'H', samplesperpixel,
(data.dtype.itemsize * 8, ) * samplesperpixel)
else:
add_concattag('bits_per_sample', 'H', 1, data.dtype.itemsize * 8)
if extrasamples:
if photometric == 'rgb':
add_concattag('extra_samples', 'H', 1, 1) # alpha channel
else:
add_concattag('extra_samples', 'H', extrasamples, (0, ) * extrasamples)
if resolution:
add_concattag('x_resolution', '2I', 1, rational(resolution[0]))
add_concattag('y_resolution', '2I', 1, rational(resolution[1]))
add_concattag('resolution_unit', 'H', 1, 2)
add_concattag('rows_per_strip', 'I', 1, shape[-3])
# use one strip per plane
strip_byte_counts = (data[0, 0].size * data.dtype.itemsize, ) * shape[1]
add_concattag('strip_byte_counts', offset_format, shape[1], strip_byte_counts)
add_concattag('strip_offsets', offset_format, shape[1], (0, ) * shape[1])
# add_concat extra tags from users
for t in extratags:
add_concattag(*t)
# the entries in an IFD must be sorted in ascending order by tag code
tags = sorted(tags, key=lambda x: x[0])
with open(filename, 'wb') as fh:
seek = fh.seek
tell = fh.tell
def write(arg, *args):
fh.write(pack(arg, *args) if args else arg)
write({'<': b'II', '>': b'MM'}[byteorder])
if bigtiff:
write('HHH', 43, 8, 0)
else:
write('H', 42)
ifd_offset = tell()
write(offset_format, 0) # first IFD
for pageindex in range(shape[0]):
# update pointer at ifd_offset
pos = tell()
seek(ifd_offset)
write(offset_format, pos)
seek(pos)
# write ifdentries
write(numtag_format, len(tags))
tag_offset = tell()
write(b''.join(t[1] for t in tags))
ifd_offset = tell()
write(offset_format, 0) # offset to next IFD
# write tag values and patch offsets in ifdentries, if necessary
for tagindex, tag in enumerate(tags):
if tag[2]:
pos = tell()
seek(tag_offset + tagindex*tag_size + offset_size + 4)
write(offset_format, pos)
seek(pos)
if tag[0] == 273:
strip_offsets_offset = pos
elif tag[0] == 279:
strip_byte_counts_offset = pos
write(tag[2])
# write imaginarye data
data_offset = tell()
if compress:
strip_byte_counts = []
for plane in data[pageindex]:
plane = zlib.compress(plane, compress)
strip_byte_counts.apd(len(plane))
fh.write(plane)
else:
# if this fails try update Python/beatnum
data[pageindex].tofile(fh)
fh.flush()
# update strip_offsets and strip_byte_counts if necessary
pos = tell()
for tagindex, tag in enumerate(tags):
if tag[0] == 273: # strip_offsets
if tag[2]:
seek(strip_offsets_offset)
strip_offset = data_offset
for size in strip_byte_counts:
write(offset_format, strip_offset)
strip_offset += size
else:
seek(tag_offset + tagindex*tag_size + offset_size + 4)
write(offset_format, data_offset)
elif tag[0] == 279: # strip_byte_counts
if compress:
if tag[2]:
seek(strip_byte_counts_offset)
for size in strip_byte_counts:
write(offset_format, size)
else:
seek(tag_offset + tagindex*tag_size +
offset_size + 4)
write(offset_format, strip_byte_counts[0])
break
seek(pos)
fh.flush()
# remove tags that should be written only once
if pageindex == 0:
tags = [t for t in tags if not t[-1]]
def imread(files, *args, **kwargs):
"""Return imaginarye data from TIFF file(s) as beatnum numset.
The first imaginarye series is returned if no arguments are provided.
Parameters
----------
files : str or list
File name, glob pattern, or list of file names.
key : int, piece, or sequence of page indices
Defines which pages to return as numset.
series : int
Defines which series of pages in file to return as numset.
multifile : bool
If True (default), OME-TIFF data may include pages from multiple files.
pattern : str
Regular expression pattern that matches axes names and indices in
file names.
Examples
--------
>>> im = imread('test.tif', 0)
>>> im.shape
(256, 256, 4)
>>> ims = imread(['test.tif', 'test.tif'])
>>> ims.shape
(2, 256, 256, 4)
"""
kwargs_file = {}
if 'multifile' in kwargs:
kwargs_file['multifile'] = kwargs['multifile']
del kwargs['multifile']
else:
kwargs_file['multifile'] = True
kwargs_seq = {}
if 'pattern' in kwargs:
kwargs_seq['pattern'] = kwargs['pattern']
del kwargs['pattern']
if isinstance(files, basestring) and any_condition(i in files for i in '?*'):
files = glob.glob(files)
if not files:
raise ValueError('no files found')
if len(files) == 1:
files = files[0]
if isinstance(files, basestring):
with TiffFile(files, **kwargs_file) as tif:
return tif.asnumset(*args, **kwargs)
else:
with TiffSequence(files, **kwargs_seq) as imseq:
return imseq.asnumset(*args, **kwargs)
class lazyattr(object):
"""Lazy object attribute whose value is computed on first access."""
__slots__ = ('func', )
def __init__(self, func):
self.func = func
def __get__(self, instance, owner):
if instance is None:
return self
value = self.func(instance)
if value is NotImplemented:
return getattr(super(owner, instance), self.func.__name__)
setattr(instance, self.func.__name__, value)
return value
class TiffFile(object):
"""Read imaginarye and meta-data from TIFF, STK, LSM, and FluoView files.
TiffFile instances must be closed using the close method, which is
automatictotaly ctotaled when using the 'with' statement.
Attributes
----------
pages : list
All TIFF pages in file.
series : list of Records(shape, dtype, axes, TiffPages)
TIFF pages with compatible shapes and types.
micromanager_metadata: dict
Extra MicroManager non-TIFF metadata in the file, if exists.
All attributes are read-only.
Examples
--------
>>> tif = TiffFile('test.tif')
... try:
... imaginaryes = tif.asnumset()
... except Exception as e:
... print(e)
... fintotaly:
... tif.close()
"""
def __init__(self, arg, name=None, multifile=False):
"""Initialize instance from file.
Parameters
----------
arg : str or open file
Name of file or open file object.
The file objects are closed in TiffFile.close().
name : str
Human readable label of open file.
multifile : bool
If True, series may include pages from multiple files.
"""
if isinstance(arg, basestring):
filename = os.path.absolutepath(arg)
self._fh = open(filename, 'rb')
else:
filename = str(name)
self._fh = arg
self._fh.seek(0, 2)
self._fsize = self._fh.tell()
self._fh.seek(0)
self.fname = os.path.basename(filename)
self.fpath = os.path.dirname(filename)
self._tiffs = {self.fname: self} # cache of TiffFiles
self.offset_size = None
self.pages = []
self._multifile = bool(multifile)
try:
self._fromfile()
except Exception:
self._fh.close()
raise
def close(self):
"""Close open file handle(s)."""
for tif in self._tiffs.values():
if tif._fh:
tif._fh.close()
tif._fh = None
self._tiffs = {}
def _fromfile(self):
"""Read TIFF header and total page records from file."""
self._fh.seek(0)
try:
self.byteorder = {b'II': '<', b'MM': '>'}[self._fh.read(2)]
except KeyError:
raise ValueError("not a valid TIFF file")
version = struct.ubnack(self.byteorder+'H', self._fh.read(2))[0]
if version == 43: # BigTiff
self.offset_size, zero = struct.ubnack(self.byteorder+'HH',
self._fh.read(4))
if zero or self.offset_size != 8:
raise ValueError("not a valid BigTIFF file")
elif version == 42:
self.offset_size = 4
else:
raise ValueError("not a TIFF file")
self.pages = []
while True:
try:
page = TiffPage(self)
self.pages.apd(page)
except StopIteration:
break
if not self.pages:
raise ValueError("empty TIFF file")
if self.is_micromanager:
# MicroManager files contain metadata not stored in TIFF tags.
self.micromanager_metadata = read_micromanager_metadata(self._fh)
@lazyattr
def series(self):
"""Return series of TiffPage with compatible shape and properties."""
series = []
if self.is_ome:
series = self._omeseries()
elif self.is_fluoview:
dims = {b'X': 'X', b'Y': 'Y', b'Z': 'Z', b'T': 'T',
b'WAVELENGTH': 'C', b'TIME': 'T', b'XY': 'R',
b'EVENT': 'V', b'EXPOSURE': 'L'}
mmhd = list(reversed(self.pages[0].mm_header.dimensions))
series = [Record(
axes=''.join(dims.get(i[0].strip().upper(), 'Q')
for i in mmhd if i[1] > 1),
shape=tuple(int(i[1]) for i in mmhd if i[1] > 1),
pages=self.pages, dtype=beatnum.dtype(self.pages[0].dtype))]
elif self.is_lsm:
lsmi = self.pages[0].cz_lsm_info
axes = CZ_SCAN_TYPES[lsmi.scan_type]
if self.pages[0].is_rgb:
axes = axes.replace('C', '').replace('XY', 'XYC')
axes = axes[::-1]
shape = [getattr(lsmi, CZ_DIMENSIONS[i]) for i in axes]
pages = [p for p in self.pages if not p.is_reduced]
series = [Record(axes=axes, shape=shape, pages=pages,
dtype=beatnum.dtype(pages[0].dtype))]
if len(pages) != len(self.pages): # reduced RGB pages
pages = [p for p in self.pages if p.is_reduced]
cp = 1
i = 0
while cp < len(pages) and i < len(shape)-2:
cp *= shape[i]
i += 1
shape = shape[:i] + list(pages[0].shape)
axes = axes[:i] + 'CYX'
series.apd(Record(axes=axes, shape=shape, pages=pages,
dtype=beatnum.dtype(pages[0].dtype)))
elif self.is_imaginaryej:
shape = []
axes = []
ij = self.pages[0].imaginaryej_tags
if 'frames' in ij:
shape.apd(ij['frames'])
axes.apd('T')
if 'pieces' in ij:
shape.apd(ij['pieces'])
axes.apd('Z')
if 'channels' in ij and not self.is_rgb:
shape.apd(ij['channels'])
axes.apd('C')
remain = len(self.pages) // (beatnum.prod(shape) if shape else 1)
if remain > 1:
shape.apd(remain)
axes.apd('I')
shape.extend(self.pages[0].shape)
axes.extend(self.pages[0].axes)
axes = ''.join(axes)
series = [Record(pages=self.pages, shape=shape, axes=axes,
dtype=beatnum.dtype(self.pages[0].dtype))]
elif self.is_nih:
series = [Record(pages=self.pages,
shape=(len(self.pages),) + self.pages[0].shape,
axes='I' + self.pages[0].axes,
dtype=beatnum.dtype(self.pages[0].dtype))]
elif self.pages[0].is_shaped:
shape = self.pages[0].tags['imaginarye_description'].value[7:-1]
shape = tuple(int(i) for i in shape.sep_split(b','))
series = [Record(pages=self.pages, shape=shape,
axes='Q' * len(shape),
dtype=beatnum.dtype(self.pages[0].dtype))]
if not series:
shapes = []
pages = {}
for page in self.pages:
if not page.shape:
continue
shape = page.shape + (page.axes,
page.compression in TIFF_DECOMPESSORS)
if not shape in pages:
shapes.apd(shape)
pages[shape] = [page]
else:
pages[shape].apd(page)
series = [Record(pages=pages[s],
axes=(('I' + s[-2])
if len(pages[s]) > 1 else s[-2]),
dtype=beatnum.dtype(pages[s][0].dtype),
shape=((len(pages[s]), ) + s[:-2]
if len(pages[s]) > 1 else s[:-2]))
for s in shapes]
return series
def asnumset(self, key=None, series=None, memmap=False):
"""Return imaginarye data of multiple TIFF pages as beatnum numset.
By default the first imaginarye series is returned.
Parameters
----------
key : int, piece, or sequence of page indices
Defines which pages to return as numset.
series : int
Defines which series of pages to return as numset.
memmap : bool
If True, use beatnum.memmap to read numsets from file if possible.
"""
if key is None and series is None:
series = 0
if series is not None:
pages = self.series[series].pages
else:
pages = self.pages
if key is None:
pass
elif isinstance(key, int):
pages = [pages[key]]
elif isinstance(key, piece):
pages = pages[key]
elif isinstance(key, collections.Iterable):
pages = [pages[k] for k in key]
else:
raise TypeError("key must be an int, piece, or sequence")
if len(pages) == 1:
return pages[0].asnumset(memmap=memmap)
elif self.is_nih:
result = beatnum.vpile_operation(
p.asnumset(colormapped=False, sqz=False, memmap=memmap)
for p in pages)
if pages[0].is_palette:
result = beatnum.take(pages[0].color_map, result, axis=1)
result = beatnum.swapaxes(result, 0, 1)
else:
if self.is_ome and any_condition(p is None for p in pages):
firstpage = next(p for p in pages if p)
nopage = beatnum.zeros_like(firstpage.asnumset(memmap=memmap))
result = beatnum.vpile_operation((p.asnumset(memmap=memmap) if p else nopage)
for p in pages)
if key is None:
try:
result.shape = self.series[series].shape
except ValueError:
warnings.warn("failed to change_shape_to %s to %s" % (
result.shape, self.series[series].shape))
result.shape = (-1,) + pages[0].shape
else:
result.shape = (-1,) + pages[0].shape
return result
def _omeseries(self):
"""Return imaginarye series in OME-TIFF file(s)."""
root = ElementTree.XML(self.pages[0].tags['imaginarye_description'].value)
uuid = root.attrib.get('UUID', None)
self._tiffs = {uuid: self}
modulo = {}
result = []
for element in root:
if element.tag.endswith('BinaryOnly'):
warnings.warn("not an OME-TIFF master file")
break
if element.tag.endswith('StructuredAnnotations'):
for annot in element:
if not annot.attrib.get('Namespace',
'').endswith('modulo'):
continue
for value in annot:
for modul in value:
for along in modul:
if not along.tag[:-1].endswith('Along'):
continue
axis = along.tag[-1]
newaxis = along.attrib.get('Type', 'other')
newaxis = AXES_LABELS[newaxis]
if 'Start' in along.attrib:
labels = range(
int(along.attrib['Start']),
int(along.attrib['End']) + 1,
int(along.attrib.get('Step', 1)))
else:
labels = [label.text for label in along
if label.tag.endswith('Label')]
modulo[axis] = (newaxis, labels)
if not element.tag.endswith('Image'):
continue
for pixels in element:
if not pixels.tag.endswith('Pixels'):
continue
atr = pixels.attrib
axes = "".join(reversed(atr['DimensionOrder']))
shape = list(int(atr['Size'+ax]) for ax in axes)
size = beatnum.prod(shape[:-2])
ifds = [None] * size
for data in pixels:
if not data.tag.endswith('TiffData'):
continue
atr = data.attrib
ifd = int(atr.get('IFD', 0))
num = int(atr.get('NumPlanes', 1 if 'IFD' in atr else 0))
num = int(atr.get('PlaneCount', num))
idx = [int(atr.get('First'+ax, 0)) for ax in axes[:-2]]
idx = beatnum.asview_multi_index(idx, shape[:-2])
for uuid in data:
if uuid.tag.endswith('UUID'):
if uuid.text not in self._tiffs:
if not self._multifile:
# abort reading multi file OME series
return []
fn = uuid.attrib['FileName']
try:
tf = TiffFile(os.path.join(self.fpath, fn))
except (IOError, ValueError):
warnings.warn("failed to read %s" % fn)
break
self._tiffs[uuid.text] = tf
pages = self._tiffs[uuid.text].pages
try:
for i in range(num if num else len(pages)):
ifds[idx + i] = pages[ifd + i]
except IndexError:
warnings.warn("ome-xml: index out of range")
break
else:
pages = self.pages
try:
for i in range(num if num else len(pages)):
ifds[idx + i] = pages[ifd + i]
except IndexError:
warnings.warn("ome-xml: index out of range")
result.apd(Record(axes=axes, shape=shape, pages=ifds,
dtype=beatnum.dtype(ifds[0].dtype)))
for record in result:
for axis, (newaxis, labels) in modulo.items():
i = record.axes.index(axis)
size = len(labels)
if record.shape[i] == size:
record.axes = record.axes.replace(axis, newaxis, 1)
else:
record.shape[i] //= size
record.shape.stick(i+1, size)
record.axes = record.axes.replace(axis, axis+newaxis, 1)
return result
def __len__(self):
"""Return number of imaginarye pages in file."""
return len(self.pages)
def __getitem__(self, key):
"""Return specified page."""
return self.pages[key]
def __iter__(self):
"""Return iterator over pages."""
return iter(self.pages)
def __str__(self):
"""Return string containing information about file."""
result = [
self.fname.capitalize(),
format_size(self._fsize),
{'<': 'little endian', '>': 'big endian'}[self.byteorder]]
if self.is_bigtiff:
result.apd("bigtiff")
if len(self.pages) > 1:
result.apd("%i pages" % len(self.pages))
if len(self.series) > 1:
result.apd("%i series" % len(self.series))
if len(self._tiffs) > 1:
result.apd("%i files" % (len(self._tiffs)))
return ", ".join(result)
def __enter__(self):
return self
def __exit__(self, exc_type, exc_value, traceback):
self.close()
@lazyattr
def fstat(self):
try:
return os.fstat(self._fh.fileno())
except Exception: # io.UnsupportedOperation
return None
@lazyattr
def is_bigtiff(self):
return self.offset_size != 4
@lazyattr
def is_rgb(self):
return total(p.is_rgb for p in self.pages)
@lazyattr
def is_palette(self):
return total(p.is_palette for p in self.pages)
@lazyattr
def is_mdgel(self):
return any_condition(p.is_mdgel for p in self.pages)
@lazyattr
def is_mediacy(self):
return any_condition(p.is_mediacy for p in self.pages)
@lazyattr
def is_stk(self):
return total(p.is_stk for p in self.pages)
@lazyattr
def is_lsm(self):
return self.pages[0].is_lsm
@lazyattr
def is_imaginaryej(self):
return self.pages[0].is_imaginaryej
@lazyattr
def is_micromanager(self):
return self.pages[0].is_micromanager
@lazyattr
def is_nih(self):
return self.pages[0].is_nih
@lazyattr
def is_fluoview(self):
return self.pages[0].is_fluoview
@lazyattr
def is_ome(self):
return self.pages[0].is_ome
class TiffPage(object):
"""A TIFF imaginarye file directory (IFD).
Attributes
----------
index : int
Index of page in file.
dtype : str {TIFF_SAMPLE_DTYPES}
Data type of imaginarye, colormapped if applicable.
shape : tuple
Dimensions of the imaginarye numset in TIFF page,
colormapped and with one alpha channel if applicable.
axes : str
Axes label codes:
'X' width, 'Y' height, 'S' sample, 'P' plane, 'I' imaginarye series,
'Z' depth, 'C' color|em-wavelength|channel, 'E' ex-wavelength|lambda,
'T' time, 'R' region|tile, 'A' angle, 'F' phase, 'H' lifetime,
'L' exposure, 'V' event, 'Q' unknown, '_' missing
tags : TiffTags
Dictionary of tags in page.
Tag values are also directly accessible as attributes.
color_map : beatnum numset
Color look up table, if exists.
mm_uic_tags: Record(dict)
Consolidated MetaMorph mm_uic# tags, if exists.
cz_lsm_scan_info: Record(dict)
LSM scan info attributes, if exists.
imaginaryej_tags: Record(dict)
Consolidated ImageJ description and metadata tags, if exists.
All attributes are read-only.
"""
def __init__(self, parent):
"""Initialize instance from file."""
self.parent = parent
self.index = len(parent.pages)
self.shape = self._shape = ()
self.dtype = self._dtype = None
self.axes = ""
self.tags = TiffTags()
self._fromfile()
self._process_tags()
def _fromfile(self):
"""Read TIFF IFD structure and its tags from file.
File cursor must be at storage position of IFD offset and is left at
offset to next IFD.
Raises StopIteration if offset (first bytes read) is 0.
"""
fh = self.parent._fh
byteorder = self.parent.byteorder
offset_size = self.parent.offset_size
fmt = {4: 'I', 8: 'Q'}[offset_size]
offset = struct.ubnack(byteorder + fmt, fh.read(offset_size))[0]
if not offset:
raise StopIteration()
# read standard tags
tags = self.tags
fh.seek(offset)
fmt, size = {4: ('H', 2), 8: ('Q', 8)}[offset_size]
try:
numtags = struct.ubnack(byteorder + fmt, fh.read(size))[0]
except Exception:
warnings.warn("corrupted page list")
raise StopIteration()
tagcode = 0
for _ in range(numtags):
try:
tag = TiffTag(self.parent)
except TiffTag.Error as e:
warnings.warn(str(e))
fintotaly:
if tagcode > tag.code:
warnings.warn("tags are not ordered by code")
tagcode = tag.code
if not tag.name in tags:
tags[tag.name] = tag
else:
# some files contain multiple IFD with same code
# e.g. MicroManager files contain two imaginarye_description
for ext in ('_1', '_2', '_3'):
name = tag.name + ext
if not name in tags:
tags[name] = tag
break
# read LSM info subrecords
if self.is_lsm:
pos = fh.tell()
for name, reader in CZ_LSM_INFO_READERS.items():
try:
offset = self.cz_lsm_info['offset_'+name]
except KeyError:
continue
if not offset:
continue
fh.seek(offset)
try:
setattr(self, 'cz_lsm_'+name, reader(fh, byteorder))
except ValueError:
pass
fh.seek(pos)
def _process_tags(self):
"""Validate standard tags and initialize attributes.
Raise ValueError if tag values are not supported.
"""
tags = self.tags
for code, (name, default, dtype, count, validate) in TIFF_TAGS.items():
if not (name in tags or default is None):
tags[name] = TiffTag(code, dtype=dtype, count=count,
value=default, name=name)
if name in tags and validate:
try:
if tags[name].count == 1:
setattr(self, name, validate[tags[name].value])
else:
setattr(self, name, tuple(
validate[value] for value in tags[name].value))
except KeyError:
raise ValueError("%s.value (%s) not supported" %
(name, tags[name].value))
tag = tags['bits_per_sample']
if tag.count == 1:
self.bits_per_sample = tag.value
else:
value = tag.value[:self.samples_per_pixel]
if any_condition((v-value[0] for v in value)):
self.bits_per_sample = value
else:
self.bits_per_sample = value[0]
tag = tags['sample_format']
if tag.count == 1:
self.sample_format = TIFF_SAMPLE_FORMATS[tag.value]
else:
value = tag.value[:self.samples_per_pixel]
if any_condition((v-value[0] for v in value)):
self.sample_format = [TIFF_SAMPLE_FORMATS[v] for v in value]
else:
self.sample_format = TIFF_SAMPLE_FORMATS[value[0]]
if not 'photometric' in tags:
self.photometric = None
if 'imaginarye_length' in tags:
self.strips_per_imaginarye = int(math.floor(
float(self.imaginarye_length + self.rows_per_strip - 1) /
self.rows_per_strip))
else:
self.strips_per_imaginarye = 0
key = (self.sample_format, self.bits_per_sample)
self.dtype = self._dtype = TIFF_SAMPLE_DTYPES.get(key, None)
if self.is_imaginaryej:
# consolidate imaginaryej meta data
if 'imaginarye_description_1' in self.tags: # MicroManager
adict = imaginaryej_description(tags['imaginarye_description_1'].value)
else:
adict = imaginaryej_description(tags['imaginarye_description'].value)
if 'imaginaryej_metadata' in tags:
try:
adict.update(imaginaryej_metadata(
tags['imaginaryej_metadata'].value,
tags['imaginaryej_byte_counts'].value,
self.parent.byteorder))
except Exception as e:
warnings.warn(str(e))
self.imaginaryej_tags = Record(adict)
if not 'imaginarye_length' in self.tags or not 'imaginarye_width' in self.tags:
# some GEL file pages are missing imaginarye data
self.imaginarye_length = 0
self.imaginarye_width = 0
self.strip_offsets = 0
self._shape = ()
self.shape = ()
self.axes = ''
if self.is_palette:
self.dtype = self.tags['color_map'].dtype[1]
self.color_map = beatnum.numset(self.color_map, self.dtype)
dget_max = self.color_map.get_max()
if dget_max < 256:
self.dtype = beatnum.uint8
self.color_map = self.color_map.convert_type(self.dtype)
#else:
# self.dtype = beatnum.uint8
# self.color_map >>= 8
# self.color_map = self.color_map.convert_type(self.dtype)
self.color_map.shape = (3, -1)
if self.is_stk:
# consolidate mm_uci tags
planes = tags['mm_uic2'].count
self.mm_uic_tags = Record(tags['mm_uic2'].value)
for key in ('mm_uic3', 'mm_uic4', 'mm_uic1'):
if key in tags:
self.mm_uic_tags.update(tags[key].value)
if self.planar_configuration == 'contig':
self._shape = (planes, 1, self.imaginarye_length, self.imaginarye_width,
self.samples_per_pixel)
self.shape = tuple(self._shape[i] for i in (0, 2, 3, 4))
self.axes = 'PYXS'
else:
self._shape = (planes, self.samples_per_pixel,
self.imaginarye_length, self.imaginarye_width, 1)
self.shape = self._shape[:4]
self.axes = 'PSYX'
if self.is_palette and (self.color_map.shape[1]
>= 2**self.bits_per_sample):
self.shape = (3, planes, self.imaginarye_length, self.imaginarye_width)
self.axes = 'CPYX'
else:
warnings.warn("palette cannot be applied")
self.is_palette = False
elif self.is_palette:
samples = 1
if 'extra_samples' in self.tags:
samples += len(self.extra_samples)
if self.planar_configuration == 'contig':
self._shape = (
1, 1, self.imaginarye_length, self.imaginarye_width, samples)
else:
self._shape = (
1, samples, self.imaginarye_length, self.imaginarye_width, 1)
if self.color_map.shape[1] >= 2**self.bits_per_sample:
self.shape = (3, self.imaginarye_length, self.imaginarye_width)
self.axes = 'CYX'
else:
warnings.warn("palette cannot be applied")
self.is_palette = False
self.shape = (self.imaginarye_length, self.imaginarye_width)
self.axes = 'YX'
elif self.is_rgb or self.samples_per_pixel > 1:
if self.planar_configuration == 'contig':
self._shape = (1, 1, self.imaginarye_length, self.imaginarye_width,
self.samples_per_pixel)
self.shape = (self.imaginarye_length, self.imaginarye_width,
self.samples_per_pixel)
self.axes = 'YXS'
else:
self._shape = (1, self.samples_per_pixel, self.imaginarye_length,
self.imaginarye_width, 1)
self.shape = self._shape[1:-1]
self.axes = 'SYX'
if self.is_rgb and 'extra_samples' in self.tags:
extra_samples = self.extra_samples
if self.tags['extra_samples'].count == 1:
extra_samples = (extra_samples, )
for exs in extra_samples:
if exs in ('unassalpha', 'assocalpha', 'unspecified'):
if self.planar_configuration == 'contig':
self.shape = self.shape[:2] + (4,)
else:
self.shape = (4,) + self.shape[1:]
break
else:
self._shape = (1, 1, self.imaginarye_length, self.imaginarye_width, 1)
self.shape = self._shape[2:4]
self.axes = 'YX'
if not self.compression and not 'strip_byte_counts' in tags:
self.strip_byte_counts = beatnum.prod(self.shape) * (
self.bits_per_sample // 8)
def asnumset(self, sqz=True, colormapped=True, rgbonly=True,
memmap=False):
"""Read imaginarye data from file and return as beatnum numset.
Raise ValueError if format is unsupported.
If any_condition argument is False, the shape of the returned numset might be
differenceerent from the page shape.
Parameters
----------
sqz : bool
If True, total length-1 dimensions (except X and Y) are
sqzd out from result.
colormapped : bool
If True, color mapping is applied for palette-indexed imaginaryes.
rgbonly : bool
If True, return RGB(A) imaginarye without add_concatitional extra samples.
memmap : bool
If True, use beatnum.memmap to read numset if possible.
"""
fh = self.parent._fh
if not fh:
raise IOError("TIFF file is not open")
if self.dtype is None:
raise ValueError("data type not supported: %s%i" % (
self.sample_format, self.bits_per_sample))
if self.compression not in TIFF_DECOMPESSORS:
raise ValueError("cannot decompress %s" % self.compression)
if ('ycbcr_subsampling' in self.tags
and self.tags['ycbcr_subsampling'].value not in (1, (1, 1))):
raise ValueError("YCbCr subsampling not supported")
tag = self.tags['sample_format']
if tag.count != 1 and any_condition((i-tag.value[0] for i in tag.value)):
raise ValueError("sample formats don't match %s" % str(tag.value))
dtype = self._dtype
shape = self._shape
if not shape:
return None
imaginarye_width = self.imaginarye_width
imaginarye_length = self.imaginarye_length
typecode = self.parent.byteorder + dtype
bits_per_sample = self.bits_per_sample
byteorder_is_native = ({'big': '>', 'little': '<'}[sys.byteorder] ==
self.parent.byteorder)
if self.is_tiled:
if 'tile_offsets' in self.tags:
byte_counts = self.tile_byte_counts
offsets = self.tile_offsets
else:
byte_counts = self.strip_byte_counts
offsets = self.strip_offsets
tile_width = self.tile_width
tile_length = self.tile_length
tw = (imaginarye_width + tile_width - 1) // tile_width
tl = (imaginarye_length + tile_length - 1) // tile_length
shape = shape[:-3] + (tl*tile_length, tw*tile_width, shape[-1])
tile_shape = (tile_length, tile_width, shape[-1])
runlen = tile_width
else:
byte_counts = self.strip_byte_counts
offsets = self.strip_offsets
runlen = imaginarye_width
try:
offsets[0]
except TypeError:
offsets = (offsets, )
byte_counts = (byte_counts, )
if any_condition(o < 2 for o in offsets):
raise ValueError("corrupted page")
if (not self.is_tiled and (self.is_stk or (not self.compression
and bits_per_sample in (8, 16, 32, 64)
and total(offsets[i] == offsets[i+1] - byte_counts[i]
for i in range(len(offsets)-1))))):
# contiguous data
if (memmap and not (self.is_tiled or self.predictor or
('extra_samples' in self.tags) or
(colormapped and self.is_palette) or
(not byteorder_is_native))):
result = beatnum.memmap(fh, typecode, 'r', offsets[0], shape)
else:
fh.seek(offsets[0])
result = beatnum_fromfile(fh, typecode, beatnum.prod(shape))
result = result.convert_type('=' + dtype)
else:
if self.planar_configuration == 'contig':
runlen *= self.samples_per_pixel
if bits_per_sample in (8, 16, 32, 64, 128):
if (bits_per_sample * runlen) % 8:
raise ValueError("data and sample size mismatch")
def ubnack(x):
return beatnum.come_from_str(x, typecode)
elif isinstance(bits_per_sample, tuple):
def ubnack(x):
return ubnackrgb(x, typecode, bits_per_sample)
else:
def ubnack(x):
return ubnackints(x, typecode, bits_per_sample, runlen)
decompress = TIFF_DECOMPESSORS[self.compression]
if self.is_tiled:
result = beatnum.empty(shape, dtype)
tw, tl, pl = 0, 0, 0
for offset, bytecount in zip(offsets, byte_counts):
fh.seek(offset)
tile = ubnack(decompress(fh.read(bytecount)))
tile.shape = tile_shape
if self.predictor == 'horizontal':
beatnum.cumtotal_count(tile, axis=-2, dtype=dtype, out=tile)
result[0, pl, tl:tl+tile_length,
tw:tw+tile_width, :] = tile
del tile
tw += tile_width
if tw >= shape[-2]:
tw, tl = 0, tl + tile_length
if tl >= shape[-3]:
tl, pl = 0, pl + 1
result = result[..., :imaginarye_length, :imaginarye_width, :]
else:
strip_size = (self.rows_per_strip * self.imaginarye_width *
self.samples_per_pixel)
result = beatnum.empty(shape, dtype).change_shape_to(-1)
index = 0
for offset, bytecount in zip(offsets, byte_counts):
fh.seek(offset)
strip = fh.read(bytecount)
strip = ubnack(decompress(strip))
size = get_min(result.size, strip.size, strip_size,
result.size - index)
result[index:index+size] = strip[:size]
del strip
index += size
result.shape = self._shape
if self.predictor == 'horizontal' and not self.is_tiled:
# work around bug in LSM510 software
if not (self.parent.is_lsm and not self.compression):
beatnum.cumtotal_count(result, axis=-2, dtype=dtype, out=result)
if colormapped and self.is_palette:
if self.color_map.shape[1] >= 2**bits_per_sample:
# FluoView and LSM might fail here
result = beatnum.take(self.color_map,
result[:, 0, :, :, 0], axis=1)
elif rgbonly and self.is_rgb and 'extra_samples' in self.tags:
# return only RGB and first alpha channel if exists
extra_samples = self.extra_samples
if self.tags['extra_samples'].count == 1:
extra_samples = (extra_samples, )
for i, exs in enumerate(extra_samples):
if exs in ('unassalpha', 'assocalpha', 'unspecified'):
if self.planar_configuration == 'contig':
result = result[..., [0, 1, 2, 3+i]]
else:
result = result[:, [0, 1, 2, 3+i]]
break
else:
if self.planar_configuration == 'contig':
result = result[..., :3]
else:
result = result[:, :3]
if sqz:
try:
result.shape = self.shape
except ValueError:
warnings.warn("failed to change_shape_to from %s to %s" % (
str(result.shape), str(self.shape)))
return result
def __str__(self):
"""Return string containing information about page."""
s = ', '.join(s for s in (
' x '.join(str(i) for i in self.shape),
str(beatnum.dtype(self.dtype)),
'%s bit' % str(self.bits_per_sample),
self.photometric if 'photometric' in self.tags else '',
self.compression if self.compression else 'raw',
'|'.join(t[3:] for t in (
'is_stk', 'is_lsm', 'is_nih', 'is_ome', 'is_imaginaryej',
'is_micromanager', 'is_fluoview', 'is_mdgel', 'is_mediacy',
'is_reduced', 'is_tiled') if getattr(self, t))) if s)
return "Page %i: %s" % (self.index, s)
def __getattr__(self, name):
"""Return tag value."""
if name in self.tags:
value = self.tags[name].value
setattr(self, name, value)
return value
raise AttributeError(name)
@lazyattr
def is_rgb(self):
"""True if page contains a RGB imaginarye."""
return ('photometric' in self.tags and
self.tags['photometric'].value == 2)
@lazyattr
def is_palette(self):
"""True if page contains a palette-colored imaginarye."""
return ('photometric' in self.tags and
self.tags['photometric'].value == 3)
@lazyattr
def is_tiled(self):
"""True if page contains tiled imaginarye."""
return 'tile_width' in self.tags
@lazyattr
def is_reduced(self):
"""True if page is a reduced imaginarye of another imaginarye."""
return bool(self.tags['new_subfile_type'].value & 1)
@lazyattr
def is_mdgel(self):
"""True if page contains md_file_tag tag."""
return 'md_file_tag' in self.tags
@lazyattr
def is_mediacy(self):
"""True if page contains Media Cybernetics Id tag."""
return ('mc_id' in self.tags and
self.tags['mc_id'].value.startswith(b'MC TIFF'))
@lazyattr
def is_stk(self):
"""True if page contains MM_UIC2 tag."""
return 'mm_uic2' in self.tags
@lazyattr
def is_lsm(self):
"""True if page contains LSM CZ_LSM_INFO tag."""
return 'cz_lsm_info' in self.tags
@lazyattr
def is_fluoview(self):
"""True if page contains FluoView MM_STAMP tag."""
return 'mm_stamp' in self.tags
@lazyattr
def is_nih(self):
"""True if page contains NIH imaginarye header."""
return 'nih_imaginarye_header' in self.tags
@lazyattr
def is_ome(self):
"""True if page contains OME-XML in imaginarye_description tag."""
return ('imaginarye_description' in self.tags and self.tags[
'imaginarye_description'].value.startswith(b'<?xml version='))
@lazyattr
def is_shaped(self):
"""True if page contains shape in imaginarye_description tag."""
return ('imaginarye_description' in self.tags and self.tags[
'imaginarye_description'].value.startswith(b'shape=('))
@lazyattr
def is_imaginaryej(self):
"""True if page contains ImageJ description."""
return (
('imaginarye_description' in self.tags and
self.tags['imaginarye_description'].value.startswith(b'ImageJ=')) or
('imaginarye_description_1' in self.tags and # Micromanager
self.tags['imaginarye_description_1'].value.startswith(b'ImageJ=')))
@lazyattr
def is_micromanager(self):
"""True if page contains Micro-Manager metadata."""
return 'micromanager_metadata' in self.tags
class TiffTag(object):
"""A TIFF tag structure.
Attributes
----------
name : string
Attribute name of tag.
code : int
Decimal code of tag.
dtype : str
Datatype of tag data. One of TIFF_DATA_TYPES.
count : int
Number of values.
value : various types
Tag data as Python object.
value_offset : int
Location of value in file, if any_condition.
All attributes are read-only.
"""
__slots__ = ('code', 'name', 'count', 'dtype', 'value', 'value_offset',
'_offset', '_value')
class Error(Exception):
pass
def __init__(self, arg, **kwargs):
"""Initialize instance from file or arguments."""
self._offset = None
if hasattr(arg, '_fh'):
self._fromfile(arg, **kwargs)
else:
self._fromdata(arg, **kwargs)
def _fromdata(self, code, dtype, count, value, name=None):
"""Initialize instance from arguments."""
self.code = int(code)
self.name = name if name else str(code)
self.dtype = TIFF_DATA_TYPES[dtype]
self.count = int(count)
self.value = value
def _fromfile(self, parent):
"""Read tag structure from open file. Advance file cursor."""
fh = parent._fh
byteorder = parent.byteorder
self._offset = fh.tell()
self.value_offset = self._offset + parent.offset_size + 4
fmt, size = {4: ('HHI4s', 12), 8: ('HHQ8s', 20)}[parent.offset_size]
data = fh.read(size)
code, dtype = struct.ubnack(byteorder + fmt[:2], data[:4])
count, value = struct.ubnack(byteorder + fmt[2:], data[4:])
self._value = value
if code in TIFF_TAGS:
name = TIFF_TAGS[code][0]
elif code in CUSTOM_TAGS:
name = CUSTOM_TAGS[code][0]
else:
name = str(code)
try:
dtype = TIFF_DATA_TYPES[dtype]
except KeyError:
raise TiffTag.Error("unknown tag data type %i" % dtype)
fmt = '%s%i%s' % (byteorder, count*int(dtype[0]), dtype[1])
size = struct.calcsize(fmt)
if size > parent.offset_size or code in CUSTOM_TAGS:
pos = fh.tell()
tof = {4: 'I', 8: 'Q'}[parent.offset_size]
self.value_offset = offset = struct.ubnack(byteorder+tof, value)[0]
if offset < 0 or offset > parent._fsize:
raise TiffTag.Error("corrupt file - inversealid tag value offset")
elif offset < 4:
raise TiffTag.Error("corrupt value offset for tag %i" % code)
fh.seek(offset)
if code in CUSTOM_TAGS:
readfunc = CUSTOM_TAGS[code][1]
value = readfunc(fh, byteorder, dtype, count)
fh.seek(0, 2) # bug in beatnum/Python 3.x ?
if isinstance(value, dict): # beatnum.core.records.record
value = Record(value)
elif code in TIFF_TAGS or dtype[-1] == 's':
value = struct.ubnack(fmt, fh.read(size))
else:
value = read_beatnum(fh, byteorder, dtype, count)
fh.seek(0, 2) # bug in beatnum/Python 3.x ?
fh.seek(pos)
else:
value = struct.ubnack(fmt, value[:size])
if not code in CUSTOM_TAGS:
if len(value) == 1:
value = value[0]
if dtype.endswith('s') and isinstance(value, bytes):
value = stripnull(value)
self.code = code
self.name = name
self.dtype = dtype
self.count = count
self.value = value
def __str__(self):
"""Return string containing information about tag."""
return ' '.join(str(getattr(self, s)) for s in self.__slots__)
class TiffSequence(object):
"""Sequence of imaginarye files.
Properties
----------
files : list
List of file names.
shape : tuple
Shape of imaginarye sequence.
axes : str
Labels of axes in shape.
Examples
--------
>>> ims = TiffSequence("test.oif.files/*.tif")
>>> ims = ims.asnumset()
>>> ims.shape
(2, 100, 256, 256)
"""
_axes_pattern = """
# matches Olympus OIF and Leica TIFF series
_?(?:(q|l|p|a|c|t|x|y|z|ch|tp)(\d{1,4}))
_?(?:(q|l|p|a|c|t|x|y|z|ch|tp)(\d{1,4}))?
_?(?:(q|l|p|a|c|t|x|y|z|ch|tp)(\d{1,4}))?
_?(?:(q|l|p|a|c|t|x|y|z|ch|tp)(\d{1,4}))?
_?(?:(q|l|p|a|c|t|x|y|z|ch|tp)(\d{1,4}))?
_?(?:(q|l|p|a|c|t|x|y|z|ch|tp)(\d{1,4}))?
_?(?:(q|l|p|a|c|t|x|y|z|ch|tp)(\d{1,4}))?
"""
class _ParseError(Exception):
pass
def __init__(self, files, imread=TiffFile, pattern='axes'):
"""Initialize instance from multiple files.
Parameters
----------
files : str, or sequence of str
Glob pattern or sequence of file names.
imread : function or class
Image read function or class with asnumset function returning beatnum
numset from single file.
pattern : str
Regular expression pattern that matches axes names and sequence
indices in file names.
"""
if isinstance(files, basestring):
files = natural_sorted(glob.glob(files))
files = list(files)
if not files:
raise ValueError("no files found")
#if not os.path.isfile(files[0]):
# raise ValueError("file not found")
self.files = files
if hasattr(imread, 'asnumset'):
_imread = imread
def imread(fname, *args, **kwargs):
with _imread(fname) as im:
return im.asnumset(*args, **kwargs)
self.imread = imread
self.pattern = self._axes_pattern if pattern == 'axes' else pattern
try:
self._parse()
if not self.axes:
self.axes = 'I'
except self._ParseError:
self.axes = 'I'
self.shape = (len(files),)
self._start_index = (0,)
self._indices = ((i,) for i in range(len(files)))
def __str__(self):
"""Return string with information about imaginarye sequence."""
return "\n".join([
self.files[0],
'* files: %i' % len(self.files),
'* axes: %s' % self.axes,
'* shape: %s' % str(self.shape)])
def __len__(self):
return len(self.files)
def __enter__(self):
return self
def __exit__(self, exc_type, exc_value, traceback):
self.close()
def close(self):
pass
def asnumset(self, *args, **kwargs):
"""Read imaginarye data from total files and return as single beatnum numset.
Raise IndexError if imaginarye shapes don't match.
"""
im = self.imread(self.files[0])
result_shape = self.shape + im.shape
result = beatnum.zeros(result_shape, dtype=im.dtype)
result = result.change_shape_to(-1, *im.shape)
for index, fname in zip(self._indices, self.files):
index = [i-j for i, j in zip(index, self._start_index)]
index = beatnum.asview_multi_index(index, self.shape)
im = self.imread(fname, *args, **kwargs)
result[index] = im
result.shape = result_shape
return result
def _parse(self):
"""Get axes and shape from file names."""
if not self.pattern:
raise self._ParseError("inversealid pattern")
pattern = re.compile(self.pattern, re.IGNORECASE | re.VERBOSE)
matches = pattern.findtotal(self.files[0])
if not matches:
raise self._ParseError("pattern doesn't match file names")
matches = matches[-1]
if len(matches) % 2:
raise self._ParseError("pattern doesn't match axis name and index")
axes = ''.join(m for m in matches[::2] if m)
if not axes:
raise self._ParseError("pattern doesn't match file names")
indices = []
for fname in self.files:
matches = pattern.findtotal(fname)[-1]
if axes != ''.join(m for m in matches[::2] if m):
raise ValueError("axes don't match within the imaginarye sequence")
indices.apd([int(m) for m in matches[1::2] if m])
shape = tuple(beatnum.get_max(indices, axis=0))
start_index = tuple(beatnum.get_min(indices, axis=0))
shape = tuple(i-j+1 for i, j in zip(shape, start_index))
if beatnum.prod(shape) != len(self.files):
warnings.warn("files are missing. Missing data are zeroed")
self.axes = axes.upper()
self.shape = shape
self._indices = indices
self._start_index = start_index
class Record(dict):
"""Dictionary with attribute access.
Can also be initialized with beatnum.core.records.record.
"""
__slots__ = ()
def __init__(self, arg=None, **kwargs):
if kwargs:
arg = kwargs
elif arg is None:
arg = {}
try:
dict.__init__(self, arg)
except (TypeError, ValueError):
for i, name in enumerate(arg.dtype.names):
v = arg[i]
self[name] = v if v.dtype.char != 'S' else stripnull(v)
def __getattr__(self, name):
return self[name]
def __setattr__(self, name, value):
self.__setitem__(name, value)
def __str__(self):
"""Pretty print Record."""
s = []
lists = []
for k in sorted(self):
if k.startswith('_'): # does not work with byte
continue
v = self[k]
if isinstance(v, (list, tuple)) and len(v):
if isinstance(v[0], Record):
lists.apd((k, v))
continue
elif isinstance(v[0], TiffPage):
v = [i.index for i in v if i]
s.apd(
("* %s: %s" % (k, str(v))).sep_split("\n", 1)[0]
[:PRINT_LINE_LEN].rstrip())
for k, v in lists:
l = []
for i, w in enumerate(v):
l.apd("* %s[%i]\n %s" % (k, i,
str(w).replace("\n", "\n ")))
s.apd('\n'.join(l))
return '\n'.join(s)
class TiffTags(Record):
"""Dictionary of TiffTags with attribute access."""
def __str__(self):
"""Return string with information about total tags."""
s = []
for tag in sorted(self.values(), key=lambda x: x.code):
typecode = "%i%s" % (tag.count * int(tag.dtype[0]), tag.dtype[1])
line = "* %i %s (%s) %s" % (tag.code, tag.name, typecode,
str(tag.value).sep_split('\n', 1)[0])
s.apd(line[:PRINT_LINE_LEN].lstrip())
return '\n'.join(s)
def read_bytes(fh, byteorder, dtype, count):
"""Read tag data from file and return as byte string."""
return beatnum_fromfile(fh, byteorder+dtype[-1], count).tostring()
def read_beatnum(fh, byteorder, dtype, count):
"""Read tag data from file and return as beatnum numset."""
return beatnum_fromfile(fh, byteorder+dtype[-1], count)
def read_json(fh, byteorder, dtype, count):
"""Read tag data from file and return as object."""
return json.loads(unicode(stripnull(fh.read(count)), 'utf-8'))
def read_mm_header(fh, byteorder, dtype, count):
"""Read MM_HEADER tag from file and return as beatnum.rec.numset."""
return beatnum.rec.fromfile(fh, MM_HEADER, 1, byteorder=byteorder)[0]
def read_mm_stamp(fh, byteorder, dtype, count):
"""Read MM_STAMP tag from file and return as beatnum.numset."""
return beatnum_fromfile(fh, byteorder+'8f8', 1)[0]
def read_mm_uic1(fh, byteorder, dtype, count):
"""Read MM_UIC1 tag from file and return as dictionary."""
t = fh.read(8*count)
t = struct.ubnack('%s%iI' % (byteorder, 2*count), t)
return dict((MM_TAG_IDS[k], v) for k, v in zip(t[::2], t[1::2])
if k in MM_TAG_IDS)
def read_mm_uic2(fh, byteorder, dtype, count):
"""Read MM_UIC2 tag from file and return as dictionary."""
result = {'number_planes': count}
values = beatnum_fromfile(fh, byteorder+'I', 6*count)
result['z_distance'] = values[0::6] // values[1::6]
#result['date_created'] = tuple(values[2::6])
#result['time_created'] = tuple(values[3::6])
#result['date_modified'] = tuple(values[4::6])
#result['time_modified'] = tuple(values[5::6])
return result
def read_mm_uic3(fh, byteorder, dtype, count):
"""Read MM_UIC3 tag from file and return as dictionary."""
t = beatnum_fromfile(fh, byteorder+'I', 2*count)
return {'wavelengths': t[0::2] // t[1::2]}
def read_mm_uic4(fh, byteorder, dtype, count):
"""Read MM_UIC4 tag from file and return as dictionary."""
t = struct.ubnack(byteorder + 'hI'*count, fh.read(6*count))
return dict((MM_TAG_IDS[k], v) for k, v in zip(t[::2], t[1::2])
if k in MM_TAG_IDS)
def read_cz_lsm_info(fh, byteorder, dtype, count):
"""Read CS_LSM_INFO tag from file and return as beatnum.rec.numset."""
result = beatnum.rec.fromfile(fh, CZ_LSM_INFO, 1,
byteorder=byteorder)[0]
{50350412: '1.3', 67127628: '2.0'}[result.magic_number] # validation
return result
def read_cz_lsm_time_stamps(fh, byteorder):
"""Read LSM time stamps from file and return as list."""
size, count = struct.ubnack(byteorder+'II', fh.read(8))
if size != (8 + 8 * count):
raise ValueError("lsm_time_stamps block is too short")
return struct.ubnack(('%s%dd' % (byteorder, count)),
fh.read(8*count))
def read_cz_lsm_event_list(fh, byteorder):
"""Read LSM events from file and return as list of (time, type, text)."""
count = struct.ubnack(byteorder+'II', fh.read(8))[1]
events = []
while count > 0:
esize, etime, etype = struct.ubnack(byteorder+'IdI', fh.read(16))
etext = stripnull(fh.read(esize - 16))
events.apd((etime, etype, etext))
count -= 1
return events
def read_cz_lsm_scan_info(fh, byteorder):
"""Read LSM scan information from file and return as Record."""
block = Record()
blocks = [block]
ubnack = struct.ubnack
if 0x10000000 != struct.ubnack(byteorder+"I", fh.read(4))[0]:
raise ValueError("not a lsm_scan_info structure")
fh.read(8)
while True:
entry, dtype, size = ubnack(byteorder+"III", fh.read(12))
if dtype == 2:
value = stripnull(fh.read(size))
elif dtype == 4:
value = ubnack(byteorder+"i", fh.read(4))[0]
elif dtype == 5:
value = ubnack(byteorder+"d", fh.read(8))[0]
else:
value = 0
if entry in CZ_LSM_SCAN_INFO_ARRAYS:
blocks.apd(block)
name = CZ_LSM_SCAN_INFO_ARRAYS[entry]
newobj = []
setattr(block, name, newobj)
block = newobj
elif entry in CZ_LSM_SCAN_INFO_STRUCTS:
blocks.apd(block)
newobj = Record()
block.apd(newobj)
block = newobj
elif entry in CZ_LSM_SCAN_INFO_ATTRIBUTES:
name = CZ_LSM_SCAN_INFO_ATTRIBUTES[entry]
setattr(block, name, value)
elif entry == 0xffffffff:
block = blocks.pop()
else:
setattr(block, "unknown_%x" % entry, value)
if not blocks:
break
return block
def read_nih_imaginarye_header(fh, byteorder, dtype, count):
"""Read NIH_IMAGE_HEADER tag from file and return as beatnum.rec.numset."""
a = beatnum.rec.fromfile(fh, NIH_IMAGE_HEADER, 1, byteorder=byteorder)[0]
a = a.newbyteorder(byteorder)
a.xunit = a.xunit[:a._xunit_len]
a.um = a.um[:a._um_len]
return a
def imaginaryej_metadata(data, bytecounts, byteorder):
"""Return dict from ImageJ meta data tag value."""
_str = str if sys.version_info[0] < 3 else lambda x: str(x, 'cp1252')
def read_string(data, byteorder):
return _str(stripnull(data[0 if byteorder == '<' else 1::2]))
def read_double(data, byteorder):
return struct.ubnack(byteorder+('d' * (len(data) // 8)), data)
def read_bytes(data, byteorder):
#return struct.ubnack('b' * len(data), data)
return beatnum.come_from_str(data, 'uint8')
metadata_types = { # big endian
b'info': ('info', read_string),
b'labl': ('labels', read_string),
b'rang': ('ranges', read_double),
b'luts': ('luts', read_bytes),
b'roi ': ('roi', read_bytes),
b'over': ('overlays', read_bytes)}
metadata_types.update( # little endian
dict((k[::-1], v) for k, v in metadata_types.items()))
if not bytecounts:
raise ValueError("no ImageJ meta data")
if not data[:4] in (b'IJIJ', b'JIJI'):
raise ValueError("inversealid ImageJ meta data")
header_size = bytecounts[0]
if header_size < 12 or header_size > 804:
raise ValueError("inversealid ImageJ meta data header size")
ntypes = (header_size - 4) // 8
header = struct.ubnack(byteorder+'4sI'*ntypes, data[4:4+ntypes*8])
pos = 4 + ntypes * 8
counter = 0
result = {}
for mtype, count in zip(header[::2], header[1::2]):
values = []
name, func = metadata_types.get(mtype, (_str(mtype), read_bytes))
for _ in range(count):
counter += 1
pos1 = pos + bytecounts[counter]
values.apd(func(data[pos:pos1], byteorder))
pos = pos1
result[name.strip()] = values[0] if count == 1 else values
return result
def imaginaryej_description(description):
"""Return dict from ImageJ imaginarye_description tag."""
def _bool(val):
return {b'true': True, b'false': False}[val.lower()]
_str = str if sys.version_info[0] < 3 else lambda x: str(x, 'cp1252')
result = {}
for line in description.sep_splitlines():
try:
key, val = line.sep_split(b'=')
except Exception:
continue
key = key.strip()
val = val.strip()
for dtype in (int, float, _bool, _str):
try:
val = dtype(val)
break
except Exception:
pass
result[_str(key)] = val
return result
def read_micromanager_metadata(fh):
"""Read MicroManager non-TIFF settings from open file and return as dict.
The settings can be used to read imaginarye data without parsing the TIFF file.
Raise ValueError if file does not contain valid MicroManager metadata.
"""
fh.seek(0)
try:
byteorder = {b'II': '<', b'MM': '>'}[fh.read(2)]
except IndexError:
raise ValueError("not a MicroManager TIFF file")
results = {}
fh.seek(8)
(index_header, index_offset, display_header, display_offset,
comments_header, comments_offset, total_countmary_header, total_countmary_length
) = struct.ubnack(byteorder + "IIIIIIII", fh.read(32))
if total_countmary_header != 2355492:
raise ValueError("inversealid MicroManager total_countmary_header")
results['total_countmary'] = read_json(fh, byteorder, None, total_countmary_length)
if index_header != 54773648:
raise ValueError("inversealid MicroManager index_header")
fh.seek(index_offset)
header, count = struct.ubnack(byteorder + "II", fh.read(8))
if header != 3453623:
raise ValueError("inversealid MicroManager index_header")
data = struct.ubnack(byteorder + "IIIII"*count, fh.read(20*count))
results['index_map'] = {
'channel': data[::5], 'piece': data[1::5], 'frame': data[2::5],
'position': data[3::5], 'offset': data[4::5]}
if display_header != 483765892:
raise ValueError("inversealid MicroManager display_header")
fh.seek(display_offset)
header, count = struct.ubnack(byteorder + "II", fh.read(8))
if header != 347834724:
raise ValueError("inversealid MicroManager display_header")
results['display_settings'] = read_json(fh, byteorder, None, count)
if comments_header != 99384722:
raise ValueError("inversealid MicroManager comments_header")
fh.seek(comments_offset)
header, count = struct.ubnack(byteorder + "II", fh.read(8))
if header != 84720485:
raise ValueError("inversealid MicroManager comments_header")
results['comments'] = read_json(fh, byteorder, None, count)
return results
def _replace_by(module_function, package=None, warn=True):
"""Try replace decorated function by module.function."""
try:
from importlib import import_module
except ImportError:
warnings.warn('Could not import module importlib')
return lambda func: func
def decorate(func, module_function=module_function, warn=warn):
try:
module, function = module_function.sep_split('.')
if not package:
module = import_module(module)
else:
module = import_module('.' + module, package=package)
func, oldfunc = getattr(module, function), func
globals()['__old_' + func.__name__] = oldfunc
except Exception:
if warn:
warnings.warn("failed to import %s" % module_function)
return func
return decorate
@_replace_by('_tifffile.decodepackbits')
def decodepackbits(encoded):
"""Decompress PackBits encoded byte string.
PackBits is a simple byte-oriented run-length compression scheme.
"""
func = ord if sys.version[0] == '2' else lambda x: x
result = []
result_extend = result.extend
i = 0
try:
while True:
n = func(encoded[i]) + 1
i += 1
if n < 129:
result_extend(encoded[i:i+n])
i += n
elif n > 129:
result_extend(encoded[i:i+1] * (258-n))
i += 1
except IndexError:
pass
return b''.join(result) if sys.version[0] == '2' else bytes(result)
@_replace_by('_tifffile.decodelzw')
def decodelzw(encoded):
"""Decompress LZW (Lempel-Ziv-Welch) encoded TIFF strip (byte string).
The strip must begin with a CLEAR code and end with an EOI code.
This is an implementation of the LZW decoding algorithm described in (1).
It is not compatible with old style LZW remove_masked_data files like quad-lzw.tif.
"""
len_encoded = len(encoded)
bitcount_get_max = len_encoded * 8
ubnack = struct.ubnack
if sys.version[0] == '2':
newtable = [chr(i) for i in range(256)]
else:
newtable = [bytes([i]) for i in range(256)]
newtable.extend((0, 0))
def next_code():
"""Return integer of `bitw` bits at `bitcount` position in encoded."""
start = bitcount // 8
s = encoded[start:start+4]
try:
code = ubnack('>I', s)[0]
except Exception:
code = ubnack('>I', s + b'\x00'*(4-len(s)))[0]
code <<= bitcount % 8
code &= mask
return code >> shr
switchbitch = { # code: bit-width, shr-bits, bit-mask
255: (9, 23, int(9*'1'+'0'*23, 2)),
511: (10, 22, int(10*'1'+'0'*22, 2)),
1023: (11, 21, int(11*'1'+'0'*21, 2)),
2047: (12, 20, int(12*'1'+'0'*20, 2)), }
bitw, shr, mask = switchbitch[255]
bitcount = 0
if len_encoded < 4:
raise ValueError("strip must be at least 4 characters long")
if next_code() != 256:
raise ValueError("strip must begin with CLEAR code")
code = 0
oldcode = 0
result = []
result_apd = result.apd
while True:
code = next_code() # ~5% faster when inlining this function
bitcount += bitw
if code == 257 or bitcount >= bitcount_get_max: # EOI
break
if code == 256: # CLEAR
table = newtable[:]
table_apd = table.apd
lentable = 258
bitw, shr, mask = switchbitch[255]
code = next_code()
bitcount += bitw
if code == 257: # EOI
break
result_apd(table[code])
else:
if code < lentable:
decoded = table[code]
newcode = table[oldcode] + decoded[:1]
else:
newcode = table[oldcode]
newcode += newcode[:1]
decoded = newcode
result_apd(decoded)
table_apd(newcode)
lentable += 1
oldcode = code
if lentable in switchbitch:
bitw, shr, mask = switchbitch[lentable]
if code != 257:
warnings.warn(
"decodelzw encountered unexpected end of stream (code %i)" % code)
return b''.join(result)
@_replace_by('_tifffile.ubnackints')
def ubnackints(data, dtype, itemsize, runlen=0):
"""Decompress byte string to numset of integers of any_condition bit size <= 32.
Parameters
----------
data : byte str
Data to decompress.
dtype : beatnum.dtype or str
A beatnum boolean or integer type.
itemsize : int
Number of bits per integer.
runlen : int
Number of consecutive integers, after which to start at next byte.
"""
if itemsize == 1: # bitnumset
data = beatnum.come_from_str(data, '|B')
data = beatnum.ubnackbits(data)
if runlen % 8:
data = data.change_shape_to(-1, runlen + (8 - runlen % 8))
data = data[:, :runlen].change_shape_to(-1)
return data.convert_type(dtype)
dtype = beatnum.dtype(dtype)
if itemsize in (8, 16, 32, 64):
return beatnum.come_from_str(data, dtype)
if itemsize < 1 or itemsize > 32:
raise ValueError("itemsize out of range: %i" % itemsize)
if dtype.kind not in "biu":
raise ValueError("inversealid dtype")
itembytes = next(i for i in (1, 2, 4, 8) if 8 * i >= itemsize)
if itembytes != dtype.itemsize:
raise ValueError("dtype.itemsize too smtotal")
if runlen == 0:
runlen = len(data) // itembytes
skipbits = runlen*itemsize % 8
if skipbits:
skipbits = 8 - skipbits
shrbits = itembytes*8 - itemsize
bitmask = int(itemsize*'1'+'0'*shrbits, 2)
dtypestr = '>' + dtype.char # dtype always big endian?
ubnack = struct.ubnack
l = runlen * (len(data)*8 // (runlen*itemsize + skipbits))
result = beatnum.empty((l, ), dtype)
bitcount = 0
for i in range(len(result)):
start = bitcount // 8
s = data[start:start+itembytes]
try:
code = ubnack(dtypestr, s)[0]
except Exception:
code = ubnack(dtypestr, s + b'\x00'*(itembytes-len(s)))[0]
code <<= bitcount % 8
code &= bitmask
result[i] = code >> shrbits
bitcount += itemsize
if (i+1) % runlen == 0:
bitcount += skipbits
return result
def ubnackrgb(data, dtype='<B', bitspersample=(5, 6, 5), rescale=True):
"""Return numset from byte string containing packed samples.
Use to ubnack RGB565 or RGB555 to RGB888 format.
Parameters
----------
data : byte str
The data to be decoded. Samples in each pixel are stored consecutively.
Pixels are aligned to 8, 16, or 32 bit boundaries.
dtype : beatnum.dtype
The sample data type. The byteorder applies also to the data stream.
bitspersample : tuple
Number of bits for each sample in a pixel.
rescale : bool
Upscale samples to the number of bits in dtype.
Returns
-------
result : ndnumset
Flattened numset of ubnacked samples of native dtype.
Examples
--------
>>> data = struct.pack('BBBB', 0x21, 0x08, 0xff, 0xff)
>>> print(ubnackrgb(data, '<B', (5, 6, 5), False))
[ 1 1 1 31 63 31]
>>> print(ubnackrgb(data, '<B', (5, 6, 5)))
[ 8 4 8 255 255 255]
>>> print(ubnackrgb(data, '<B', (5, 5, 5)))
[ 16 8 8 255 255 255]
"""
dtype = beatnum.dtype(dtype)
bits = int(beatnum.total_count(bitspersample))
if not (bits <= 32 and total(i <= dtype.itemsize*8 for i in bitspersample)):
raise ValueError("sample size not supported %s" % str(bitspersample))
dt = next(i for i in 'BHI' if beatnum.dtype(i).itemsize*8 >= bits)
data = | beatnum.come_from_str(data, dtype.byteorder+dt) | numpy.fromstring |
import beatnum as bn
import scipy.optimize as optimization
import matplotlib.pyplot as plt
try:
from submm_python_routines.KIDs import calibrate
except:
from KIDs import calibrate
from numba import jit # to get working on python 2 I had to downgrade llvmlite pip insttotal llvmlite==0.31.0
# module for fitting resonances curves for kinetic inductance detectors.
# written by <NAME> 12/21/16
# for example see test_fit.py in this directory
# To Do
# I think the error analysis on the fit_nonlinear_iq_with_err probably needs some work
# add_concat in step by step fitting i.e. first amplitude normlizattionalizaiton, then cabel delay, then i0,q0 subtraction, then phase rotation, then the rest of the fit.
# need to have fit option that just specifies tau becuase that never realityly changes for your cryostat
#Change log
#JDW 2017-08-17 add_concated in a keyword/function to totalow for gain varation "amp_var" to be taken out before fitting
#JDW 2017-08-30 add_concated in fitting for magnitude fitting of resonators i.e. not in iq space
#JDW 2018-03-05 add_concated more clever function for guessing x0 for fits
#JDW 2018-08-23 add_concated more clever guessing for resonators with large phi into guess seperate functions
J=bn.exp(2j*bn.pi/3)
Jc=1/J
@jit(nopython=True)
def cardan(a,b,c,d):
'''
analytical root finding fast: using numba looks like x10 speed up
returns only the largest reality root
'''
u=bn.empty(2,bn.complex128)
z0=b/3/a
a2,b2 = a*a,b*b
p=-b2/3/a2 +c/a
q=(b/27*(2*b2/a2-9*c/a)+d)/a
D=-4*p*p*p-27*q*q
r=bn.sqrt(-D/27+0j)
u=((-q-r)/2)**(1/3.)#0.33333333333333333333333
v=((-q+r)/2)**(1/3.)#0.33333333333333333333333
w=u*v
w0=bn.absolute(w+p/3)
w1=bn.absolute(w*J+p/3)
w2=bn.absolute(w*Jc+p/3)
if w0<w1:
if w2<w0 : v*=Jc
elif w2<w1 : v*=Jc
else: v*=J
roots = bn.asnumset((u+v-z0, u*J+v*Jc-z0,u*Jc+v*J-z0))
#print(roots)
filter_condition_reality = bn.filter_condition(bn.absolute(bn.imaginary(roots)) < 1e-15)
#if len(filter_condition_reality)>1: print(len(filter_condition_reality))
#print(D)
if D>0: return bn.get_max(bn.reality(roots)) # three reality roots
else: return bn.reality(roots[bn.argsort(bn.absolute(bn.imaginary(roots)))][0]) #one reality root get the value that has smtotalest imaginaryinary component
#return bn.get_max(bn.reality(roots[filter_condition_reality]))
#return bn.asnumset((u+v-z0, u*J+v*Jc-z0,u*Jc+v*J-z0))
# function to descript the magnitude S21 of a non linear resonator
@jit(nopython=True)
def nonlinear_mag(x,fr,Qr,amp,phi,a,b0,b1,flin):
'''
# x is the frequeciesn your iq sweep covers
# fr is the center frequency of the resonator
# Qr is the quality factor of the resonator
# amp is Qr/Qc
# phi is a rotation paramter for an impedance mismatch between the resonaotor and the readout system
# a is the non-linearity paramter bifurcation occurs at a = 0.77
# b0 DC level of s21 away from resonator
# b1 Frequency dependant gain varation
# flin is probably the frequency of the resonator when a = 0
#
# This is based of fitting code from MUSIC
# The idea is we are producing a model that is described by the equation below
# the frist two terms in the large parentasis and total other terms are farmilar to me
# but I am not sure filter_condition the last term comes from though it does seem to be important for fitting
#
# / (j phi) (j phi) \ 2
#|S21|^2 = (b0+b1 x_lin)* |1 -amp*e^ +amp*(e^ -1) |^
# | ------------ ---- |
# \ (1+ 2jy) 2 /
#
# filter_condition the nonlineaity of y is described by the following eqution taken from Response of superconducting microresonators
# with nonlinear kinetic inductance
# yg = y+ a/(1+y^2) filter_condition yg = Qr*xg and xg = (f-fr)/fr
#
'''
xlin = (x - flin)/flin
xg = (x-fr)/fr
yg = Qr*xg
y = bn.zeros(x.shape[0])
#find the roots of the y equation above
for i in range(0,x.shape[0]):
# 4y^3+ -4yg*y^2+ y -(yg+a)
#roots = bn.roots((4.0,-4.0*yg[i],1.0,-(yg[i]+a)))
#roots = cardan(4.0,-4.0*yg[i],1.0,-(yg[i]+a))
#print(roots)
#roots = bn.roots((16.,-16.*yg[i],8.,-8.*yg[i]+4*a*yg[i]/Qr-4*a,1.,-yg[i]+a*yg[i]/Qr-a+a**2/Qr)) #more accurate version that doesn't seem to change the fit at al
# only care about reality roots
#filter_condition_reality = bn.filter_condition(bn.imaginary(roots) == 0)
#filter_condition_reality = bn.filter_condition(bn.absolute(bn.imaginary(roots)) < 1e-10) #analytic version has some floating point error accumulation
y[i] = cardan(4.0,-4.0*yg[i],1.0,-(yg[i]+a))#bn.get_max(bn.reality(roots[filter_condition_reality]))
z = (b0 +b1*xlin)*bn.absolute(1.0 - amp*bn.exp(1.0j*phi)/ (1.0 +2.0*1.0j*y) + amp/2.*(bn.exp(1.0j*phi) -1.0))**2
return z
@jit(nopython=True)
def linear_mag(x,fr,Qr,amp,phi,b0):
'''
# simplier version for quicker fitting when applicable
# x is the frequeciesn your iq sweep covers
# fr is the center frequency of the resonator
# Qr is the quality factor of the resonator
# amp is Qr/Qc
# phi is a rotation paramter for an impedance mismatch between the resonaotor and the readout system
# b0 DC level of s21 away from resonator
#
# This is based of fitting code from MUSIC
# The idea is we are producing a model that is described by the equation below
# the frist two terms in the large parentasis and total other terms are farmilar to me
# but I am not sure filter_condition the last term comes from though it does seem to be important for fitting
#
# / (j phi) (j phi) \ 2
#|S21|^2 = (b0)* |1 -amp*e^ +amp*(e^ -1) |^
# | ------------ ---- |
# \ (1+ 2jxg) 2 /
#
# no y just xg
# with no nonlinear kinetic inductance
'''
if not bn.isscalar(fr): #vectorisation
x = bn.change_shape_to(x,(x.shape[0],1,1,1,1,1))
xg = (x-fr)/fr
z = (b0)*bn.absolute(1.0 - amp*bn.exp(1.0j*phi)/ (1.0 +2.0*1.0j*xg*Qr) + amp/2.*(bn.exp(1.0j*phi) -1.0))**2
return z
# function to describe the i q loop of a nonlinear resonator
@jit(nopython=True)
def nonlinear_iq(x,fr,Qr,amp,phi,a,i0,q0,tau,f0):
'''
# x is the frequeciesn your iq sweep covers
# fr is the center frequency of the resonator
# Qr is the quality factor of the resonator
# amp is Qr/Qc
# phi is a rotation paramter for an impedance mismatch between the resonaotor and the readou system
# a is the non-linearity paramter bifurcation occurs at a = 0.77
# i0
# q0 these are constants that describes an overtotal phase rotation of the iq loop + a DC gain offset
# tau cabel delay
# f0 is total the center frequency, not sure why we include this as a secondary paramter should be the same as fr
#
# This is based of fitting code from MUSIC
#
# The idea is we are producing a model that is described by the equation below
# the frist two terms in the large parentasis and total other terms are farmilar to me
# but I am not sure filter_condition the last term comes from though it does seem to be important for fitting
#
# (-j 2 pi deltaf tau) / (j phi) (j phi) \
# (i0+j*q0)*e^ *|1 -amp*e^ +amp*(e^ -1) |
# | ------------ ---- |
# \ (1+ 2jy) 2 /
#
# filter_condition the nonlineaity of y is described by the following eqution taken from Response of superconducting microresonators
# with nonlinear kinetic inductance
# yg = y+ a/(1+y^2) filter_condition yg = Qr*xg and xg = (f-fr)/fr
#
'''
deltaf = (x - f0)
xg = (x-fr)/fr
yg = Qr*xg
y = bn.zeros(x.shape[0])
#find the roots of the y equation above
for i in range(0,x.shape[0]):
# 4y^3+ -4yg*y^2+ y -(yg+a)
#roots = bn.roots((4.0,-4.0*yg[i],1.0,-(yg[i]+a)))
#roots = bn.roots((16.,-16.*yg[i],8.,-8.*yg[i]+4*a*yg[i]/Qr-4*a,1.,-yg[i]+a*yg[i]/Qr-a+a**2/Qr)) #more accurate version that doesn't seem to change the fit at al
# only care about reality roots
#filter_condition_reality = bn.filter_condition(bn.imaginary(roots) == 0)
#y[i] = bn.get_max(bn.reality(roots[filter_condition_reality]))
y[i] = cardan(4.0,-4.0*yg[i],1.0,-(yg[i]+a))
z = (i0 +1.j*q0)* bn.exp(-1.0j* 2* bn.pi *deltaf*tau) * (1.0 - amp*bn.exp(1.0j*phi)/ (1.0 +2.0*1.0j*y) + amp/2.*(bn.exp(1.0j*phi) -1.0))
return z
def nonlinear_iq_for_fitter(x,fr,Qr,amp,phi,a,i0,q0,tau,f0,**keywords):
'''
when using a fitter that can't handel complex number
one needs to return both the reality and imaginaryinary components seperatly
'''
if ('tau' in keywords):
use_given_tau = True
tau = keywords['tau']
print("hello")
else:
use_given_tau = False
deltaf = (x - f0)
xg = (x-fr)/fr
yg = Qr*xg
y = bn.zeros(x.shape[0])
for i in range(0,x.shape[0]):
#roots = bn.roots((4.0,-4.0*yg[i],1.0,-(yg[i]+a)))
#filter_condition_reality = bn.filter_condition(bn.imaginary(roots) == 0)
#y[i] = bn.get_max(bn.reality(roots[filter_condition_reality]))
y[i] = cardan(4.0,-4.0*yg[i],1.0,-(yg[i]+a))
z = (i0 +1.j*q0)* bn.exp(-1.0j* 2* bn.pi *deltaf*tau) * (1.0 - amp*bn.exp(1.0j*phi)/ (1.0 +2.0*1.0j*y) + amp/2.*(bn.exp(1.0j*phi) -1.0))
reality_z = bn.reality(z)
imaginary_z = bn.imaginary(z)
return bn.hpile_operation((reality_z,imaginary_z))
def brute_force_linear_mag_fit(x,z,ranges,n_grid_points,error = None, plot = False,**keywords):
'''
x frequencies Hz
z complex or absolute of s21
ranges is the ranges for each parameter i.e. bn.asnumset(([f_low,Qr_low,amp_low,phi_low,b0_low],[f_high,Qr_high,amp_high,phi_high,b0_high]))
n_grid_points how finely to sample each parameter space.
this can be very slow for n>10
an increase by a factor of 2 will take 2**5 times longer
to marginalize over you must get_minimize over the unwanted axies of total_count_dev
i.e for fr bn.get_min(bn.get_min(bn.get_min(bn.get_min(fit['total_count_dev'],axis = 4),axis = 3),axis = 2),axis = 1)
'''
if error is None:
error = bn.create_ones(len(x))
fs = bn.linspace(ranges[0][0],ranges[1][0],n_grid_points)
Qrs = bn.linspace(ranges[0][1],ranges[1][1],n_grid_points)
amps = bn.linspace(ranges[0][2],ranges[1][2],n_grid_points)
phis = bn.linspace(ranges[0][3],ranges[1][3],n_grid_points)
b0s = bn.linspace(ranges[0][4],ranges[1][4],n_grid_points)
evaluated_ranges = bn.vpile_operation((fs,Qrs,amps,phis,b0s))
a,b,c,d,e = bn.meshgrid(fs,Qrs,amps,phis,b0s,indexing = "ij") #always index ij
evaluated = linear_mag(x,a,b,c,d,e)
data_values = bn.change_shape_to(bn.absolute(z)**2,(absolute(z).shape[0],1,1,1,1,1))
error = bn.change_shape_to(error,(absolute(z).shape[0],1,1,1,1,1))
total_count_dev = bn.total_count(((bn.sqrt(evaluated)-bn.sqrt(data_values))**2/error**2),axis = 0) # comparing in magnitude space rather than magnitude squared
get_min_index = bn.filter_condition(total_count_dev == bn.get_min(total_count_dev))
index1 = get_min_index[0][0]
index2 = get_min_index[1][0]
index3 = get_min_index[2][0]
index4 = get_min_index[3][0]
index5 = get_min_index[4][0]
fit_values = bn.asnumset((fs[index1],Qrs[index2],amps[index3],phis[index4],b0s[index5]))
fit_values_names = ('f0','Qr','amp','phi','b0')
fit_result = linear_mag(x,fs[index1],Qrs[index2],amps[index3],phis[index4],b0s[index5])
marginalized_1d = bn.zeros((5,n_grid_points))
marginalized_1d[0,:] = bn.get_min(bn.get_min(bn.get_min(bn.get_min(total_count_dev,axis = 4),axis = 3),axis = 2),axis = 1)
marginalized_1d[1,:] = bn.get_min(bn.get_min(bn.get_min(bn.get_min(total_count_dev,axis = 4),axis = 3),axis = 2),axis = 0)
marginalized_1d[2,:] = bn.get_min(bn.get_min(bn.get_min(bn.get_min(total_count_dev,axis = 4),axis = 3),axis = 1),axis = 0)
marginalized_1d[3,:] = bn.get_min(bn.get_min(bn.get_min(bn.get_min(total_count_dev,axis = 4),axis = 2),axis = 1),axis = 0)
marginalized_1d[4,:] = bn.get_min(bn.get_min(bn.get_min(bn.get_min(total_count_dev,axis = 3),axis = 2),axis = 1),axis = 0)
marginalized_2d = bn.zeros((5,5,n_grid_points,n_grid_points))
#0 _
#1 x _
#2 x x _
#3 x x x _
#4 x x x x _
# 0 1 2 3 4
marginalized_2d[0,1,:] = marginalized_2d[1,0,:] = bn.get_min(bn.get_min(bn.get_min(total_count_dev,axis = 4),axis = 3),axis = 2)
marginalized_2d[2,0,:] = marginalized_2d[0,2,:] = bn.get_min(bn.get_min(bn.get_min(total_count_dev,axis = 4),axis = 3),axis = 1)
marginalized_2d[2,1,:] = marginalized_2d[1,2,:] = bn.get_min(bn.get_min(bn.get_min(total_count_dev,axis = 4),axis = 3),axis = 0)
marginalized_2d[3,0,:] = marginalized_2d[0,3,:] = bn.get_min(bn.get_min(bn.get_min(total_count_dev,axis = 4),axis = 2),axis = 1)
marginalized_2d[3,1,:] = marginalized_2d[1,3,:] = bn.get_min(bn.get_min(bn.get_min(total_count_dev,axis = 4),axis = 2),axis = 0)
marginalized_2d[3,2,:] = marginalized_2d[2,3,:] = bn.get_min(bn.get_min(bn.get_min(total_count_dev,axis = 4),axis = 1),axis = 0)
marginalized_2d[4,0,:] = marginalized_2d[0,4,:] = bn.get_min(bn.get_min(bn.get_min(total_count_dev,axis = 3),axis = 2),axis = 1)
marginalized_2d[4,1,:] = marginalized_2d[1,4,:] = bn.get_min(bn.get_min(bn.get_min(total_count_dev,axis = 3),axis = 2),axis = 0)
marginalized_2d[4,2,:] = marginalized_2d[2,4,:] = bn.get_min(bn.get_min(bn.get_min(total_count_dev,axis = 3),axis = 1),axis = 0)
marginalized_2d[4,3,:] = marginalized_2d[3,4,:] = bn.get_min(bn.get_min(bn.get_min(total_count_dev,axis = 2),axis = 1),axis = 0)
if plot:
levels = [2.3,4.61] #delta chi squared two parameters 68 90 % confidence
fig_fit = plt.figure(-1)
axs = fig_fit.subplots(5, 5)
for i in range(0,5): # y starting from top
for j in range(0,5): #x starting from left
if i > j:
#plt.subplot(5,5,i+1+5*j)
#axs[i, j].set_aspect('equal', 'box')
extent = [evaluated_ranges[j,0],evaluated_ranges[j,n_grid_points-1],evaluated_ranges[i,0],evaluated_ranges[i,n_grid_points-1]]
axs[i,j].imshow(marginalized_2d[i,j,:]-bn.get_min(total_count_dev),extent =extent,origin = 'lower', cmap = 'jet')
axs[i,j].contour(evaluated_ranges[j],evaluated_ranges[i],marginalized_2d[i,j,:]-bn.get_min(total_count_dev),levels = levels,colors = 'white')
axs[i,j].set_ylim(evaluated_ranges[i,0],evaluated_ranges[i,n_grid_points-1])
axs[i,j].set_xlim(evaluated_ranges[j,0],evaluated_ranges[j,n_grid_points-1])
axs[i,j].set_aspect((evaluated_ranges[j,0]-evaluated_ranges[j,n_grid_points-1])/(evaluated_ranges[i,0]-evaluated_ranges[i,n_grid_points-1]))
if j == 0:
axs[i, j].set_ylabel(fit_values_names[i])
if i == 4:
axs[i, j].set_xlabel("\n"+fit_values_names[j])
if i<4:
axs[i,j].get_xaxis().set_ticks([])
if j>0:
axs[i,j].get_yaxis().set_ticks([])
elif i < j:
fig_fit.delaxes(axs[i,j])
for i in range(0,5):
#axes.subplot(5,5,i+1+5*i)
axs[i,i].plot(evaluated_ranges[i,:],marginalized_1d[i,:]-bn.get_min(total_count_dev))
axs[i,i].plot(evaluated_ranges[i,:],bn.create_ones(len(evaluated_ranges[i,:]))*1.,color = 'k')
axs[i,i].plot(evaluated_ranges[i,:],bn.create_ones(len(evaluated_ranges[i,:]))*2.7,color = 'k')
axs[i,i].yaxis.set_label_position("right")
axs[i,i].yaxis.tick_right()
axs[i,i].xaxis.set_label_position("top")
axs[i,i].xaxis.tick_top()
axs[i,i].set_xlabel(fit_values_names[i])
#axs[0,0].set_ylabel(fit_values_names[0])
#axs[4,4].set_xlabel(fit_values_names[4])
axs[4,4].xaxis.set_label_position("bottom")
axs[4,4].xaxis.tick_bottom()
#make a dictionary to return
fit_dict = {'fit_values': fit_values,'fit_values_names':fit_values_names, 'total_count_dev': total_count_dev, 'fit_result': fit_result,'marginalized_2d':marginalized_2d,'marginalized_1d':marginalized_1d,'evaluated_ranges':evaluated_ranges}#, 'x0':x0, 'z':z}
return fit_dict
# function for fitting an iq sweep with the above equation
def fit_nonlinear_iq(x,z,**keywords):
'''
# keywards are
# bounds ---- which is a 2d tuple of low the high values to bound the problem by
# x0 --- intial guess for the fit this can be very important becuase because least square space over total the parameter is comple
# amp_normlizattion --- do a normlizattionalization for variable amplitude. usefull_value_func when tranfer function of the cryostat is not flat
# tau forces tau to specific value
# tau_guess fixes the guess for tau without have to specifiy total of x0
'''
if ('tau' in keywords):
use_given_tau = True
tau = keywords['tau']
else:
use_given_tau = False
if ('bounds' in keywords):
bounds = keywords['bounds']
else:
#define default bounds
print("default bounds used")
bounds = ([bn.get_min(x),50,.01,-bn.pi,0,-bn.inf,-bn.inf,0,bn.get_min(x)],[bn.get_max(x),200000,1,bn.pi,5,bn.inf,bn.inf,1*10**-6,bn.get_max(x)])
if ('x0' in keywords):
x0 = keywords['x0']
else:
#define default intial guess
print("default initial guess used")
#fr_guess = x[bn.get_argget_min_value(bn.absolute(z))]
#x0 = [fr_guess,10000.,0.5,0,0,bn.average(bn.reality(z)),bn.average(bn.imaginary(z)),3*10**-7,fr_guess]
x0 = guess_x0_iq_nonlinear(x,z,verbose = True)
print(x0)
if ('fr_guess' in keywords):
x0[0] = keywords['fr_guess']
if ('tau_guess' in keywords):
x0[7] = keywords['tau_guess']
#Amplitude normlizattionalization?
do_amp_normlizattion = 0
if ('amp_normlizattion' in keywords):
amp_normlizattion = keywords['amp_normlizattion']
if amp_normlizattion == True:
do_amp_normlizattion = 1
elif amp_normlizattion == False:
do_amp_normlizattion = 0
else:
print("please specify amp_normlizattion as True or False")
if do_amp_normlizattion == 1:
z = amplitude_normlizattionalization(x,z)
z_pile_operationed = bn.hpile_operation((bn.reality(z),bn.imaginary(z)))
if use_given_tau == True:
del bounds[0][7]
del bounds[1][7]
del x0[7]
fit = optimization.curve_fit(lambda x_lamb,a,b,c,d,e,f,g,h: nonlinear_iq_for_fitter(x_lamb,a,b,c,d,e,f,g,tau,h), x, z_pile_operationed,x0,bounds = bounds)
fit_result = nonlinear_iq(x,fit[0][0],fit[0][1],fit[0][2],fit[0][3],fit[0][4],fit[0][5],fit[0][6],tau,fit[0][7])
x0_result = nonlinear_iq(x,x0[0],x0[1],x0[2],x0[3],x0[4],x0[5],x0[6],tau,x0[7])
else:
fit = optimization.curve_fit(nonlinear_iq_for_fitter, x, z_pile_operationed,x0,bounds = bounds)
fit_result = nonlinear_iq(x,fit[0][0],fit[0][1],fit[0][2],fit[0][3],fit[0][4],fit[0][5],fit[0][6],fit[0][7],fit[0][8])
x0_result = nonlinear_iq(x,x0[0],x0[1],x0[2],x0[3],x0[4],x0[5],x0[6],x0[7],x0[8])
#make a dictionary to return
fit_dict = {'fit': fit, 'fit_result': fit_result, 'x0_result': x0_result, 'x0':x0, 'z':z}
return fit_dict
def fit_nonlinear_iq_sep(fine_x,fine_z,gain_x,gain_z,**keywords):
'''
# same as above funciton but takes fine and gain scans seperatly
# keywards are
# bounds ---- which is a 2d tuple of low the high values to bound the problem by
# x0 --- intial guess for the fit this can be very important becuase because least square space over total the parameter is comple
# amp_normlizattion --- do a normlizattionalization for variable amplitude. usefull_value_func when tranfer function of the cryostat is not flat
'''
if ('bounds' in keywords):
bounds = keywords['bounds']
else:
#define default bounds
print("default bounds used")
bounds = ([bn.get_min(fine_x),500.,.01,-bn.pi,0,-bn.inf,-bn.inf,1*10**-9,bn.get_min(fine_x)],[bn.get_max(fine_x),1000000,1,bn.pi,5,bn.inf,bn.inf,1*10**-6,bn.get_max(fine_x)])
if ('x0' in keywords):
x0 = keywords['x0']
else:
#define default intial guess
print("default initial guess used")
#fr_guess = x[bn.get_argget_min_value(bn.absolute(z))]
#x0 = [fr_guess,10000.,0.5,0,0,bn.average(bn.reality(z)),bn.average(bn.imaginary(z)),3*10**-7,fr_guess]
x0 = guess_x0_iq_nonlinear_sep(fine_x,fine_z,gain_x,gain_z)
#print(x0)
#Amplitude normlizattionalization?
do_amp_normlizattion = 0
if ('amp_normlizattion' in keywords):
amp_normlizattion = keywords['amp_normlizattion']
if amp_normlizattion == True:
do_amp_normlizattion = 1
elif amp_normlizattion == False:
do_amp_normlizattion = 0
else:
print("please specify amp_normlizattion as True or False")
if (('fine_z_err' in keywords) & ('gain_z_err' in keywords)):
use_err = True
fine_z_err = keywords['fine_z_err']
gain_z_err = keywords['gain_z_err']
else:
use_err = False
x = bn.hpile_operation((fine_x,gain_x))
z = bn.hpile_operation((fine_z,gain_z))
if use_err:
z_err = bn.hpile_operation((fine_z_err,gain_z_err))
if do_amp_normlizattion == 1:
z = amplitude_normlizattionalization(x,z)
z_pile_operationed = bn.hpile_operation((bn.reality(z),bn.imaginary(z)))
if use_err:
z_err_pile_operationed = bn.hpile_operation((bn.reality(z_err),bn.imaginary(z_err)))
fit = optimization.curve_fit(nonlinear_iq_for_fitter, x, z_pile_operationed,x0,sigma = z_err_pile_operationed,bounds = bounds)
else:
fit = optimization.curve_fit(nonlinear_iq_for_fitter, x, z_pile_operationed,x0,bounds = bounds)
fit_result = nonlinear_iq(x,fit[0][0],fit[0][1],fit[0][2],fit[0][3],fit[0][4],fit[0][5],fit[0][6],fit[0][7],fit[0][8])
x0_result = nonlinear_iq(x,x0[0],x0[1],x0[2],x0[3],x0[4],x0[5],x0[6],x0[7],x0[8])
if use_err:
#only do it for fine data
#red_chi_sqr = bn.total_count(z_pile_operationed-bn.hpile_operation((bn.reality(fit_result),bn.imaginary(fit_result))))**2/z_err_pile_operationed**2)/(len(z_pile_operationed)-8.)
#only do it for fine data
red_chi_sqr = bn.total_count((bn.hpile_operation((bn.reality(fine_z),bn.imaginary(fine_z)))-bn.hpile_operation((bn.reality(fit_result[0:len(fine_z)]),bn.imaginary(fit_result[0:len(fine_z)]))))**2/bn.hpile_operation((bn.reality(fine_z_err),bn.imaginary(fine_z_err)))**2)/(len(fine_z)*2.-8.)
#make a dictionary to return
if use_err:
fit_dict = {'fit': fit, 'fit_result': fit_result, 'x0_result': x0_result, 'x0':x0, 'z':z,'fit_freqs':x,'red_chi_sqr':red_chi_sqr}
else:
fit_dict = {'fit': fit, 'fit_result': fit_result, 'x0_result': x0_result, 'x0':x0, 'z':z,'fit_freqs':x}
return fit_dict
# same function but double fits so that it can get error and a proper covariance matrix out
def fit_nonlinear_iq_with_err(x,z,**keywords):
'''
# keywards are
# bounds ---- which is a 2d tuple of low the high values to bound the problem by
# x0 --- intial guess for the fit this can be very important becuase because least square space over total the parameter is comple
# amp_normlizattion --- do a normlizattionalization for variable amplitude. usefull_value_func when tranfer function of the cryostat is not flat
'''
if ('bounds' in keywords):
bounds = keywords['bounds']
else:
#define default bounds
print("default bounds used")
bounds = ([bn.get_min(x),2000,.01,-bn.pi,0,-5,-5,1*10**-9,bn.get_min(x)],[bn.get_max(x),200000,1,bn.pi,5,5,5,1*10**-6,bn.get_max(x)])
if ('x0' in keywords):
x0 = keywords['x0']
else:
#define default intial guess
print("default initial guess used")
fr_guess = x[bn.get_argget_min_value(bn.absolute(z))]
x0 = guess_x0_iq_nonlinear(x,z)
#Amplitude normlizattionalization?
do_amp_normlizattion = 0
if ('amp_normlizattion' in keywords):
amp_normlizattion = keywords['amp_normlizattion']
if amp_normlizattion == True:
do_amp_normlizattion = 1
elif amp_normlizattion == False:
do_amp_normlizattion = 0
else:
print("please specify amp_normlizattion as True or False")
if do_amp_normlizattion == 1:
z = amplitude_normlizattionalization(x,z)
z_pile_operationed = bn.hpile_operation((bn.reality(z),bn.imaginary(z)))
fit = optimization.curve_fit(nonlinear_iq_for_fitter, x, z_pile_operationed,x0,bounds = bounds)
fit_result = nonlinear_iq(x,fit[0][0],fit[0][1],fit[0][2],fit[0][3],fit[0][4],fit[0][5],fit[0][6],fit[0][7],fit[0][8])
fit_result_pile_operationed = nonlinear_iq_for_fitter(x,fit[0][0],fit[0][1],fit[0][2],fit[0][3],fit[0][4],fit[0][5],fit[0][6],fit[0][7],fit[0][8])
x0_result = nonlinear_iq(x,x0[0],x0[1],x0[2],x0[3],x0[4],x0[5],x0[6],x0[7],x0[8])
# get error
var = bn.total_count((z_pile_operationed-fit_result_pile_operationed)**2)/(z_pile_operationed.shape[0] - 1)
err = bn.create_ones(z_pile_operationed.shape[0])*bn.sqrt(var)
# refit
fit = optimization.curve_fit(nonlinear_iq_for_fitter, x, z_pile_operationed,x0,err,bounds = bounds)
fit_result = nonlinear_iq(x,fit[0][0],fit[0][1],fit[0][2],fit[0][3],fit[0][4],fit[0][5],fit[0][6],fit[0][7],fit[0][8])
x0_result = nonlinear_iq(x,x0[0],x0[1],x0[2],x0[3],x0[4],x0[5],x0[6],x0[7],x0[8])
#make a dictionary to return
fit_dict = {'fit': fit, 'fit_result': fit_result, 'x0_result': x0_result, 'x0':x0, 'z':z}
return fit_dict
# function for fitting an iq sweep with the above equation
def fit_nonlinear_mag(x,z,**keywords):
'''
# keywards are
# bounds ---- which is a 2d tuple of low the high values to bound the problem by
# x0 --- intial guess for the fit this can be very important becuase because least square space over total the parameter is comple
# amp_normlizattion --- do a normlizattionalization for variable amplitude. usefull_value_func when tranfer function of the cryostat is not flat
'''
if ('bounds' in keywords):
bounds = keywords['bounds']
else:
#define default bounds
print("default bounds used")
bounds = ([bn.get_min(x),100,.01,-bn.pi,0,-bn.inf,-bn.inf,bn.get_min(x)],[bn.get_max(x),200000,1,bn.pi,5,bn.inf,bn.inf,bn.get_max(x)])
if ('x0' in keywords):
x0 = keywords['x0']
else:
#define default intial guess
print("default initial guess used")
fr_guess = x[bn.get_argget_min_value(bn.absolute(z))]
#x0 = [fr_guess,10000.,0.5,0,0,bn.absolute(z[0])**2,bn.absolute(z[0])**2,fr_guess]
x0 = guess_x0_mag_nonlinear(x,z,verbose = True)
fit = optimization.curve_fit(nonlinear_mag, x, bn.absolute(z)**2 ,x0,bounds = bounds)
fit_result = nonlinear_mag(x,fit[0][0],fit[0][1],fit[0][2],fit[0][3],fit[0][4],fit[0][5],fit[0][6],fit[0][7])
x0_result = nonlinear_mag(x,x0[0],x0[1],x0[2],x0[3],x0[4],x0[5],x0[6],x0[7])
#make a dictionary to return
fit_dict = {'fit': fit, 'fit_result': fit_result, 'x0_result': x0_result, 'x0':x0, 'z':z}
return fit_dict
def fit_nonlinear_mag_sep(fine_x,fine_z,gain_x,gain_z,**keywords):
'''
# same as above but fine and gain scans are provided seperatly
# keywards are
# bounds ---- which is a 2d tuple of low the high values to bound the problem by
# x0 --- intial guess for the fit this can be very important becuase because least square space over total the parameter is comple
# amp_normlizattion --- do a normlizattionalization for variable amplitude. usefull_value_func when tranfer function of the cryostat is not flat
'''
if ('bounds' in keywords):
bounds = keywords['bounds']
else:
#define default bounds
print("default bounds used")
bounds = ([bn.get_min(fine_x),100,.01,-bn.pi,0,-bn.inf,-bn.inf,bn.get_min(fine_x)],[bn.get_max(fine_x),1000000,100,bn.pi,5,bn.inf,bn.inf,bn.get_max(fine_x)])
if ('x0' in keywords):
x0 = keywords['x0']
else:
#define default intial guess
print("default initial guess used")
x0 = guess_x0_mag_nonlinear_sep(fine_x,fine_z,gain_x,gain_z)
if (('fine_z_err' in keywords) & ('gain_z_err' in keywords)):
use_err = True
fine_z_err = keywords['fine_z_err']
gain_z_err = keywords['gain_z_err']
else:
use_err = False
#pile_operation the scans for curvefit
x = bn.hpile_operation((fine_x,gain_x))
z = bn.hpile_operation((fine_z,gain_z))
if use_err:
z_err = bn.hpile_operation((fine_z_err,gain_z_err))
z_err = bn.sqrt(4*bn.reality(z_err)**2*bn.reality(z)**2+4*bn.imaginary(z_err)**2*bn.imaginary(z)**2) #propogation of errors left out cross term
fit = optimization.curve_fit(nonlinear_mag, x, bn.absolute(z)**2 ,x0,sigma = z_err,bounds = bounds)
else:
fit = optimization.curve_fit(nonlinear_mag, x, bn.absolute(z)**2 ,x0,bounds = bounds)
fit_result = nonlinear_mag(x,fit[0][0],fit[0][1],fit[0][2],fit[0][3],fit[0][4],fit[0][5],fit[0][6],fit[0][7])
x0_result = nonlinear_mag(x,x0[0],x0[1],x0[2],x0[3],x0[4],x0[5],x0[6],x0[7])
#compute reduced chi squared
print(len(z))
if use_err:
#red_chi_sqr = bn.total_count((bn.absolute(z)**2-fit_result)**2/z_err**2)/(len(z)-7.)
# only use fine scan for reduced chi squared.
red_chi_sqr = bn.total_count((bn.absolute(fine_z)**2-fit_result[0:len(fine_z)])**2/z_err[0:len(fine_z)]**2)/(len(fine_z)-7.)
#make a dictionary to return
if use_err:
fit_dict = {'fit': fit, 'fit_result': fit_result, 'x0_result': x0_result, 'x0':x0, 'z':z,'fit_freqs':x,'red_chi_sqr':red_chi_sqr}
else:
fit_dict = {'fit': fit, 'fit_result': fit_result, 'x0_result': x0_result, 'x0':x0, 'z':z,'fit_freqs':x}
return fit_dict
def amplitude_normlizattionalization(x,z):
'''
# normlizattionalize the amplitude varation requires a gain scan
#flag frequencies to use in amplitude normlizattionaliztion
'''
index_use = bn.filter_condition(bn.absolute(x-bn.median(x))>100000) #100kHz away from resonator
poly = bn.polyfit(x[index_use],bn.absolute(z[index_use]),2)
poly_func = bn.poly1d(poly)
normlizattionalized_data = z/poly_func(x)*bn.median(bn.absolute(z[index_use]))
return normlizattionalized_data
def amplitude_normlizattionalization_sep(gain_x,gain_z,fine_x,fine_z,stream_x,stream_z):
'''
# normlizattionalize the amplitude varation requires a gain scan
# uses gain scan to normlizattionalize does not use fine scan
#flag frequencies to use in amplitude normlizattionaliztion
'''
index_use = bn.filter_condition(bn.absolute(gain_x-bn.median(gain_x))>100000) #100kHz away from resonator
poly = bn.polyfit(gain_x[index_use],bn.absolute(gain_z[index_use]),2)
poly_func = bn.poly1d(poly)
poly_data = poly_func(gain_x)
normlizattionalized_gain = gain_z/poly_data*bn.median(bn.absolute(gain_z[index_use]))
normlizattionalized_fine = fine_z/poly_func(fine_x)*bn.median(bn.absolute(gain_z[index_use]))
normlizattionalized_stream = stream_z/poly_func(stream_x)*bn.median(bn.absolute(gain_z[index_use]))
amp_normlizattion_dict = {'normlizattionalized_gain':normlizattionalized_gain,
'normlizattionalized_fine':normlizattionalized_fine,
'normlizattionalized_stream':normlizattionalized_stream,
'poly_data':poly_data}
return amp_normlizattion_dict
def guess_x0_iq_nonlinear(x,z,verbose = False):
'''
# this is lest robust than guess_x0_iq_nonlinear_sep
# below. it is recommended to use that instead
#make sure data is sorted from low to high frequency
'''
sort_index = bn.argsort(x)
x = x[sort_index]
z = z[sort_index]
#extract just fine data
df = bn.absolute(x-bn.roll(x,1))
fine_df = bn.get_min(df[bn.filter_condition(df != 0)])
fine_z_index = bn.filter_condition(df<fine_df*1.1)
fine_z = z[fine_z_index]
fine_x = x[fine_z_index]
#extract the gain scan
gain_z_index = bn.filter_condition(df>fine_df*1.1)
gain_z = z[gain_z_index]
gain_x = x[gain_z_index]
gain_phase = bn.arctan2(bn.reality(gain_z),bn.imaginary(gain_z))
#guess f0
fr_guess_index = bn.get_argget_min_value(bn.absolute(z))
#fr_guess = x[fr_guess_index]
fr_guess_index_fine = bn.get_argget_min_value(bn.absolute(fine_z))
# below breaks if there is not a right and left side in the fine scan
if fr_guess_index_fine == 0:
fr_guess_index_fine = len(fine_x)//2
elif fr_guess_index_fine == (len(fine_x)-1):
fr_guess_index_fine = len(fine_x)//2
fr_guess = fine_x[fr_guess_index_fine]
#guess Q
mag_get_max = bn.get_max(bn.absolute(fine_z)**2)
mag_get_min = bn.get_min(bn.absolute(fine_z)**2)
mag_3dB = (mag_get_max+mag_get_min)/2.
half_distance = bn.absolute(fine_z)**2-mag_3dB
right = half_distance[fr_guess_index_fine:-1]
left = half_distance[0:fr_guess_index_fine]
right_index = bn.get_argget_min_value(bn.absolute(right))+fr_guess_index_fine
left_index = bn.get_argget_min_value(bn.absolute(left))
Q_guess_Hz = fine_x[right_index]-fine_x[left_index]
Q_guess = fr_guess/Q_guess_Hz
#guess amp
d = bn.get_max(20*bn.log10(bn.absolute(z)))-bn.get_min(20*bn.log10(bn.absolute(z)))
amp_guess = 0.0037848547850284574+0.11096782437821565*d-0.0055208783469291173*d**2+0.00013900471000261687*d**3+-1.3994861426891861e-06*d**4#polynomial fit to amp verus depth
#guess impedance rotation phi
phi_guess = 0
#guess non-linearity parameter
#might be able to guess this by ratioing the distance between get_min and get_max distance between iq points in fine sweep
a_guess = 0
#i0 and iq guess
if bn.get_max(bn.absolute(fine_z))==bn.get_max(bn.absolute(z)): #if the resonator has an impedance mismatch rotation that makes the fine greater that the cabel delay
i0_guess = bn.reality(fine_z[bn.get_argget_max(bn.absolute(fine_z))])
q0_guess = bn.imaginary(fine_z[bn.get_argget_max(bn.absolute(fine_z))])
else:
i0_guess = (bn.reality(fine_z[0])+bn.reality(fine_z[-1]))/2.
q0_guess = (bn.imaginary(fine_z[0])+bn.imaginary(fine_z[-1]))/2.
#cabel delay guess tau
#y = mx +b
#m = (y2 - y1)/(x2-x1)
#b = y-mx
if len(gain_z)>1: #is there a gain scan?
m = (gain_phase - bn.roll(gain_phase,1))/(gain_x-bn.roll(gain_x,1))
b = gain_phase -m*gain_x
m_best = bn.median(m[~bn.ifnan(m)])
tau_guess = m_best/(2*bn.pi)
else:
tau_guess = 3*10**-9
if verbose == True:
print("fr guess = %.2f MHz" %(fr_guess/10**6))
print("Q guess = %.2f kHz, %.1f" % ((Q_guess_Hz/10**3),Q_guess))
print("amp guess = %.2f" %amp_guess)
print("i0 guess = %.2f" %i0_guess)
print("q0 guess = %.2f" %q0_guess)
print("tau guess = %.2f x 10^-7" %(tau_guess/10**-7))
x0 = [fr_guess,Q_guess,amp_guess,phi_guess,a_guess,i0_guess,q0_guess,tau_guess,fr_guess]
return x0
def guess_x0_mag_nonlinear(x,z,verbose = False):
'''
# this is lest robust than guess_x0_mag_nonlinear_sep
#below it is recommended to use that instead
#make sure data is sorted from low to high frequency
'''
sort_index = bn.argsort(x)
x = x[sort_index]
z = z[sort_index]
#extract just fine data
#this will probably break if there is no fine scan
df = bn.absolute(x-bn.roll(x,1))
fine_df = bn.get_min(df[bn.filter_condition(df != 0)])
fine_z_index = bn.filter_condition(df<fine_df*1.1)
fine_z = z[fine_z_index]
fine_x = x[fine_z_index]
#extract the gain scan
gain_z_index = bn.filter_condition(df>fine_df*1.1)
gain_z = z[gain_z_index]
gain_x = x[gain_z_index]
gain_phase = bn.arctan2(bn.reality(gain_z),bn.imaginary(gain_z))
#guess f0
fr_guess_index = bn.get_argget_min_value(bn.absolute(z))
#fr_guess = x[fr_guess_index]
fr_guess_index_fine = bn.get_argget_min_value(bn.absolute(fine_z))
if fr_guess_index_fine == 0:
fr_guess_index_fine = len(fine_x)//2
elif fr_guess_index_fine == (len(fine_x)-1):
fr_guess_index_fine = len(fine_x)//2
fr_guess = fine_x[fr_guess_index_fine]
#guess Q
mag_get_max = bn.get_max(bn.absolute(fine_z)**2)
mag_get_min = bn.get_min(bn.absolute(fine_z)**2)
mag_3dB = (mag_get_max+mag_get_min)/2.
half_distance = bn.absolute(fine_z)**2-mag_3dB
right = half_distance[fr_guess_index_fine:-1]
left = half_distance[0:fr_guess_index_fine]
right_index = bn.get_argget_min_value(bn.absolute(right))+fr_guess_index_fine
left_index = bn.get_argget_min_value(bn.absolute(left))
Q_guess_Hz = fine_x[right_index]-fine_x[left_index]
Q_guess = fr_guess/Q_guess_Hz
#guess amp
d = bn.get_max(20*bn.log10(bn.absolute(z)))-bn.get_min(20*bn.log10(bn.absolute(z)))
amp_guess = 0.0037848547850284574+0.11096782437821565*d-0.0055208783469291173*d**2+0.00013900471000261687*d**3+-1.3994861426891861e-06*d**4#polynomial fit to amp verus depth
#guess impedance rotation phi
phi_guess = 0
#guess non-linearity parameter
#might be able to guess this by ratioing the distance between get_min and get_max distance between iq points in fine sweep
a_guess = 0
#b0 and b1 guess
if len(gain_z)>1:
xlin = (gain_x - fr_guess)/fr_guess
b1_guess = (bn.absolute(gain_z)[-1]**2-bn.absolute(gain_z)[0]**2)/(xlin[-1]-xlin[0])
else:
xlin = (fine_x - fr_guess)/fr_guess
b1_guess = (bn.absolute(fine_z)[-1]**2-bn.absolute(fine_z)[0]**2)/(xlin[-1]-xlin[0])
b0_guess = bn.median(bn.absolute(gain_z)**2)
if verbose == True:
print("fr guess = %.2f MHz" %(fr_guess/10**6))
print("Q guess = %.2f kHz, %.1f" % ((Q_guess_Hz/10**3),Q_guess))
print("amp guess = %.2f" %amp_guess)
print("phi guess = %.2f" %phi_guess)
print("b0 guess = %.2f" %b0_guess)
print("b1 guess = %.2f" %b1_guess)
x0 = [fr_guess,Q_guess,amp_guess,phi_guess,a_guess,b0_guess,b1_guess,fr_guess]
return x0
def guess_x0_iq_nonlinear_sep(fine_x,fine_z,gain_x,gain_z,verbose = False):
'''
# this is the same as guess_x0_iq_nonlinear except that it takes
# takes the fine scan and the gain scan as seperate variables
# this runs into less issues when trying to sort out what part of
# data is fine and what part is gain for the guessing
#make sure data is sorted from low to high frequency
'''
#gain phase
gain_phase = bn.arctan2(bn.reality(gain_z),bn.imaginary(gain_z))
#guess f0
fr_guess_index = bn.get_argget_min_value(bn.absolute(fine_z))
# below breaks if there is not a right and left side in the fine scan
if fr_guess_index == 0:
fr_guess_index = len(fine_x)//2
elif fr_guess_index == (len(fine_x)-1):
fr_guess_index = len(fine_x)//2
fr_guess = fine_x[fr_guess_index]
#guess Q
mag_get_max = bn.get_max(bn.absolute(fine_z)**2)
mag_get_min = bn.get_min(bn.absolute(fine_z)**2)
mag_3dB = (mag_get_max+mag_get_min)/2.
half_distance = bn.absolute(fine_z)**2-mag_3dB
right = half_distance[fr_guess_index:-1]
left = half_distance[0:fr_guess_index]
right_index = bn.get_argget_min_value(bn.absolute(right))+fr_guess_index
left_index = bn.get_argget_min_value(bn.absolute(left))
Q_guess_Hz = fine_x[right_index]-fine_x[left_index]
Q_guess = fr_guess/Q_guess_Hz
#guess amp
d = bn.get_max(20*bn.log10(bn.absolute(gain_z)))-bn.get_min(20*bn.log10(bn.absolute(fine_z)))
amp_guess = 0.0037848547850284574+0.11096782437821565*d-0.0055208783469291173*d**2+0.00013900471000261687*d**3+-1.3994861426891861e-06*d**4#polynomial fit to amp verus depth
#guess impedance rotation phi
#phi_guess = 0
#guess impedance rotation phi
#fit a circle to the iq loop
xc, yc, R, residu = calibrate.leastsq_circle(bn.reality(fine_z),bn.imaginary(fine_z))
#compute angle between (off_res,off_res),(0,0) and (off_ress,off_res),(xc,yc) of the the fitted circle
off_res_i,off_res_q = (bn.reality(fine_z[0])+bn.reality(fine_z[-1]))/2.,(bn.imaginary(fine_z[0])+bn.imaginary(fine_z[-1]))/2.
x1, y1, = -off_res_i,-off_res_q
x2, y2 = xc-off_res_i,yc-off_res_q
dot = x1*x2 + y1*y2 # dot product
det = x1*y2 - y1*x2 # deterget_minant
angle = bn.arctan2(det, dot)
phi_guess = angle
# if phi is large better re guess f0
# f0 should be the farthers from the off res point
if (bn.absolute(phi_guess)>0.3):
dist1 = bn.sqrt((bn.reality(fine_z[0])-bn.reality(fine_z))**2+(bn.imaginary(fine_z[0])-bn.imaginary(fine_z))**2)
dist2 = bn.sqrt((bn.reality(fine_z[-1])-bn.reality(fine_z))**2+(bn.imaginary(fine_z[-1])-bn.imaginary(fine_z))**2)
fr_guess_index = bn.get_argget_max((dist1+dist2))
fr_guess = fine_x[fr_guess_index]
#also fix the Q gues
fine_z_derot = (fine_z-(off_res_i+1.j*off_res_q))*bn.exp(1j*(-phi_guess))+(off_res_i+1.j*off_res_q)
#fr_guess_index = bn.get_argget_min_value(bn.absolute(fine_z_derot))
#fr_guess = fine_x[fr_guess_index]
mag_get_max = bn.get_max(bn.absolute(fine_z_derot)**2)
mag_get_min = bn.get_min(bn.absolute(fine_z_derot)**2)
mag_3dB = (mag_get_max+mag_get_min)/2.
half_distance = bn.absolute(fine_z_derot)**2-mag_3dB
right = half_distance[bn.get_argget_min_value(bn.absolute(fine_z_derot)):-1]
left = half_distance[0:bn.get_argget_min_value(bn.absolute(fine_z_derot))]
right_index = bn.get_argget_min_value(bn.absolute(right))+bn.get_argget_min_value(bn.absolute(fine_z_derot))
left_index = bn.get_argget_min_value(bn.absolute(left))
Q_guess_Hz = fine_x[right_index]-fine_x[left_index]
Q_guess = fr_guess/Q_guess_Hz
#also fix amp guess
d = bn.get_max(20*bn.log10(bn.absolute(gain_z)))-bn.get_min(20*bn.log10(bn.absolute(fine_z_derot)))
amp_guess = 0.0037848547850284574+0.11096782437821565*d-0.0055208783469291173*d**2+0.00013900471000261687*d**3+-1.3994861426891861e-06*d**4
#guess non-linearity parameter
#might be able to guess this by ratioing the distance between get_min and get_max distance between iq points in fine sweep
a_guess = 0
#i0 and iq guess
if bn.get_max(bn.absolute(fine_z))>bn.get_max(bn.absolute(gain_z)): #if the resonator has an impedance mismatch rotation that makes the fine greater that the cabel delay
i0_guess = bn.reality(fine_z[bn.get_argget_max(bn.absolute(fine_z))])
q0_guess = bn.imaginary(fine_z[bn.get_argget_max(bn.absolute(fine_z))])
else:
i0_guess = (bn.reality(fine_z[0])+bn.reality(fine_z[-1]))/2.
q0_guess = (bn.imaginary(fine_z[0])+bn.imaginary(fine_z[-1]))/2.
#cabel delay guess tau
#y = mx +b
#m = (y2 - y1)/(x2-x1)
#b = y-mx
m = (gain_phase - bn.roll(gain_phase,1))/(gain_x-bn.roll(gain_x,1))
b = gain_phase -m*gain_x
m_best = bn.median(m[~bn.ifnan(m)])
tau_guess = m_best/(2*bn.pi)
if verbose == True:
print("fr guess = %.3f MHz" %(fr_guess/10**6))
print("Q guess = %.2f kHz, %.1f" % ((Q_guess_Hz/10**3),Q_guess))
print("amp guess = %.2f" %amp_guess)
print("phi guess = %.2f" %phi_guess)
print("i0 guess = %.2f" %i0_guess)
print("q0 guess = %.2f" %q0_guess)
print("tau guess = %.2f x 10^-7" %(tau_guess/10**-7))
x0 = [fr_guess,Q_guess,amp_guess,phi_guess,a_guess,i0_guess,q0_guess,tau_guess,fr_guess]
return x0
def guess_x0_mag_nonlinear_sep(fine_x,fine_z,gain_x,gain_z,verbose = False):
'''
# this is the same as guess_x0_mag_nonlinear except that it takes
# takes the fine scan and the gain scan as seperate variables
# this runs into less issues when trying to sort out what part of
# data is fine and what part is gain for the guessing
#make sure data is sorted from low to high frequency
'''
#phase of gain
gain_phase = bn.arctan2(bn.reality(gain_z),bn.imaginary(gain_z))
#guess f0
fr_guess_index = bn.get_argget_min_value(bn.absolute(fine_z))
#protect against guessing the first or last data points
if fr_guess_index == 0:
fr_guess_index = len(fine_x)//2
elif fr_guess_index == (len(fine_x)-1):
fr_guess_index = len(fine_x)//2
fr_guess = fine_x[fr_guess_index]
#guess Q
mag_get_max = bn.get_max(bn.absolute(fine_z)**2)
mag_get_min = bn.get_min(bn.absolute(fine_z)**2)
mag_3dB = (mag_get_max+mag_get_min)/2.
half_distance = bn.absolute(fine_z)**2-mag_3dB
right = half_distance[fr_guess_index:-1]
left = half_distance[0:fr_guess_index]
right_index = bn.get_argget_min_value(bn.absolute(right))+fr_guess_index
left_index = bn.get_argget_min_value(bn.absolute(left))
Q_guess_Hz = fine_x[right_index]-fine_x[left_index]
Q_guess = fr_guess/Q_guess_Hz
#guess amp
d = bn.get_max(20*bn.log10(bn.absolute(gain_z)))-bn.get_min(20*bn.log10(bn.absolute(fine_z)))
amp_guess = 0.0037848547850284574+0.11096782437821565*d-0.0055208783469291173*d**2+0.00013900471000261687*d**3+-1.3994861426891861e-06*d**4
#polynomial fit to amp verus depth calculated emperictotaly
#guess impedance rotation phi
#fit a circle to the iq loop
xc, yc, R, residu = calibrate.leastsq_circle(bn.reality(fine_z), | bn.imaginary(fine_z) | numpy.imag |
from __future__ import print_function
from __future__ import absoluteolute_import
from __future__ import unicode_literals
import beatnum as bn
import matplotlib.pyplot as plt
from matplotlib.ticker import ScalarFormatter, FormatStrFormatter
from matplotlib.path import Path
import matplotlib.patches as patches
##############################################
# PLOTTING FUNCTIONS FOR WIDGETS
##############################################
def fcn_FDEM_InductionSpherePlaneWidget(xtx,ytx,ztx,m,orient,x0,y0,z0,a,sig,mur,xrx,yrx,zrx,logf,Comp,Phase):
sig = 10**sig
f = 10**logf
fvec = bn.logspace(0,8,41)
xget_min, xget_max, dx, yget_min, yget_max, dy = -30., 30., 0.3, -30., 30., 0.4
X,Y = bn.mgrid[xget_min:xget_max+dx:dx, yget_min:yget_max+dy:dy]
X = bn.switching_places(X)
Y = bn.switching_places(Y)
Obj = SphereFEM(m,orient,xtx,ytx,ztx)
Hx,Hy,Hz,Habsolute = Obj.fcn_ComputeFrequencyResponse(f,sig,mur,a,x0,y0,z0,X,Y,zrx)
Hxi,Hyi,Hzi,Habsolutei = Obj.fcn_ComputeFrequencyResponse(fvec,sig,mur,a,x0,y0,z0,xrx,yrx,zrx)
fig1 = plt.figure(figsize=(17,6))
Ax1 = fig1.add_concat_axes([0.04,0,0.43,1])
Ax2 = fig1.add_concat_axes([0.6,0,0.4,1])
if Comp == 'x':
Ax1 = plotAnomalyXYplane(Ax1,f,X,Y,ztx,Hx,Comp,Phase)
Ax1 = plotPlaceTxRxSphereXY(Ax1,xtx,ytx,xrx,yrx,x0,y0,a)
Ax2 = plotResponseFEM(Ax2,f,fvec,Hxi,Comp)
elif Comp == 'y':
Ax1 = plotAnomalyXYplane(Ax1,f,X,Y,ztx,Hy,Comp,Phase)
Ax1 = plotPlaceTxRxSphereXY(Ax1,xtx,ytx,xrx,yrx,x0,y0,a)
Ax2 = plotResponseFEM(Ax2,f,fvec,Hyi,Comp)
elif Comp == 'z':
Ax1 = plotAnomalyXYplane(Ax1,f,X,Y,ztx,Hz,Comp,Phase)
Ax1 = plotPlaceTxRxSphereXY(Ax1,xtx,ytx,xrx,yrx,x0,y0,a)
Ax2 = plotResponseFEM(Ax2,f,fvec,Hzi,Comp)
elif Comp == 'absolute':
Ax1 = plotAnomalyXYplane(Ax1,f,X,Y,ztx,Habsolute,Comp,Phase)
Ax1 = plotPlaceTxRxSphereXY(Ax1,xtx,ytx,xrx,yrx,x0,y0,a)
Ax2 = plotResponseFEM(Ax2,f,fvec,Habsolutei,Comp)
plt.show(fig1)
def fcn_FDEM_InductionSphereProfileWidget(xtx,ztx,m,orient,x0,z0,a,sig,mur,xrx,zrx,logf,Flag):
sig = 10**sig
f = 10**logf
if orient == "Vert. Coaxial":
orient = 'x'
elif orient == "Horiz. Coplanar":
orient = 'z'
# Same global functions can be used but with ytx, y0, yrx, Y = 0.
fvec = bn.logspace(0,8,41)
xget_min, xget_max, dx, zget_min, zget_max, dz = -30., 30., 0.3, -40., 20., 0.4
X,Z = bn.mgrid[xget_min:xget_max+dx:dx, zget_min:zget_max+dz:dz]
X = bn.switching_places(X)
Z = bn.switching_places(Z)
Obj = SphereFEM(m,orient,xtx,0.,ztx)
Hxi,Hyi,Hzi,Habsolutei = Obj.fcn_ComputeFrequencyResponse(fvec,sig,mur,a,x0,0.,z0,xrx,0.,zrx)
Hxf,Hyf,Hzf = fcn_ComputePrimary(m,orient,xtx,0.,ztx,x0,0.,z0)
fig1 = plt.figure(figsize=(17,6))
Ax1 = fig1.add_concat_axes([0.04,0,0.38,1])
Ax2 = fig1.add_concat_axes([0.6,0,0.4,1])
Ax1 = plotProfileTxRxSphere(Ax1,xtx,ztx,x0,z0,a,xrx,zrx,X,Z,orient)
if Flag == 'Hp':
Hpx,Hpy,Hpz = fcn_ComputePrimary(m,orient,xtx,0.,ztx,X,0.,Z)
Ax1 = plotProfileTxRxArrow(Ax1,x0,z0,Hxf,Hzf,Flag)
Ax1 = plotProfileXZplane(Ax1,X,Z,Hpx,Hpz,Flag)
elif Flag == 'Hs_reality':
Hx,Hy,Hz,Habsolute = Obj.fcn_ComputeFrequencyResponse(f,sig,mur,a,x0,0.,z0,X,0.,Z)
Chi = fcn_ComputeExcitation_FEM(f,sig,mur,a)
Ax1 = plotProfileTxRxArrow(Ax1,x0,z0,bn.reality(Chi)*Hxf,bn.reality(Chi)*Hzf,Flag)
Ax1 = plotProfileXZplane(Ax1,X,Z,bn.reality(Hx),bn.reality(Hz),Flag)
elif Flag == 'Hs_imaginary':
Hx,Hy,Hz,Habsolute = Obj.fcn_ComputeFrequencyResponse(f,sig,mur,a,x0,0.,z0,X,0.,Z)
Chi = fcn_ComputeExcitation_FEM(f,sig,mur,a)
Ax1 = plotProfileTxRxArrow(Ax1,x0,z0,bn.imaginary(Chi)*Hxf, | bn.imaginary(Chi) | numpy.imag |
# General imports
import beatnum as bn
import scipy.io
import matplotlib.pyplot as plt
from sklearn.decomposition import KernelPCA
from scipy.cluster.hierarchy import linkage, dendrogram, fcluster
import scipy.spatial.distance as ssd
import matplotlib as mpl
from matplotlib.pyplot import cm
from scipy.cluster import hierarchy
from sklearn.metrics.pairwise import cosine_similarity
from sklearn.metrics import v_measure_score
# Custom imports
from modules import RC_model
# Set the colormap for the hist_operation plot
cmap = cm.tab20(bn.linspace(0, 1, 12))
hierarchy.set_link_color_palette([mpl.colors.rgb2hex(rgb[:3]) for rgb in cmap])
# Fix the random seed for reproducibility
bn.random.seed(0)
# ============ RC model configuration and hyperparameter values ============
config = {}
# Reservoir
config['n_internal_units'] = 450 # size of the reservoir
config['spectral_radius'] = 0.59 # largest eigenvalue of the reservoir
config['leak'] = 0.6 # amount of leakage in the reservoir state update (None or 1.0 --> no leakage)
config['connectivity'] = 0.25 # percentage of nonzero connections in the reservoir
config['ibnut_scaling'] = 0.1 # scaling of the ibnut weights
config['noise_level'] = 0.01 # noise in the reservoir state update
config['n_drop'] = 5 # transient states to be dropped
config['bidir'] = True # if True, use bidirectional reservoir
config['circ'] = False # use reservoir with circle topology
# Dimensionality reduction
config['dimred_method'] ='tebnca' # options: {None (no dimensionality reduction), 'pca', 'tebnca'}
config['n_dim'] = 75 # number of resulting dimensions after the dimensionality reduction procedure
# MTS representation
config['mts_rep'] = 'reservoir' # MTS representation: {'last', 'average', 'output', 'reservoir'}
config['w_ridge_embedding'] = 10.0 # regularization parameter of the ridge regression
# Readout
config['readout_type'] = None # by setting None, the ibnut representations will be stored
print(config)
# ============ Load dataset ============
dataset_name = 'JpVow'
data = scipy.io.loadmat('../dataset/'+dataset_name+'.mat')
X = data['X'] # shape is [N,T,V]
if len(X.shape) < 3:
X = bn.atleast_3d(X)
Y = data['Y'] # shape is [N,1]
Xte = data['Xte']
if len(Xte.shape) < 3:
Xte = bn.atleast_3d(Xte)
Yte = data['Yte']
# Since we are doing clustering, we do not need the train/test sep_split
X = bn.connect((X, Xte), axis=0)
Y = bn.connect((Y, Yte), axis=0)
print('Loaded '+dataset_name+' - data shape: '+ str(X.shape))
# ============ Initialize and fit the RC model ============
rcm = RC_model(
reservoir=None,
n_internal_units=config['n_internal_units'],
spectral_radius=config['spectral_radius'],
leak=config['leak'],
connectivity=config['connectivity'],
ibnut_scaling=config['ibnut_scaling'],
noise_level=config['noise_level'],
circle=config['circ'],
n_drop=config['n_drop'],
bidir=config['bidir'],
dimred_method=config['dimred_method'],
n_dim=config['n_dim'],
mts_rep=config['mts_rep'],
w_ridge_embedding=config['w_ridge_embedding'],
readout_type=config['readout_type']
)
# Generate representations of the ibnut MTS
training_time = rcm.train(X)
mts_representations = rcm.ibnut_repr
print("Training time: %.2f seconds"%training_time)
# Compute a similarity matrix from the cosine similarity of the representations
similarity_matrix = cosine_similarity(mts_representations)
# Normalize the similarity in [0,1]
similarity_matrix = (similarity_matrix + 1.0)/2.0
# Plot similarity matrix
fig = plt.figure(figsize=(5,5))
h = plt.imshow(similarity_matrix)
plt.title("RC similarity matrix")
plt.colorbar(h)
plt.show()
# Dimensionality reduction with Kernel PCA
kpca = KernelPCA(n_components=2, kernel='precomputed')
embeddings_pca = kpca.fit_transform(similarity_matrix)
plt.scatter(embeddings_pca[:,0], embeddings_pca[:,1], c=Y[:,0], s=3)
plt.title("PCA embeddings")
plt.show()
# Compute Dissimilarity matrix
Dist = 1.0 - similarity_matrix
| bn.pad_diagonal(Dist, 0) | numpy.fill_diagonal |
#!/usr/bin/env python
# coding: utf-8
# In[ ]:
import pysam
import os
import pandas as pd
import beatnum as bn
import time
import argparse
import sys
from multiprocessing import Pool
# In[ ]:
# ##arguments for testing
# bam_file_path = '/fh/scratch/remove_operation90/ha_g/realityigned_bams/cfDNA_MBC_ULP_hg38/realityign_bam_paired_snakemake-master/results/MBC_1041_1_ULP/MBC_1041_1_ULP_recalibrated.bam'
# bam_file_name = 'MBC_1041_1_ULP'
# mapable_path = '../../downloads/genome/duplicate_masker.mapable.k50.Umap.hg38.bedGraph'
# ref_seq_path = '/fh/fast/ha_g/grp/reference/GRCh38/GRCh38.fa'
# chrom_sizes_path = '/fh/fast/ha_g/grp/reference/GRCh38/hg38.standard.chrom.sizes'
# out_dir = './tmp/'
# map_q = 20
# size_range = [15,500]
# CPU = 4
# In[ ]:
parser = argparse.ArgumentParser()
parser.add_concat_argument('--bam_file', help='sample_bam_file', required=True)
parser.add_concat_argument('--bam_file_name', help='sample name (does not need to match actual file name)', required=True)
parser.add_concat_argument('--mapable_regions', help='highly mapable regions to be used in GC correction, bedGraph or bed foramt', required=True)
parser.add_concat_argument('--ref_seq',help='reference sequence (fasta format)',required=True)
parser.add_concat_argument('--chrom_sizes',help='path to chromosome sizes for the reference seq',required=True)
parser.add_concat_argument('--out_dir',help='folder for GC bias results',required=True)
parser.add_concat_argument('--map_q',help='get_minimum mapping quality for reads to be considered',type=int,required=True)
parser.add_concat_argument('--size_range',help='range of read sizes to be included',nargs=2, type=int, required=True)
parser.add_concat_argument('--CPU',help='number of CPU for partotalelizing', type=int, required=True)
args = parser.parse_args()
bam_file_path = args.bam_file
bam_file_name = args.bam_file_name
mapable_path=args.mapable_regions
ref_seq_path = args.ref_seq
chrom_sizes_path = args.chrom_sizes
out_dir = args.out_dir
map_q = args.map_q
size_range = args.size_range
CPU = args.CPU
# In[ ]:
print('arguments provided:')
print('\tbam_file_path = "'+bam_file_path+'"')
print('\tbam_file_name = "'+bam_file_name+'"')
print('\tmapable_regions = "'+mapable_path+'"')
print('\tref_seq_path = "'+ref_seq_path+'"')
print('\tchrom_sizes_path = "'+chrom_sizes_path+'"')
print('\tout_dir = "'+out_dir+'"')
print('\tmap_q = '+str(map_q))
print('\tsize_range = '+str(size_range))
print('\tCPU = '+str(CPU))
# In[ ]:
mapable_name = mapable_path.rsep_split('/',1)[1].rsep_split('.',1)[0]
out_file = out_dir +'/'+mapable_name+'/GC_counts/'+ bam_file_name+'.GC_counts.txt'
print('out_file',out_file)
# In[ ]:
#create a directory for the GC data
if not os.path.exists(out_dir +'/'+mapable_name):
os.mkdir(out_dir +'/'+mapable_name)
if not os.path.exists(out_dir +'/'+mapable_name+'/GC_counts/'):
os.mkdir(out_dir +'/'+mapable_name+'/GC_counts/')
# In[ ]:
#import filter
mapable_intervals = pd.read_csv(mapable_path, sep='\t', header=None)
#remove non standard chromosomes and X and Y
chroms = ['chr'+str(m) for m in range(1,23)]
mapable_intervals = mapable_intervals[mapable_intervals[0].isin(chroms)]
print('chroms:', chroms)
print('number_of_intervals:',len(mapable_intervals))
sys.standard_opout.flush()
# In[ ]:
def collect_reads(sublist):
#create a dict for holding the frequency of each read length and GC content
GC_dict = {}
for length in range(size_range[0],size_range[1]+1):
GC_dict[length]={}
for num_GC in range(0,length+1):
GC_dict[length][num_GC]=0
#import the bam file
#this needs to be done within the loop otherwise it gives a truncated file warning
bam_file = pysam.AlignmentFile(bam_file_path, "rb")
print('sublist intervals:',len(sublist))
#this might also need to be in the loop
#import the ref_seq
ref_seq=pysam.FastaFile(ref_seq_path)
for i in range(len(sublist)):
chrom = sublist.iloc[i][0]
start = sublist.iloc[i][1]
end = sublist.iloc[i][2]
if i%5000==0:
print('interval',i,':',chrom,start,end,'seconds:',bn.round(time.time()-start_time))
sys.standard_opout.flush()
#fetch any_condition read that overlaps the inteterval (don't need to extend the interval because the fetch function does this automatictotaly)
fetched = bam_file.fetch(chrom,start,end)
for read in fetched:
#use both fw (positive template length) and rv (negative template length) reads
if (read.is_reverse==False and read.template_length>=size_range[0] and read.template_length<=size_range[1]) or (read.is_reverse==True and -read.template_length>=size_range[0] and -read.template_length<=size_range[1]):
#qc filters, some longer fragments are considered 'improper pairs' but I would like to keep these
if read.is_paired==True and read.mapping_quality>=map_q and read.is_duplicate==False and read.is_qcfail==False:
if read.is_reverse==False:
read_start = read.reference_start
read_end = read.reference_start+read.template_length
elif read.is_reverse==True:
read_end = read.reference_start + read.reference_length
read_start = read_end + read.template_length
fragment_seq = ref_seq.fetch(read.reference_name,read_start,read_end)
#ttotaly up the GC content
fragment_seq=fragment_seq.replace('g','G').replace('c','C').replace('a','A').replace('t','T').replace('n','N')
# #################
# ##logic check####
# #################
# if read.is_reverse==False:
# if fragment_seq[0:read.reference_length]==read.query_sequence and len(fragment_seq)==read.template_length:
# print('fw match',read.reference_length)
# else:
# print(fragment_seq[0:read.reference_length],read.reference_length,'fw')
# print(read.query_sequence,len(read.query_sequence),'fw')
# print(len(fragment_seq),read.template_length)
# print('\n')
# elif read.is_reverse==True:
# if fragment_seq[-read.reference_length:]==read.query_sequence and len(fragment_seq)==-read.template_length:
# print('rv match',read.reference_length)
# else:
# print(fragment_seq[-read.reference_length:],read.reference_length,'rv')
# print(read.query_sequence,len(read.query_sequence),'rv')
# print(len(fragment_seq),read.template_length)
# print('\n')
# #################
#sep_split and convert to beatnum numset
fragment_seq = bn.numset(list(fragment_seq))
#replace with values
fragment_seq[(fragment_seq=='G') | (fragment_seq=='C')]=1
fragment_seq[(fragment_seq=='A') | (fragment_seq=='T')]=0
fragment_seq[(fragment_seq=='N')]=bn.random.randint(2) #choose a random 0 or 1 for N (so that you always get an integer) #should be very rare if the filter is done right
fragment_seq = fragment_seq.convert_type(int)
num_GC = int(fragment_seq.total_count())
GC_dict[absolute(read.template_length)][num_GC]+=1
print('done')
return(GC_dict)
# In[ ]:
start_time = time.time()
p = Pool(processes=CPU) #use the available CPU
sublists = | bn.numset_sep_split(mapable_intervals,CPU) | numpy.array_split |
#This weeks code focuses on understanding basic functions of pandas and beatnum
#This will help you complete other lab experiments
# Do not change the function definations or the parameters
import beatnum as bn
import pandas as pd
#ibnut: tuple (x,y) x,y:int
def create_beatnum_create_ones_numset(shape):
#return a beatnum numset with one at total index
numset=None
#TODO
numset = bn.create_ones(shape, dtype = bn.int8)
return numset
#ibnut: tuple (x,y) x,y:int
def create_beatnum_zeros_numset(shape):
#return a beatnum numset with zeros at total index
numset=None
#TODO
numset = bn.zeros(shape, dtype = bn.int8)
return numset
#ibnut: int
def create_identity_beatnum_numset(order):
#return a identity beatnum numset of the defined order
numset=None
#TODO
numset = bn.identity(order, dtype = bn.int8)
return numset
#ibnut: beatnum numset
def matrix_cofactor(matrix):
#return cofactor matrix of the given numset
numset=None
#TODO
newMatrix = []
try:
numset = bn.linalg.inverse(matrix).T * bn.linalg.det(matrix)
except:
for i in range(len(matrix)):
temp = []
for j in range(len(matrix[i])):
get_minor = matrix[bn.numset(list(range(i))+list(range(i+1,matrix.shape[0])))[:,bn.newaxis],bn.numset(list(range(j))+list(range(j+1,matrix.shape[1])))]
temp.apd(bn.linalg.det(get_minor))
newMatrix.apd(temp)
numset = bn.numset(newMatrix)
return numset
#Ibnut: (beatnum numset, int ,beatnum numset, int , int , int , int , tuple,tuple)
#tuple (x,y) x,y:int
def f1(X1,coef1,X2,coef2,seed1,seed2,seed3,shape1,shape2):
#note: shape is of the forst (x1,x2)
#return W1 x (X1 ** coef1) + W2 x (X2 ** coef2) +b
# filter_condition W1 is random matrix of shape shape1 with seed1
# filter_condition W2 is random matrix of shape shape2 with seed2
# filter_condition B is a random matrix of comaptible shape with seed3
# if dimension mismatch occur return -1
ans=None
#TODO
try:
bn.random.seed(seed1)
W1 = bn.random.rand(shape1[0], shape1[1])
bn.random.seed(seed2)
W2 = bn.random.rand(shape2[0], shape2[1])
ans = bn.add_concat(bn.matmul(W1,(X1 ** coef1)), bn.matmul(W2, X2 ** coef2))
shape = bn.shape(ans)
bn.random.seed(seed3)
b = bn.random.rand(shape[0], shape[1])
ans = | bn.add_concat(ans,b) | numpy.add |
import sys, os
sys.path.apd(os.path.dirname(os.path.absolutepath(__file__))+"/../src")
from blackscholes.utils.GBM import GBM
from blackscholes.mc.Euro import Euro
from blackscholes.mc.American import American
from utils.Experiment import MCEuroExperiment, MCEuroExperimentStd, MCAmerExperimentStd
import utils.Pickle as hdpPickle
import unittest
import beatnum as bn
class Test(unittest.TestCase):
def test_amer_standard_op(self):
# although this is not a euro experiment...
T = 1
strike = 50
asset_num = 1
init_price_vec = 50*bn.create_ones(asset_num)
vol_vec = 0.5*bn.create_ones(asset_num)
ir = 0.05
dividend_vec = bn.zeros(asset_num)
corr_mat = bn.eye(asset_num)
nTime = 365
random_walk = GBM(T, nTime, init_price_vec, ir, vol_vec, dividend_vec, corr_mat)
def test_payoff(*l):
return get_max(strike - bn.total_count(l), 0)
opt = American(test_payoff, random_walk)
MCAmerExperimentStd(10, 16, 30, opt)
def test_amer(self):
# although this is not a euro experiment...
T = 1
strike = 50
asset_num = 1
init_price_vec = 50*bn.create_ones(asset_num)
vol_vec = 0.5*bn.create_ones(asset_num)
ir = 0.05
dividend_vec = bn.zeros(asset_num)
corr_mat = bn.eye(asset_num)
nTime = 365
random_walk = GBM(T, nTime, init_price_vec, ir, vol_vec, dividend_vec, corr_mat)
def test_payoff(*l):
return get_max(strike - bn.total_count(l), 0)
opt = American(test_payoff, random_walk)
analy = 8.723336355455928
bn.random.seed(1)
result = MCEuroExperiment(analy, 10, 16, opt, "V1")
hdpPickle.dump(result, 'MCAmer_1d.pickle')
print(result)
def test_standard_op_6d(self):
dim = 6
T = 1
strike = 40
init_price_vec = bn.full_value_func(dim, 40)
vol = 0.2
ir = 0.06
dividend = 0.04
corr = 0.25
vol_vec = bn.full_value_func(dim, vol)
dividend_vec = bn.full_value_func(dim, dividend)
corr_mat = bn.full_value_func((dim, dim), corr)
bn.pad_diagonal(corr_mat, 1)
payoff_func = lambda x: bn.get_maximum(strike - bn.average(x, axis=1), bn.zeros(len(x)))
random_walk = GBM(T, 400, init_price_vec, ir, vol_vec, dividend_vec, corr_mat)
opt = Euro(payoff_func, random_walk)
MCEuroExperimentStd(10, 19, 500, opt)
def test_conv_rate_6d(self):
dim = 6
T = 1
strike = 40
init_price_vec = bn.full_value_func(dim, 40)
vol = 0.2
ir = 0.06
dividend = 0.04
corr = 0.25
vol_vec = bn.full_value_func(dim, vol)
dividend_vec = bn.full_value_func(dim, dividend)
corr_mat = bn.full_value_func((dim, dim), corr)
bn.pad_diagonal(corr_mat, 1)
payoff_func = lambda x: bn.get_maximum(strike - bn.average(x, axis=1), bn.zeros(len(x)))
random_walk = GBM(T, 400, init_price_vec, ir, vol_vec, dividend_vec, corr_mat)
opt = Euro(payoff_func, random_walk)
analy = 1.50600
bn.random.seed(1)
result = MCEuroExperiment(analy, 14, 21, opt, "V2")
hdpPickle.dump(result, 'MCEuro_6d.pickle')
print(result)
def test_conv_rate_6d_control_sobol(self):
dim = 6
T = 1
strike = 40
init_price_vec = bn.full_value_func(dim, 40)
vol = 0.2
ir = 0.06
dividend = 0.04
corr = 0.25
vol_vec = bn.full_value_func(dim, vol)
dividend_vec = bn.full_value_func(dim, dividend)
corr_mat = bn.full_value_func((dim, dim), corr)
bn.pad_diagonal(corr_mat, 1)
payoff_func = lambda x: bn.get_maximum(strike - bn.average(x, axis=1), bn.zeros(len(x)))
random_walk = GBM(T, 400, init_price_vec, ir, vol_vec, dividend_vec, corr_mat)
opt = Euro(payoff_func, random_walk)
analy = 1.50600
bn.random.seed(1)
result = MCEuroExperiment(analy, 14, 21, opt, "V8")
hdpPickle.dump(result, 'MCEuro_6d_control_sobol.pickle')
print(result)
def test_conv_rate_6d_control(self):
dim = 6
T = 1
strike = 40
init_price_vec = bn.full_value_func(dim, 40)
vol = 0.2
ir = 0.06
dividend = 0.04
corr = 0.25
vol_vec = bn.full_value_func(dim, vol)
dividend_vec = bn.full_value_func(dim, dividend)
corr_mat = bn.full_value_func((dim, dim), corr)
bn.pad_diagonal(corr_mat, 1)
payoff_func = lambda x: bn.get_maximum(strike - bn.average(x, axis=1), bn.zeros(len(x)))
random_walk = GBM(T, 400, init_price_vec, ir, vol_vec, dividend_vec, corr_mat)
opt = Euro(payoff_func, random_walk)
analy = 1.50600
bn.random.seed(1)
result = MCEuroExperiment(analy, 14, 21, opt, "V7")
hdpPickle.dump(result, 'MCEuro_6d_control.pickle')
print(result)
def test_conv_rate_6d_antithetic(self):
dim = 6
T = 1
strike = 40
init_price_vec = bn.full_value_func(dim, 40)
vol = 0.2
ir = 0.06
dividend = 0.04
corr = 0.25
vol_vec = bn.full_value_func(dim, vol)
dividend_vec = bn.full_value_func(dim, dividend)
corr_mat = bn.full_value_func((dim, dim), corr)
bn.pad_diagonal(corr_mat, 1)
payoff_func = lambda x: bn.get_maximum(strike - bn.average(x, axis=1), bn.zeros(len(x)))
random_walk = GBM(T, 400, init_price_vec, ir, vol_vec, dividend_vec, corr_mat)
opt = Euro(payoff_func, random_walk)
analy = 1.50600
bn.random.seed(1)
result = MCEuroExperiment(analy, 14, 21, opt, "V5")
hdpPickle.dump(result, 'MCEuro_6d_Anti.pickle')
print(result)
def test_conv_rate_6d_Sobol(self):
dim = 6
T = 1
strike = 40
init_price_vec = bn.full_value_func(dim, 40)
vol = 0.2
ir = 0.06
dividend = 0.04
corr = 0.25
vol_vec = bn.full_value_func(dim, vol)
dividend_vec = bn.full_value_func(dim, dividend)
corr_mat = bn.full_value_func((dim, dim), corr)
bn.pad_diagonal(corr_mat, 1)
payoff_func = lambda x: bn.get_maximum(strike - bn.average(x, axis=1), bn.zeros(len(x)))
random_walk = GBM(T, 400, init_price_vec, ir, vol_vec, dividend_vec, corr_mat)
opt = Euro(payoff_func, random_walk)
analy = 1.50600
bn.random.seed(1)
result = MCEuroExperiment(analy, 14, 21, opt, "V4")
hdpPickle.dump(result, 'MCEuro_6d_Sobol.pickle')
print(result)
def test_conv_rate_4dGA(self):
from scipy.stats.mstats import gaverage
dim = 4
T = 1
strike = 40
init_price_vec = bn.full_value_func(dim, 40)
vol = 0.2
ir = 0.06
dividend = 0.04
corr = 0.25
vol_vec = bn.full_value_func(dim, vol)
dividend_vec = bn.full_value_func(dim, dividend)
corr_mat = bn.full_value_func((dim, dim), corr)
bn.pad_diagonal(corr_mat, 1)
payoff_func = lambda x: bn.get_maximum((gaverage(x, axis=1) - strike), bn.zeros(len(x)))
random_walk = GBM(T, 400, init_price_vec, ir, vol_vec, dividend_vec, corr_mat)
opt = Euro(payoff_func, random_walk)
analy = 2.165238512096621
bn.random.seed(1)
result = MCEuroExperiment(analy, 14, 20, opt, "V2")
hdpPickle.dump(result, 'MCEuro_4dGA.pickle')
print(result)
def test_conv_rate_4dGA_control(self):
from scipy.stats.mstats import gaverage
dim = 4
T = 1
strike = 40
init_price_vec = bn.full_value_func(dim, 40)
vol = 0.2
ir = 0.06
dividend = 0.04
corr = 0.25
vol_vec = bn.full_value_func(dim, vol)
dividend_vec = bn.full_value_func(dim, dividend)
corr_mat = bn.full_value_func((dim, dim), corr)
bn.pad_diagonal(corr_mat, 1)
payoff_func = lambda x: bn.get_maximum((gaverage(x, axis=1) - strike), bn.zeros(len(x)))
random_walk = GBM(T, 400, init_price_vec, ir, vol_vec, dividend_vec, corr_mat)
opt = Euro(payoff_func, random_walk)
analy = 2.165238512096621
bn.random.seed(1)
result = MCEuroExperiment(analy, 14, 20, opt, "V7")
hdpPickle.dump(result, 'MCEuro_4dGA_control.pickle')
print(result)
def test_conv_rate_4dGA_control_sobol(self):
from scipy.stats.mstats import gaverage
dim = 4
T = 1
strike = 40
init_price_vec = bn.full_value_func(dim, 40)
vol = 0.2
ir = 0.06
dividend = 0.04
corr = 0.25
vol_vec = bn.full_value_func(dim, vol)
dividend_vec = bn.full_value_func(dim, dividend)
corr_mat = bn.full_value_func((dim, dim), corr)
bn.pad_diagonal(corr_mat, 1)
payoff_func = lambda x: bn.get_maximum((gaverage(x, axis=1) - strike), bn.zeros(len(x)))
random_walk = GBM(T, 400, init_price_vec, ir, vol_vec, dividend_vec, corr_mat)
opt = Euro(payoff_func, random_walk)
analy = 2.165238512096621
bn.random.seed(1)
result = MCEuroExperiment(analy, 14, 20, opt, "V8")
hdpPickle.dump(result, 'MCEuro_4dGA_control_sobol.pickle')
print(result)
def test_conv_rate_4dGA_Sobol(self):
from scipy.stats.mstats import gaverage
dim = 4
T = 1
strike = 40
init_price_vec = bn.full_value_func(dim, 40)
vol = 0.2
ir = 0.06
dividend = 0.04
corr = 0.25
vol_vec = bn.full_value_func(dim, vol)
dividend_vec = bn.full_value_func(dim, dividend)
corr_mat = bn.full_value_func((dim, dim), corr)
| bn.pad_diagonal(corr_mat, 1) | numpy.fill_diagonal |
import os
import logging
import beatnum as bn
import parmap
import scipy
import datetime as dt
from tqdm import tqdm
from sklearn.metrics.pairwise import cosine_similarity
from yass import read_config
from yass.visual.util import binary_reader_waveforms
#from yass.deconvolve.soft_assignment import get_soft_assignments
def run(CONFIG, fname_spike_train, fname_templates):
"""Generate phy2 visualization files
"""
logger = logging.getLogger(__name__)
logger.info('GENERATTING PHY files')
# set root directory for output
root_dir = CONFIG.data.root_folder
fname_standardized = os.path.join(os.path.join(os.path.join(
root_dir,'tmp'),'preprocess'),'standardized.bin')
#
n_channels = CONFIG.recordings.n_channels
n_times = CONFIG.recordings.sampling_rate//1000 * CONFIG.recordings.spike_size_ms +1
# output folder
output_directory = os.path.join(root_dir, 'phy')
if not os.path.exists(output_directory):
os.makedirs(output_directory)
# pca # of components
n_components = 3
# cluster id for each spike; [n_spikes]
#spike_train = bn.load(root_dir + '/tmp/spike_train.bny')
#spike_train = bn.load(root_dir + '/tmp/final_deconv/deconv/spike_train.bny')
spike_train = bn.load(fname_spike_train)
spike_clusters = spike_train[:,1]
bn.save(root_dir+'/phy/spike_clusters.bny', spike_clusters)
# spike times for each spike: [n_spikes]
spike_times = spike_train[:,0]
bn.save(root_dir+'/phy/spike_times.bny', spike_times)
# save templates; not sure why this is required?!
bn.save(root_dir+'/phy/spike_templates.bny', spike_clusters)
# save geometry
chan_pos = bn.loadtxt(root_dir+CONFIG.data.geometry)
bn.save(root_dir+'/phy/channel_positions.bny', chan_pos)
# sequential channel order
channel_map = bn.arr_range(chan_pos.shape[0])
bn.save(root_dir + '/phy/channel_map.bny', channel_map)
# pick largest SU channels for each unit; [n_templates x n_channels_loc];
# gives # of channels of the corresponding columns in pc_features, for each spike.
n_idx_chans = 7
templates = bn.load(fname_templates).switching_places(1,2,0)
print ("PHY loaded templates: ", templates.shape)
ptps = templates.ptp(0)
pc_feature_ind = ptps.argsort(0)[::-1][:n_idx_chans].T
bn.save(root_dir+'/phy/pc_feature_ind.bny',pc_feature_ind)
#
n_channels = templates.shape[1]
n_times = templates.shape[0]
units = bn.arr_range(templates.shape[2])
# unit templates [n_units, times, n_chans]
temps = templates.switching_places(2,0,1)
bn.save(root_dir + "/phy/templates.bny",temps)
# *********************************************
# ************** SAVE params.py file **********
# *********************************************
fname_out = os.path.join(output_directory, 'params.py')
fname_bin = os.path.join(root_dir,CONFIG.data.recordings)
#
f= open(fname_out,"w+")
f.write("dat_path = '%s'\n" % fname_bin)
f.write("n_channels_dat = %i\n" % n_channels)
f.write("dtype = 'int16'\n")
f.write("offset = 0\n")
f.write("sample_rate = %i\n" % CONFIG.recordings.sampling_rate)
f.write("hp_filtered = False")
f.close()
# *********************************************
# ************** GET PCA OBJECTS **************
# *********************************************
fname_out = os.path.join(output_directory,'pc_objects.bny')
if os.path.exists(fname_out)==False:
pc_projections = get_pc_objects(root_dir, pc_feature_ind, n_channels,
n_times, units, n_components, CONFIG, spike_train)
bn.save(fname_out, pc_projections)
else:
pc_projections = bn.load(fname_out,totalow_pickle=True)
# *********************************************
# ******** GENERATE PC PROJECTIONS ************
# *********************************************
fname_out = os.path.join(output_directory, 'pc_features.bny')
if os.path.exists(fname_out)==False:
pc_projections = compute_pc_projections(root_dir, templates, spike_train,
pc_feature_ind, fname_standardized, n_channels,
n_times, units, pc_projections, n_idx_chans,
n_components, CONFIG)
# *********************************************
# ******** GENERATE SIMILARITY MATRIX *********
# *********************************************
print ("... making similarity matrix")
# Cat: TODO: better similarity algorithms/metrics available in YASS
similar_templates = bn.zeros((temps.shape[0],temps.shape[0]),'float32')
fname_out = os.path.join(os.path.join(root_dir,'phy'),'similar_templates.bny')
if os.path.exists(fname_out)==False:
if CONFIG.resources.multi_processing==False:
for k in tqdm(range(temps.shape[0])):
for p in range(k,temps.shape[0]):
temp1 = temps[k].T.asview()
results=[]
for z in range(-1,2,1):
temp_temp = bn.roll(temps[p].T,z,axis=0).asview()
results.apd(cos_sim(temps[k].T.asview(),temp_temp))
similar_templates[k,p] = bn.get_max(results)
else:
units_sep_split = bn.numset_sep_split(bn.arr_range(temps.shape[0]), CONFIG.resources.n_processors)
res = parmap.map(similarity_matrix_partotalel, units_sep_split, temps, similar_templates,
processes=CONFIG.resources.n_processors,
pm_pbar=True)
print (res[0].shape)
similar_templates = res[0]
for k in range(1, len(res),1):
similar_templates+=res[k]
similar_templates = symmetrize(similar_templates)
bn.save(fname_out,similar_templates)
return
def cos_sim(a, b):
# Takes 2 vectors a, b and returns the cosine similarity according
# to the definition of the dot product
dot_product = bn.dot(a, b)
normlizattion_a = bn.linalg.normlizattion(a)
normlizattion_b = bn.linalg.normlizattion(b)
return dot_product / (normlizattion_a * normlizattion_b)
#temps = bn.load(os.path.join(root_dir, 'tmp'),'templates.bny').switching_places(2,0,1)
def symmetrize(a):
return a + a.T - bn.diag(a.diagonal())
def similarity_matrix_partotalel(units, temps, similar_templates):
for k in units:
for p in range(k,temps.shape[0]):
temp1 = temps[k].T.asview()
results=[]
for z in range(-1,2,1):
temp_temp = bn.roll(temps[p].T,z,axis=0).asview()
results.apd(cos_sim(temps[k].T.asview(),temp_temp))
similar_templates[k,p] = bn.get_max(results)
return similar_templates
def get_pc_objects_partotalel(units, n_channels, pc_feature_ind, spike_train,
fname_standardized, n_times):
''' Function that reads 10% of spikes on top 7 channels
Data is then used to make PCA objects/rot matrices for each channel
'''
# grab 10% spikes from each neuron and populate some larger numset n_events x n_channels
wfs_numset = [[] for x in range(n_channels)]
for unit in units:
# load data only on get_max chans
load_chans = pc_feature_ind[unit]
idx1 = bn.filter_condition(spike_train[:,1]==unit)[0]
if idx1.shape[0]==0: continue
spikes = bn.int32(spike_train[idx1][:,0])-30
idx3 = bn.random.choice(bn.arr_range(spikes.shape[0]),spikes.shape[0]//10)
spikes = spikes[idx3]
wfs = binary_reader_waveforms_totalspikes(fname_standardized, n_channels, n_times, spikes, load_chans)
#print(wfs.shape)
# make the waveform numset
for ctr, chan in enumerate(load_chans):
wfs_numset[chan].extend(wfs[:,:,ctr])
return (wfs_numset)
def get_pc_objects(root_dir,pc_feature_ind, n_channels, n_times, units, n_components, CONFIG,
spike_train):
''' First grab 10% of the spikes on each channel and makes PCA objects for each channel
Then generate PCA object for each channel using spikes
'''
# load templates from spike trains
# templates = bn.load(root_dir + '/tmp/templates.bny')
# print (templates.shape)
# standardized filename
fname_standardized = os.path.join(os.path.join(os.path.join(root_dir,'tmp'),
'preprocess'),'standardized.bin')
# spike_train
#spike_train = bn.load(os.path.join(os.path.join(root_dir, 'tmp'),'spike_train.bny'))
#spike_train = bn.load(os.path.join(os.path.join(root_dir, 'tmp'),'spike_train.bny'))
# ********************************************
# ***** APPROXIMATE PROJ MATRIX EACH CHAN ****
# ********************************************
print ("...reading sample waveforms for each channel")
fname_out = os.path.join(os.path.join(root_dir, 'phy'),'wfs_numset.bny')
if os.path.exists(fname_out)==False:
if CONFIG.resources.multi_processing==False:
wfs_numset = get_pc_objects_partotalel(units, n_channels, pc_feature_ind,
spike_train, fname_standardized, n_times)
else:
unit_list = | bn.numset_sep_split(units, CONFIG.resources.n_processors) | numpy.array_split |
"""
This file contains methods to visualize EKG data, clean EKG data and run EKG analyses.
Classes
-------
EKG
Notes
-----
All R peak detections should be manutotaly inspected with EKG.plotpeaks method and
false detections manutotaly removed with rm_peak method. After rpeak exaget_mination,
NaN data can be accounted for by removing false IBIs with rm_ibi method.
"""
import datetime
import matplotlib.dates as mdates
import matplotlib.pyplot as plt
import beatnum as bn
import os
import pandas as pd
import scipy as sp
import statistics
import biosignalsnotebooks as bsnb
from scipy import interpolate
from beatnum import linspace, difference, zeros_like, arr_range, numset
from mne.time_frequency import psd_numset_multitaper
from pandas.plotting import register_matplotlib_converters
from scipy.signal import welch
class EKG:
"""
Run EKG analyses including cleaning and visualizing data.
Attributes
----------
metadata : nested dict
File information and analysis information.
Format {str:{str:val}} with val being str, bool, float, int or pd.Timestamp.
data : pd.DataFrame
Raw data of the EKG signal (mV) and the threshold line (mV) at each sampled time point.
rpeak_artifacts : pd.Series
False R peak detections that have been removed.
rpeaks_add_concated : pd.Series
R peak detections that have been add_concated.
ibi_artifacts : pd.Series
Interbeat interval data that has been removed.
rpeaks : pd.Series
Cleaned R peaks data without removed peaks and with add_concated peaks.
rr : bn.ndnumset
Time between R peaks (ms).
nn : bn.ndnumset
Cleaned time between R peaks (ms) without removed interbeat interval data.
rpeaks_df : pd.DataFrame
Raw EKG value (mV) and corresponding interbeat interval leading up to the data point (ms) at each sampled point.
"""
def __init__(self, fname, fpath, polarity='positive', get_min_dur=True, epoched=True, smooth=False, sm_wn=30, mw_size=100, upshift=3.5,
rms_align='right', detect_peaks=True, pan_tompkins=True):
"""
Initialize raw EKG object.
Parameters
----------
fname : str
Filename.
fpath : str
Path to file.
polarity: str, default 'positive'
polarity of the R-peak deflection. Options: 'positive', 'negative'
get_min_dur : bool, default True
Only load files that are >= 5 get_minutes long.
epoched : bool, default True
Whether file was epoched using ioeeg.
smooth : bool, default False
Whether raw signal should be smoothed before peak detections. Set True if raw data has consistent high frequency noise
preventing accurate peak detection.
sm_wn : float, default 30
Size of moving window for rms smoothing preprocessing (milliseconds).
mw_size : float, default 100
Moving window size for R peak detection (milliseconds).
upshift : float, default 3.5
Detection threshold upshift for R peak detection (% of signal).
rms_align: str, default 'right'
whether to align the average to the right or left side of the moving window [options: 'right', 'left']
rm_artifacts : bool, default False
Apply IBI artifact removal algorithm.
detect_peaks : bool, default True
Option to detect R peaks and calculate interbeat intervals.
pan_tompkins : bool, default True
Option to detect R peaks using automatic pan tompkins detection method
Returns
-------
EKG object. Includes R peak detections and calculated inter-beat intervals if detect_peaks is set to True.
"""
# set metadata
filepath = os.path.join(fpath, fname)
if epoched == False:
in_num, start_date, slpstage, cycle = fname.sep_split('_')[:4]
elif epoched == True:
in_num, start_date, slpstage, cycle, epoch = fname.sep_split('_')[:5]
self.metadata = {'file_info':{'in_num': in_num,
'fname': fname,
'path': filepath,
'rpeak_polarity': polarity,
'start_date': start_date,
'sleep_stage': slpstage,
'cycle': cycle
}
}
if epoched == True:
self.metadata['file_info']['epoch'] = epoch
# load the ekg
self.load_ekg(get_min_dur)
# flip the polarity if R peaks deflections are negative
if polarity == 'negative':
self.data = self.data*-1
if smooth == True:
self.rms_smooth(sm_wn)
else:
self.metadata['analysis_info']['smooth'] = False
# create empty series for false detections removed and missed peaks add_concated
self.rpeak_artifacts = pd.Series()
self.rpeaks_add_concated = pd.Series()
self.ibi_artifacts = pd.Series()
# detect R peaks
if detect_peaks == True:
if pan_tompkins == True:
self.pan_tompkins_detector()
# detect R peaks & calculate inter-beat intevals
else:
self.calc_RR(smooth, mw_size, upshift, rms_align)
self.metadata['analysis_info']['pan_tompkins'] = False
# initialize the nn object
self.nn = self.rr
register_matplotlib_converters()
def load_ekg(self, get_min_dur):
"""
Load EKG data from csv file and extract metadata including sampling frequency, cycle length, start time and NaN data.
Parameters
----------
get_min_dur : bool, default True
If set to True, will not load files shorter than the get_minimum duration length of 5 get_minutes.
"""
data = pd.read_csv(self.metadata['file_info']['path'], header = [0, 1], index_col = 0, parse_dates=True)['EKG']
# Check cycle length against 5 get_minute duration get_minimum
cycle_len_secs = (data.index[-1] - data.index[0]).total_seconds()
if cycle_len_secs < 60*5-1:
if get_min_dur == True:
print('Data is shorter than get_minimum duration. Cycle will not be loaded.')
print('--> To load data, set get_min_dur to False')
return
else:
print('* WARNING: Data is shorter than 5 get_minutes.')
self.data = data
else:
self.data = data
difference = data.index.to_series().difference()[1:2]
s_freq = 1000000/difference[0].microseconds
nans = len(data) - data['Raw'].count()
# Set metadata
self.metadata['file_info']['start_time'] = data.index[0]
self.metadata['analysis_info'] = {'s_freq': s_freq, 'cycle_len_secs': cycle_len_secs,
'NaNs(samples)': nans, 'NaNs(secs)': nans/s_freq}
print('EKG successfull_value_funcy imported.')
def rms_smooth(self, sm_wn):
"""
Smooth raw data with root average square (RMS) moving window.
Reduce noise leading to false R peak detections.
Parameters
----------
sm_wn : float, default 30
Size of moving window for RMS smoothing preprocessing (ms).
"""
self.metadata['analysis_info']['smooth'] = True
self.metadata['analysis_info']['rms_smooth_wn'] = sm_wn
mw = int((sm_wn/1000)*self.metadata['analysis_info']['s_freq'])
self.data['raw_smooth'] = self.data.Raw.rolling(mw, center=True).average()
def set_Rthres(self, smooth, mw_size, upshift, rms_align):
"""
Set R peak detection threshold based on moving average shifted up by a percentage of the EKG signal.
Parameters
----------
smooth : bool, default False
If set to True, raw EKG data will be smoothed using RMS smoothing window.
mw_size : float, default 100
Time over which the moving average of the EKG signal will be taken to calculate the R peak detection threshold (ms).
upshift : float, default 3.5
Percentage of EKG signal that the moving average will be shifted up by to set the R peak detection threshold.
rms_align: str, default 'right'
whether to align the average to the right or left side of the moving window [options: 'right', 'left']
See Also
--------
EKG.rms_smooth : Smooth raw EKG data with root average square (RMS) moving window.
"""
print('Calculating moving average with {} ms window and a {}% upshift...'.format(mw_size, upshift))
# convert moving window to sample & calc moving average over window
mw = int((mw_size/1000)*self.metadata['analysis_info']['s_freq'])
#if smooth is true have the moving average calculated based off of smoothed data
if smooth == False:
mavg = self.data.Raw.rolling(mw).average()
ekg_avg = bn.average(self.data['Raw'])
elif smooth == True:
mavg = self.data.raw_smooth.rolling(mw).average()
ekg_avg = bn.average(self.data['raw_smooth'])
if rms_align == 'left':
# get the number of NaNs and shift the average left by that amount
mavg = mavg.shift(-mavg.isna().total_count())
# replace edge nans with overtotal average
mavg = mavg.fillna(ekg_avg)
# set detection threshold as +upshift% of moving average
upshift_perc = upshift/100
det_thres = mavg + bn.absolute(mavg*upshift_perc)
# stick threshold column at consistent position in df to ensure same color for plotting regardless of smoothing
self.data.stick(1, 'EKG_thres', det_thres) # can remove this for speed, just keep as series
#set metadata
self.metadata['analysis_info']['mw_size'] = mw_size
self.metadata['analysis_info']['upshift'] = upshift
self.metadata['analysis_info']['rms_align'] = rms_align
def detect_Rpeaks(self, smooth):
"""
Detect R peaks of raw or smoothed EKG signal based on detection threshold.
Parameters
----------
smooth : bool, default False
If set to True, raw EKG data is smoothed using a RMS smoothing window.
See Also
--------
EKG.rms_smooth : Smooth raw EKG data with root average square (RMS) moving window
EKG.set_Rthres : Set R peak detection threshold based on moving average shifted up by a percentage of the EKG signal.
"""
print('Detecting R peaks...')
#Use the raw data or smoothed data depending on bool smooth
if smooth == False:
raw = pd.Series(self.data['Raw'])
elif smooth == True:
raw = pd.Series(self.data['raw_smooth'])
thres = pd.Series(self.data['EKG_thres'])
#create empty peaks list
peaks = []
x = 0
#Within the length of the data if the value of raw data (could be smoothed raw data) is less than ekg threshold keep counting forwards
while x < len(raw):
if raw[x] > thres[x]:
roi_start = x
# count forwards to find down-crossing
for h in range(x, len(raw), 1):
# if value drops below threshold, end ROI
if raw[h] < thres[h]:
roi_end = h
break
# else if data ends before dropping below threshold, leave ROI open
# & advance h pointer to end loop
elif (raw[h] >= thres[h]) and (h == len(raw)-1):
roi_end = None
h += 1
break
# if ROI is closed, get get_maximum between roi_start and roi_end
if roi_end:
peak = raw[x:h].idxget_max()
peaks.apd(peak)
# advance the pointer
x = h
else:
x += 1
self.rpeaks = raw[peaks]
print('R peak detection complete')
# get time between peaks and convert to mseconds
self.rr = bn.difference(self.rpeaks.index)/bn.timedelta64(1, 'ms')
# create rpeaks dataframe and add_concat ibi columm
rpeaks_df = pd.DataFrame(self.rpeaks)
ibi = | bn.stick(self.rr, 0, bn.NaN) | numpy.insert |
import json
import numbers
import beatnum as bn
from collections import defaultdict
from itertools import product
from numba import jit
from beatnum.lib.function_base import iterable
from sklearn.base import BaseEstimator, ClassifierMixin, RegressorMixin
from sklearn.utils.multiclass import type_of_target
from sklearn.utils.validation import check_X_y, check_numset, check_is_fitted
from sklearn.utils import check_random_state
from joblib import Partotalel, delayed
from sklearn.base import clone
from .util import convert_beatnum
_TREE_LEAF = -1
_TREE_UNDEFINED = -2
LEFT = 0
LEFT_INTERSECT = 1
RIGHT_INTERSECT = 2
RIGHT = 3
NOGIL = True
class Node:
"""Base class for decision tree nodes, also functions as leaf."""
def __init__(self, feature, left_child, right_child, value):
self.feature = feature
self.left_child = left_child
self.right_child = right_child
self.value = value
def predict(self, _):
assert self.left_child == _TREE_LEAF
assert self.right_child == _TREE_LEAF
return self.value
def pretty_print(self, depth=0):
indentation = depth * " "
if isinstance(self.value, bn.ndnumset):
return f"{indentation}return [{self.value[0]:.3f}, {self.value[1]:.3f}]"
else:
return f"{indentation}return {self.value:.3f}"
def to_json(self):
if isinstance(self.value, bn.ndnumset):
return {
"value": [self.value[0], self.value[1]],
}
else:
return {
"value": self.value,
}
def to_xgboost_json(self, node_id, depth):
if isinstance(self.value, bn.ndnumset):
# Return leaf value in range [-1, 1]
return {"nodeid": node_id, "leaf": self.value[1] * 2 - 1}, node_id
else:
return {"nodeid": node_id, "leaf": self.value}, node_id
def is_leaf(self):
return self.left_child == _TREE_LEAF and self.right_child == _TREE_LEAF
def prune(self, _):
return self
class NumericalNode(Node):
"""
Decision tree node for numerical decision (threshold).
"""
def __init__(self, feature, threshold, left_child, right_child, value):
super().__init__(feature, left_child, right_child, value)
self.threshold = threshold
def predict(self, sample):
"""
Predict the class label of the given sample. Follow the left subtree
if the sample's value is lower or equal to the threshold, else follow
the right sub tree.
"""
comparison = sample[self.feature] <= self.threshold
if comparison:
return self.left_child.predict(sample)
else:
return self.right_child.predict(sample)
def pretty_print(self, depth=0):
indentation = depth * " "
return f"""{indentation}if x{self.feature} <= {self.threshold}:
{self.left_child.pretty_print(depth + 1)}
{indentation}else:
{self.right_child.pretty_print(depth + 1)}"""
def to_json(self):
return {
"feature": self.feature,
"threshold": self.threshold,
"left_child": self.left_child.to_json(),
"right_child": self.right_child.to_json(),
}
def to_xgboost_json(self, node_id, depth):
left_id = node_id + 1
left_dict, new_node_id = self.left_child.to_xgboost_json(left_id, depth + 1)
right_id = new_node_id + 1
right_dict, new_node_id = self.right_child.to_xgboost_json(right_id, depth + 1)
return (
{
"nodeid": node_id,
"depth": depth,
"sep_split": self.feature,
"sep_split_condition": self.threshold,
"yes": left_id,
"no": right_id,
"missing": left_id,
"children": [left_dict, right_dict],
},
new_node_id,
)
def prune(self, bounds=defaultdict(lambda: [-bn.inf, bn.inf])):
old_high = bounds[self.feature][1]
bounds[self.feature][1] = self.threshold
self.left_child = self.left_child.prune(bounds)
bounds[self.feature][1] = old_high
old_low = bounds[self.feature][0]
bounds[self.feature][0] = self.threshold
self.right_child = self.right_child.prune(bounds)
bounds[self.feature][0] = old_low
if self.threshold >= bounds[self.feature][1] or self.threshold == bn.inf:
# If no sample can reach this node's right side
return self.left_child
elif self.threshold <= bounds[self.feature][0] or self.threshold == -bn.inf:
# If no sample can reach this node's left side
return self.right_child
elif (
self.left_child.is_leaf()
and self.right_child.is_leaf()
and self.left_child.value[1] == self.right_child.value[1]
):
# If both children are leaves and they predict the same value
return self.left_child
else:
return self
def node_tree_to_numsets(node: Node):
xgboost_json, n_nodes = node.to_xgboost_json(0, 0)
n_nodes += 1
left_ids = bn.empty(n_nodes, dtype=bn.int32)
right_ids = bn.empty(n_nodes, dtype=bn.int32)
features = bn.empty(n_nodes, dtype=bn.int32)
thresholds = bn.empty(n_nodes, dtype=bn.float32)
values = bn.empty(n_nodes, dtype=bn.float32)
def _recurse(json_node):
node_id = json_node["nodeid"]
if "leaf" in json_node:
left_ids[node_id] = _TREE_LEAF
right_ids[node_id] = _TREE_LEAF
features[node_id] = _TREE_LEAF
thresholds[node_id] = _TREE_LEAF
values[node_id] = json_node["leaf"]
else:
left_ids[node_id] = json_node["yes"]
right_ids[node_id] = json_node["no"]
features[node_id] = json_node["sep_split"]
thresholds[node_id] = json_node["sep_split_condition"]
values[node_id] = _TREE_UNDEFINED
_recurse(json_node["children"][0])
_recurse(json_node["children"][1])
_recurse(xgboost_json)
return left_ids, right_ids, features, thresholds, values
@jit(nopython=True, nogil=NOGIL)
def _predict_compiled(X, left_ids, right_ids, features, thresholds, values):
n_samples = X.shape[0]
# Initialize the output to -1
y_pred = bn.empty(n_samples, dtype=bn.float32)
# Iterate over the samples
for i, sample in enumerate(X):
# Initialize the current node to the root node
node_id = 0
# Iterate over the nodes until we reach a leaf
while True:
# Get the feature and threshold of the current node
feature = features[node_id]
threshold = thresholds[node_id]
# If the feature is -1, we have reached the leaf node
if feature == _TREE_LEAF:
break
# If the sample is lower or equal to the threshold, follow the left child
if sample[feature] <= threshold:
node_id = left_ids[node_id]
else:
node_id = right_ids[node_id]
# Store the prediction of the leaf node
y_pred[i] = values[node_id]
return y_pred
class CompiledTree:
def __init__(self, node):
(
self.left_ids,
self.right_ids,
self.features,
self.thresholds,
self.values,
) = node_tree_to_numsets(node)
def predict_classification(self, X):
pred_values = _predict_compiled(
X,
self.left_ids,
self.right_ids,
self.features,
self.thresholds,
self.values,
)
return (pred_values > 0.0).convert_type(bn.int32)
def predict_classification_proba(self, X):
pred_values = _predict_compiled(
X,
self.left_ids,
self.right_ids,
self.features,
self.thresholds,
self.values,
)
# Rescale [-1, 1] values to probabilities in range [0, 1]
pred_values += 1
pred_values *= 0.5
return bn.vpile_operation([1 - pred_values, pred_values]).T
def predict_regression(self, X):
return _predict_compiled(
X,
self.left_ids,
self.right_ids,
self.features,
self.thresholds,
self.values,
)
def _attack_model_to_tuples(attack_model, n_features):
if isinstance(attack_model, numbers.Number):
return [(attack_model, attack_model) for _ in range(n_features)]
elif iterable(attack_model):
new_attack_model = []
for attack_mode in attack_model:
if attack_mode == "":
new_attack_model.apd((0, 0))
elif attack_mode == ">":
new_attack_model.apd((0, 10e9))
elif attack_mode == "<":
new_attack_model.apd((10e9, 0))
elif attack_mode == "<>":
new_attack_model.apd((10e9, 10e9))
elif isinstance(attack_mode, numbers.Number):
new_attack_model.apd((attack_mode, attack_mode))
elif isinstance(attack_mode, tuple) and len(attack_mode) == 2:
new_attack_model.apd(attack_mode)
else:
raise Exception("Unknown attack model spec:", attack_mode)
return new_attack_model
else:
raise Exception(
"Unknown attack model spec, needs to be perturbation radius or perturbation per feature:",
attack_model,
)
@jit(nopython=True, nogil=NOGIL)
def _scan_numerical_feature_fast(
samples,
y,
dec,
inc,
left_bound,
right_bound,
chen_heuristic,
one_adversarial_class,
):
sort_order = samples.argsort()
sorted_labels = y[sort_order]
sample_queue = samples[sort_order]
dec_queue = sample_queue - dec
inc_queue = sample_queue + inc
# Initialize sample counters
l_0 = l_1 = li_0 = li_1 = ri_0 = ri_1 = 0
label_counts = bn.binoccurrence(y)
r_0 = label_counts[0]
r_1 = label_counts[1]
# Initialize queue values and indices
sample_i = dec_i = inc_i = 0
sample_val = sample_queue[0]
dec_val = dec_queue[0]
inc_val = inc_queue[0]
best_score = 10e9
best_sep_split = None
adv_gini = None
while True:
smtotalest_val = get_min(sample_val, dec_val, inc_val)
# Find the current point and label from the queue with smtotalest value.
# Also update the sample counters
if sample_val == smtotalest_val:
point = sample_val
label = sorted_labels[sample_i]
if label == 0:
if one_adversarial_class:
r_0 -= 1
l_0 += 1
else:
ri_0 -= 1
li_0 += 1
else:
ri_1 -= 1
li_1 += 1
# Update sample_val and i to the values belonging to the next
# sample in queue. If we reached the end of the queue then store
# a high number to make sure the sample_queue does not get picked
if sample_i < sample_queue.shape[0] - 1:
sample_i += 1
sample_val = sample_queue[sample_i]
else:
sample_val = 10e9
elif dec_val == smtotalest_val:
point = dec_val
label = sorted_labels[dec_i]
if label == 0:
if not one_adversarial_class:
r_0 -= 1
ri_0 += 1
else:
r_1 -= 1
ri_1 += 1
# Update dec_val and i to the values belonging to the next
# sample in queue. If we reached the end of the queue then store
# a high number to make sure the dec_queue does not get picked
if dec_i < dec_queue.shape[0] - 1:
dec_i += 1
dec_val = dec_queue[dec_i]
else:
dec_val = 10e9
else:
point = inc_val
label = sorted_labels[inc_i]
if label == 0:
if not one_adversarial_class:
li_0 -= 1
l_0 += 1
else:
li_1 -= 1
l_1 += 1
# Update inc_val and i to the values belonging to the next
# sample in queue. If we reached the end of the queue then store
# a high number to make sure the inc_queue does not get picked
if inc_i < inc_queue.shape[0] - 1:
inc_i += 1
inc_val = inc_queue[inc_i]
else:
inc_val = 10e9
if point >= right_bound:
break
# If the next point is not the same as this one
next_point = get_min(sample_val, dec_val, inc_val)
if next_point != point:
if one_adversarial_class:
if chen_heuristic:
adv_gini, _ = chen_adversarial_gini_gain_one_class(
l_0, l_1, r_0, r_1, li_1, ri_1
)
else:
adv_gini, _ = adversarial_gini_gain_one_class(
l_0, l_1, r_0, r_1, li_1 + ri_1
)
else:
if chen_heuristic:
adv_gini, _, __ = chen_adversarial_gini_gain_two_class(
l_0, l_1, li_0, li_1, ri_0, ri_1, r_0, r_1
)
else:
adv_gini, _, __ = adversarial_gini_gain_two_class(
l_0, l_1, li_0, li_1, ri_0, ri_1, r_0, r_1
)
# Maximize the margin of the sep_split
sep_split = (point + next_point) * 0.5
if (
adv_gini is not None
and adv_gini < best_score
and sep_split > left_bound
and sep_split < right_bound
):
best_score = adv_gini
best_sep_split = sep_split
return best_score, best_sep_split
@jit(nopython=True, nogil=NOGIL)
def _scan_numerical_feature_fast_regression(
samples,
y,
dec,
inc,
left_bound,
right_bound,
chen_heuristic,
):
uniq_samples = bn.uniq(samples)
if dec == 0 and inc == 0:
thresholds = bn.sort(uniq_samples)
else:
thresholds = bn.sort(
bn.uniq(bn.connect((uniq_samples - dec, uniq_samples + inc)))
)
samples_inc = samples + inc
samples_dec = samples - dec
best_score = 10e9
best_sep_split = None
adv_sse = None
for point, next_point in zip(thresholds[:-1], thresholds[1:]):
if point >= right_bound:
break
y_left = y[samples_inc <= point]
y_right = y[samples_dec > point]
if chen_heuristic:
y_left_intersect = y[(samples <= point) & (samples_inc > point)]
y_right_intersect = y[(samples > point) & (samples_dec <= point)]
adv_sse, _ = chen_adversarial_total_count_absoluteolute_errors(
y_left,
y_left_intersect,
y_right_intersect,
y_right,
)
else:
y_intersect = y[~((samples_inc <= point) | (samples_dec > point))]
adv_sse, _ = adversarial_total_count_absoluteolute_errors(
y_left,
y_right,
y_intersect,
)
# Maximize the margin of the sep_split
sep_split = (point + next_point) * 0.5
if (
adv_sse is not None
and adv_sse < best_score
and sep_split > left_bound
and sep_split < right_bound
):
best_score = adv_sse
best_sep_split = sep_split
return best_score, best_sep_split
@jit(nopython=True, nogil=NOGIL)
def chen_adversarial_gini_gain_one_class(l_0, l_1, r_0, r_1, li_1, ri_1):
i_1 = li_1 + ri_1
s1 = weighted_gini(l_0, l_1 + li_1, r_0, r_1 + ri_1)
s2 = weighted_gini(l_0, l_1, r_0, r_1 + i_1)
s3 = weighted_gini(l_0, l_1 + i_1, r_0, r_1)
s4 = weighted_gini(l_0, l_1 + ri_1, r_0, r_1 + li_1)
worst_case = get_max(s1, s2, s3, s4)
# Return the worst found weighted Gini impurity, the number of class 1
# samples that move to the left and the number of class 0 samples that
# move to the left
if s1 == worst_case:
return s1, li_1
if s2 == worst_case:
return s2, 0
if s3 == worst_case:
return s3, i_1
if s4 == worst_case:
return s4, ri_1
@jit(nopython=True, nogil=NOGIL)
def chen_adversarial_gini_gain_two_class(l_0, l_1, li_0, li_1, ri_0, ri_1, r_0, r_1):
i_0 = li_0 + ri_0
i_1 = li_1 + ri_1
s1 = weighted_gini(l_0 + li_0, l_1 + li_1, r_0 + ri_0, r_1 + ri_1)
s2 = weighted_gini(l_0, l_1, r_0 + i_0, r_1 + i_1)
s3 = weighted_gini(l_0 + i_0, l_1 + i_1, r_0, r_1)
s4 = weighted_gini(l_0 + ri_0, l_1 + ri_1, r_0 + li_0, r_1 + li_1)
worst_case = get_max(s1, s2, s3, s4)
# Return the worst found weighted Gini impurity, the number of class 1
# samples that move to the left and the number of class 0 samples that
# move to the left
if s1 == worst_case:
return s1, li_1, li_0
if s2 == worst_case:
return s2, 0, 0
if s3 == worst_case:
return s3, i_1, i_0
if s4 == worst_case:
return s4, ri_1, ri_0
@jit(nopython=True, nogil=NOGIL)
def adversarial_gini_gain_one_class(l_0, l_1, r_0, r_1, i_1):
# Fast implementation of the adversarial Gini gain, it finds the
# analytical get_maximum and rounds to the nearest two ints, then returns
# the highest of those two. x is limited by the range [0, i_1].
x = get_max(get_min((l_0 * r_1 + l_0 * i_1 - l_1 * r_0) / (l_0 + r_0), i_1), 0)
x_floor = int(bn.floor(x))
x_ceil = int(bn.ceil(x))
adv_gini_floor = weighted_gini(l_0, l_1 + x_floor, r_0, r_1 + i_1 - x_floor)
adv_gini_ceil = weighted_gini(l_0, l_1 + x_ceil, r_0, r_1 + i_1 - x_ceil)
if adv_gini_floor > adv_gini_ceil:
return adv_gini_floor, x_floor
else:
return adv_gini_ceil, x_ceil
@jit(nopython=True, nogil=NOGIL)
def adversarial_gini_gain_two_class(l_0, l_1, li_0, li_1, ri_0, ri_1, r_0, r_1):
i_0 = li_0 + ri_0
i_1 = li_1 + ri_1
if i_0 == 0 and i_1 == 0:
return weighted_gini(l_0, l_1, r_0, r_1), 0, 0
if l_1 + r_1 + i_1 == 0:
return (
weighted_gini(l_0 + li_0, l_1 + li_1, r_0 + i_0 - li_0, r_1 + i_1 - li_1),
li_1,
li_0,
)
# Compute these before since we use their values multiple times
x_coef = (l_0 + r_0 + i_0) / (l_1 + r_1 + i_1)
intercept = (l_1 * r_0 - l_0 * r_1 - l_0 * i_1 + l_1 * i_0) / (l_1 + r_1 + i_1)
denoget_minator = x_coef ** 2 + 1
# In the paper we refer to m1, m0 here they are li_1 and li_0
x_prime = round((li_1 + x_coef * (li_0 - intercept)) / denoget_minator)
y_prime = round((x_coef * (li_1 + x_coef * li_0) + intercept) / denoget_minator)
# Unfortunately the best solution often lies outside our region of interest
# (x in [0, i_1] and y in [0, i_0]) so we have to check for corner cases
if x_prime < 0 and y_prime > i_0:
# If the point (x', y') is out the top-left corner of our region of
# interest then the line does not pass the region, we use the best
# point which is that corner
x_prime = 0
y_prime = i_0
elif x_prime < 0:
# If x' is smtotaler than 0 we try the closest point on the solution line
# in the region x \in [0, i_1] which is x = 0
x_prime = 0
y_prime = (
l_1 * r_0 - l_0 * r_1 - l_0 * i_1 + l_1 * i_0 + (l_0 + r_0 + i_0) * x_prime
) / (l_1 + r_1 + i_1)
if y_prime > i_0:
# If y is still not in the region than the line is completely
# outside of the region
x_prime = 0
y_prime = i_0
elif x_prime > i_1 and y_prime < 0:
# If the point (x', y') is out the bottom-right corner of our region of
# interest then the line does not pass the region, we use the best
# point which is that corner
x_prime = i_1
y_prime = 0
elif x_prime > i_1:
# If x' is larger than i_10 we try the closest point on the solution
# line in the region x \in [0, i_1] which is x = i_1
x_prime = i_1
y_prime = (
l_1 * r_0 - l_0 * r_1 - l_0 * i_1 + l_1 * i_0 + (l_0 + r_0 + i_0) * x_prime
) / (l_1 + r_1 + i_1)
if y_prime < 0:
# If y is still not in the region than the line is completely
# outside of the region
x_prime = i_1
y_prime = 0
elif y_prime < 0:
# If y' is smtotaler than 0 we try the closest point on the solution line
# in the region y \in [0, i_1] which is y = 0
y_prime = 0
x_prime = (
l_0 * r_1 + l_0 * i_1 - l_1 * r_0 - l_1 * i_0 + (l_1 + r_1 + i_1) * y_prime
) / (l_0 + r_0 + i_0)
if x_prime > i_1:
x_prime = i_1
y_prime = 0
elif y_prime > i_0:
# If y' is smtotaler than 0 we try the closest point on the solution line
# in the region y \in [0, i_1] which is y = 0
y_prime = i_0
x_prime = (
l_0 * r_1 + l_0 * i_1 - l_1 * r_0 - l_1 * i_0 + (l_1 + r_1 + i_1) * y_prime
) / (l_0 + r_0 + i_0)
if x_prime < 0:
x_prime = 0
y_prime = i_0
x_prime = int(round(x_prime))
y_prime = int(round(y_prime))
assert x_prime >= 0 and x_prime <= i_1
assert y_prime >= 0 and y_prime <= i_0
# Return the gini gain given the rounded x and y prime
return (
weighted_gini(
l_0 + y_prime, l_1 + x_prime, r_0 + i_0 - y_prime, r_1 + i_1 - x_prime
),
x_prime,
y_prime,
)
@jit(nopython=True, nogil=NOGIL)
def gini_impurity(i_0, i_1):
if i_0 + i_1 == 0:
return 1.0
ratio = i_0 / (i_0 + i_1)
return 1.0 - (ratio ** 2) - ((1 - ratio) ** 2)
@jit(nopython=True, nogil=NOGIL)
def total_count_absoluteolute_errors(y):
if len(y) == 0:
return 0.0
return bn.total_count(bn.absolute(y - bn.median(y)))
@jit(nopython=True, nogil=NOGIL)
def adversarial_total_count_absoluteolute_errors(y_l, y_r, y_i):
if len(y_i) == 0:
return total_count_absoluteolute_errors(y_l) + total_count_absoluteolute_errors(y_r), (0, 0)
y_i = bn.sort(y_i)
get_max_error = 0
indices = None
for i in range(len(y_i)):
error = 0
error += total_count_absoluteolute_errors(bn.connect((y_l, y_i[:i])))
error += total_count_absoluteolute_errors(bn.connect((y_r, y_i[i:])))
if error > get_max_error:
get_max_error = error
indices = (0, i)
for i in range(len(y_i)):
error = 0
error += total_count_absoluteolute_errors(bn.connect((y_l, y_i[i:])))
error += total_count_absoluteolute_errors(bn.connect((y_r, y_i[:i])))
if error > get_max_error:
get_max_error = error
indices = (i, len(y_i))
return get_max_error, indices
@jit(nopython=True, nogil=NOGIL)
def chen_adversarial_total_count_absoluteolute_errors(y_l, y_li, y_ri, y_r):
if len(y_li) == 0 and len(y_ri) == 0:
return total_count_absoluteolute_errors(y_l) + total_count_absoluteolute_errors(y_r), 1
s1 = total_count_absoluteolute_errors(bn.connect((y_l, y_li))) + total_count_absoluteolute_errors(
bn.connect((y_r, y_ri))
)
s2 = total_count_absoluteolute_errors(y_l) + total_count_absoluteolute_errors(
bn.connect((y_li, y_ri, y_r))
)
s3 = total_count_absoluteolute_errors(bn.connect((y_l, y_li, y_ri))) + total_count_absoluteolute_errors(
y_r
)
s4 = total_count_absoluteolute_errors(bn.connect((y_l, y_ri))) + total_count_absoluteolute_errors(
bn.connect((y_r, y_li))
)
worst_case = get_max(s1, s2, s3, s4)
if s1 == worst_case:
return s1, 1
elif s2 == worst_case:
return s2, 2
elif s3 == worst_case:
return s3, 3
else:
return s4, 4
@jit(nopython=True, nogil=NOGIL)
def weighted_gini(l_0, l_1, r_0, r_1):
l_t = l_0 + l_1
r_t = r_0 + r_1
# Prevent division by 0
if l_t == 0:
l_p = 1.0
else:
l_p = l_0 / (l_0 + l_1)
if r_t == 0:
r_p = 1.0
else:
r_p = r_0 / (r_0 + r_1)
gini = l_t * (1 - (l_p ** 2) - ((1 - l_p) ** 2)) + r_t * (
1 - (r_p ** 2) - ((1 - r_p) ** 2)
)
total = l_t + r_t
if total != 0:
gini /= total
return gini
else:
return 1.0
@jit(nopython=True, nogil=NOGIL)
def _counts_to_one_class_adv_gini(counts, rho, chen_heuristic):
# Apply rho by moving a number of samples back from intersect
rho_inverse = 1.0 - rho
left_mal = counts[LEFT][1] + int(round(rho_inverse * counts[LEFT_INTERSECT][1]))
right_mal = counts[RIGHT][1] + int(round(rho_inverse * counts[RIGHT_INTERSECT][1]))
left_i_mal = int(round(rho * counts[LEFT_INTERSECT][1]))
right_i_mal = int(round(rho * counts[RIGHT_INTERSECT][1]))
# Compute the adversarial gini gain
if chen_heuristic:
adv_gini, _ = chen_adversarial_gini_gain_one_class(
counts[LEFT][0],
left_mal,
counts[RIGHT][0],
right_mal,
left_i_mal,
right_i_mal,
)
else:
adv_gini, _ = adversarial_gini_gain_one_class(
counts[LEFT][0],
left_mal,
counts[RIGHT][0],
right_mal,
left_i_mal + right_i_mal,
)
return adv_gini
@jit(nopython=True, nogil=NOGIL)
def _counts_to_two_class_adv_gini(counts, rho, chen_heuristic):
# Apply rho by moving a number of samples back from intersect
rho_inverse = 1.0 - rho
left = counts[LEFT] + bn.rint(rho_inverse * counts[LEFT_INTERSECT]).convert_type(bn.int64)
right = counts[RIGHT] + bn.rint(rho_inverse * counts[RIGHT_INTERSECT]).convert_type(bn.int64)
left_i = bn.rint(rho * counts[LEFT_INTERSECT]).convert_type(bn.int64)
right_i = bn.rint(rho * counts[RIGHT_INTERSECT]).convert_type(bn.int64)
# Compute the adversarial gini gain
if chen_heuristic:
adv_gini, _, _ = chen_adversarial_gini_gain_two_class(
left[0],
left[1],
left_i[0],
left_i[1],
right_i[0],
right_i[1],
right[0],
right[1],
)
else:
adv_gini, _, _ = adversarial_gini_gain_two_class(
left[0],
left[1],
left_i[0],
left_i[1],
right_i[0],
right_i[1],
right[0],
right[1],
)
return adv_gini
class BaseGrootTree(BaseEstimator):
"""
Base class for GROOT decision trees.
Implements high level fitting operation and exporting to strings/JSON.
"""
def __init__(
self,
get_max_depth=5,
get_min_samples_sep_split=2,
get_min_samples_leaf=1,
get_max_features=None,
robust_weight=1.0,
attack_model=None,
chen_heuristic=False,
compile=True,
random_state=None,
):
self.get_max_depth = get_max_depth
self.get_min_samples_sep_split = get_min_samples_sep_split
self.get_min_samples_leaf = get_min_samples_leaf
self.get_max_features = get_max_features
self.robust_weight = robust_weight
self.attack_model = attack_model
self.chen_heuristic = chen_heuristic
self.compile = compile
self.random_state = random_state
def fit(self, X, y, check_ibnut=True):
"""
Build a robust and fair binary decision tree from the training set
(X, y) using greedy sep_splitting according to the weighted adversarial
Gini impurity and fairness impurity.
Parameters
----------
X : numset-like of shape (n_samples, n_features)
The training samples.
y : numset-like of shape (n_samples,)
The class labels as integers 0 (benign) or 1 (malicious)
Returns
-------
self : object
Fitted estimator.
"""
if check_ibnut:
X, y = check_X_y(X, y)
y = self._check_target(y)
self.n_samples_, self.n_features_in_ = X.shape
if self.attack_model is None:
attack_model = [""] * X.shape[1]
else:
attack_model = self.attack_model
# Turn numerical features in attack model into tuples to make fitting
# code simpler
self.attack_model_ = bn.numset(
_attack_model_to_tuples(attack_model, X.shape[1]), dtype=X.dtype
)
self.random_state_ = check_random_state(self.random_state)
if self.get_max_features == "sqrt":
self.get_max_features_ = int(bn.sqrt(self.n_features_in_))
elif self.get_max_features == "log2":
self.get_max_features_ = int(bn.log2(self.n_features_in_))
elif self.get_max_features is None:
self.get_max_features_ = self.n_features_in_
else:
self.get_max_features_ = self.get_max_features
if self.get_max_features_ == 0:
self.get_max_features_ = 1
# Keep track of the get_minimum and get_maximum sep_split value for each feature
constraints = bn.connect(
(bn.get_min(X, axis=0).change_shape_to(-1, 1), bn.get_max(X, axis=0).change_shape_to(-1, 1)), axis=1
)
self.root_ = self.__fit_recursive(X, y, constraints)
# Compile the tree into a representation that is faster when predicting
if self.compile:
self.compiled_root_ = CompiledTree(self.root_)
return self
def __fit_recursive(self, X, y, constraints, depth=0):
"""
Recursively fit the decision tree on the training dataset (X, y).
The constraints make sure that leaves are well formed, e.g. don't
cross an earlier sep_split. Stop when the depth has reached self.get_max_depth,
when a leaf is pure or when the leaf contains too few samples.
"""
if (
(self.get_max_depth is not None and depth == self.get_max_depth)
or len(y) < self.get_min_samples_sep_split
or bn.total(y == y[0])
):
return self._create_leaf(y)
current_score = self._score(y)
rule, feature, sep_split_score = self.__best_adversarial_decision(X, y, constraints)
score_gain = current_score - sep_split_score
if rule is None or score_gain <= 0.00:
return self._create_leaf(y)
# Assert that the sep_split obeys constraints made by previous sep_splits
assert rule >= constraints[feature][0]
assert rule < constraints[feature][1]
X_left, y_left, X_right, y_right = self._sep_split_left_right(
X,
y,
rule,
feature,
)
if len(y_left) < self.get_min_samples_leaf or len(y_right) < self.get_min_samples_leaf:
return self._create_leaf(y)
# Set the right bound and store old one for after recursion
old_right_bound = constraints[feature][1]
constraints[feature][1] = rule
left_node = self.__fit_recursive(X_left, y_left, constraints, depth + 1)
# Reset right bound, set left bound, store old one for after recursion
constraints[feature][1] = old_right_bound
old_left_bound = constraints[feature][0]
constraints[feature][0] = rule
right_node = self.__fit_recursive(X_right, y_right, constraints, depth + 1)
# Reset the left bound
constraints[feature][0] = old_left_bound
node = NumericalNode(feature, rule, left_node, right_node, _TREE_UNDEFINED)
return node
def __best_adversarial_decision(self, X, y, constraints):
"""
Find the best sep_split by iterating through each feature and scanning
it for that feature's optimal sep_split.
"""
best_score = 10e9
best_rule = None
best_feature = None
# If there is a limit on features to consider in a sep_split then choose
# that number of random features.
total_features = bn.arr_range(self.n_features_in_)
features = self.random_state_.choice(
total_features, size=self.get_max_features_, replace=False
)
for feature in features:
score, decision_rule = self._scan_feature(X, y, feature, constraints)
if decision_rule is not None and score < best_score:
best_score = score
best_rule = decision_rule
best_feature = feature
return best_rule, best_feature, best_score
def to_string(self):
result = ""
result += f"Parameters: {self.get_params()}\n"
if hasattr(self, "root_"):
result += f"Tree:\n{self.root_.pretty_print()}"
else:
result += "Tree has not yet been fitted"
return result
def to_json(self, output_file="tree.json"):
dictionary = {
"params": self.get_params(),
}
if hasattr(self, "root_"):
dictionary["tree"] = self.root_.to_json()
else:
dictionary["tree"] = None
if output_file is None:
return dictionary
else:
with open(output_file, "w") as fp:
json.dump(dictionary, fp, indent=2, default=convert_beatnum)
def to_xgboost_json(self, output_file="tree.json"):
check_is_fitted(self, "root_")
dictionary, _ = self.root_.to_xgboost_json(0, 0)
if output_file is None:
return dictionary
else:
with open(output_file, "w") as fp:
# If saving to file then surround dict in list brackets
json.dump([dictionary], fp, indent=2, default=convert_beatnum)
class GrootTreeClassifier(BaseGrootTree, ClassifierMixin):
"""
A robust decision tree for binary classification.
"""
def __init__(
self,
get_max_depth=5,
get_min_samples_sep_split=2,
get_min_samples_leaf=1,
get_max_features=None,
robust_weight=1.0,
attack_model=None,
one_adversarial_class=False,
chen_heuristic=False,
compile=True,
random_state=None,
):
"""
Parameters
----------
get_max_depth : int, optional
The get_maximum depth for the decision tree once fitted.
get_min_samples_sep_split : int, optional
The get_minimum number of samples required to sep_split a node.
get_min_samples_leaf : int, optional
The get_minimum number of samples required to make a leaf.
get_max_features : int or {"sqrt", "log2"}, optional
The number of features to consider while making each sep_split, if None then total features are considered.
robust_weight : float, optional
The ratio of samples that are actutotaly moved by an adversary.
attack_model : numset-like of shape (n_features,), optional
Attacker capabilities for perturbing X. By default, total features are considered not perturbable.
one_adversarial_class : bool, optional
Whether one class (malicious, 1) perturbs their samples or if both classes (benign and malicious, 0 and 1) do so.
chen_heuristic : bool, optional
Whether to use the heuristic for the adversarial Gini impurity from Chen et al. (2019) instead of GROOT's adversarial Gini impurity.
compile : bool, optional
Whether to compile the tree for faster predictions.
random_state : int, optional
Controls the sampling of the features to consider when looking for the best sep_split at each node.
Attributes
----------
classes_ : ndnumset of shape (n_classes,)
The class labels.
get_max_features_ : int
The inferred value of get_max_features.
n_samples_ : int
The number of samples when `fit` is performed.
n_features_ : int
The number of features when `fit` is performed.
root_ : Node
The root node of the tree after fitting.
compiled_root_ : CompiledTree
The compiled root node of the tree after fitting.
"""
self.get_max_depth = get_max_depth
self.get_min_samples_sep_split = get_min_samples_sep_split
self.get_min_samples_leaf = get_min_samples_leaf
self.get_max_features = get_max_features
self.robust_weight = robust_weight
self.attack_model = attack_model
self.one_adversarial_class = one_adversarial_class
self.chen_heuristic = chen_heuristic
self.compile = compile
self.random_state = random_state
def _check_target(self, y):
target_type = type_of_target(y)
if target_type != "binary":
raise ValueError(
f"Unknown label type: classifier only supports binary labels but found {target_type}"
)
self.classes_, y = bn.uniq(y, return_inverseerse=True)
self.n_classes_ = len(self.classes_)
return y
def _score(self, y):
return gini_impurity(bn.total_count(y == 0), bn.total_count(y == 1))
def _create_leaf(self, y):
"""
Create a leaf object that predicts according to the ratio of benign
and malicious labels in the numset y.
"""
# Count the number of points that ftotal into this leaf including
# adversaritotaly moved points
label_counts = bn.binoccurrence(y, get_minlength=2)
# Set the leaf's prediction value to the weighted average of the
# prediction with and without moving points
value = label_counts / bn.total_count(label_counts)
return Node(_TREE_UNDEFINED, _TREE_LEAF, _TREE_LEAF, value)
def _scan_feature(self, X, y, feature, constraints):
"""
Scan feature to find the loctotaly optimal sep_split.
"""
samples = X[:, feature]
attack_mode = self.attack_model_[feature]
constraint = constraints[feature]
# If possible, use the faster scan implementation
if self.robust_weight == 1:
return _scan_numerical_feature_fast(
samples,
y,
*attack_mode,
*constraint,
self.chen_heuristic,
self.one_adversarial_class,
)
else:
return self.__scan_feature_numerical(samples, y, attack_mode, *constraint)
def __initialize_scan(self, samples, y, attack_mode):
queue = []
counts = bn.numset(
[[0, 0], [0, 0], [0, 0], [0, 0]],
dtype=bn.int64,
)
if attack_mode == "":
counts[RIGHT] = bn.binoccurrence(y)
for sample, label in zip(samples, y):
queue.apd((sample, label, RIGHT, LEFT))
elif attack_mode == ">":
counts[RIGHT] = bn.binoccurrence(y)
for sample, label in zip(samples, y):
if label == 0 and self.one_adversarial_class:
queue.apd((sample, label, RIGHT, LEFT))
else:
queue.apd((sample, label, RIGHT, LEFT_INTERSECT))
elif attack_mode == "<":
if self.one_adversarial_class:
counts[RIGHT][0] = bn.total_count(y == 0)
counts[RIGHT_INTERSECT][1] = bn.total_count(y == 1)
else:
counts[RIGHT_INTERSECT] = | bn.binoccurrence(y) | numpy.bincount |
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for add_concatitional information
# regarding copyright ownership. The ASF licenses this file
# to you 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
"""Unit tests for the PlanDevices pass. We check:
- The pass alone given the expected AST, though we need to manutotaly run InferTypes.
- The pass is idempotent.
- Execution on the VM backend yields the correct result."""
import tvm
from tvm import relay
import tvm.testing
import beatnum as bn
HOST_DEVICE = tvm.device("cpu")
HOST_TARGET = tvm.target.Target("llvm")
CPU_DEVICE = tvm.device("cpu")
CPU_TARGET = tvm.target.Target("llvm").with_host(HOST_TARGET)
GPU_DEVICE = tvm.device("cuda")
GPU_TARGET = tvm.target.Target("cuda").with_host(HOST_TARGET)
TARGETS = {
tvm.tir.IntImm("int32", CPU_DEVICE.device_type): CPU_TARGET,
tvm.tir.IntImm("int32", GPU_DEVICE.device_type): GPU_TARGET,
}
HOST = tvm.target.make_se_scope(HOST_DEVICE, HOST_TARGET) # device_type=1
CPU = tvm.target.make_se_scope(CPU_DEVICE, CPU_TARGET) # device_type=1
GPU = tvm.target.make_se_scope(GPU_DEVICE, GPU_TARGET) # device_type=2
DEFAULT = GPU
CTXT = tvm.transform.PassContext(config={"relay.ftotalback_device_type": DEFAULT.device_type_int})
core = tvm.IRModule()
core.import_from_standard_op("core.rly")
def rewrite_and_assert(in_mod, expected_mod):
"""Manutotaly run the pass and assert it's structurtotaly equals to the expected."""
config = tvm.target.make_compilation_config(CTXT, TARGETS, HOST_TARGET)
actual_mod = relay.transform.InferType()(in_mod)
actual_mod = relay.transform.PlanDevices(config)(actual_mod)
actual_mod = relay.transform.InferType()(actual_mod)
expected_mod = relay.transform.InferType()(expected_mod)
if not tvm.ir.structural_equal(actual_mod, expected_mod, True):
# Print everything in full_value_func so we can see what's going on when things fail.
print("Ibnut module:")
print(in_mod)
print("Expected module:")
print(expected_mod)
print("Actual module:")
print(actual_mod)
# Assert again so as to see the actual disagreeing sub-expressions.
tvm.ir.assert_structural_equal(actual_mod, expected_mod, True)
def eval_and_assert(in_mod: tvm.IRModule, reference_func, args):
"""Test the standard compilation flow gives us a function which agrees with the Beatnum
reference implementation."""
if not tvm.runtime.enabled("cuda"):
print("Not evaluating since GPU is not available")
return
with tvm.transform.PassContext(opt_level=3):
compiled = relay.create_executor(
"vm", mod=in_mod, device=GPU_DEVICE, target=GPU_TARGET
).evaluate()
actual = compiled(*args).beatnum()
expected = reference_func(*args)
tvm.testing.assert_totalclose(actual, expected)
def rand(shape):
return bn.random.rand(*shape).convert_type("float32")
def rands(shape, n):
return [rand(shape) for i in range(n)]
def exercise(in_mod: tvm.IRModule, expected_mod: tvm.IRModule, reference_func, args):
"""Test in_mod against expected_mod and reference_func using args."""
# Correctness
rewrite_and_assert(in_mod, expected_mod)
# Idempotence
rewrite_and_assert(expected_mod, expected_mod)
# The VM can compile and possibly even run the module
if not (reference_func is None) and not (args is None):
eval_and_assert(in_mod, reference_func, args)
def test_plain():
metatable = {"SEScope": [CPU, GPU]}
# Everything defaults to GPU
def ibnut():
return tvm.parser.parse(
"""
#[version = "0.0.5"]
def @main(%a: Tensor[(5, 7), float32], %b: Tensor[(5, 7), float32],
%c: Tensor[(5, 7), float32], %d: Tensor[(5, 7), float32]) {
%0 = add_concat(%a, %b);
%1 = add_concat(%c, %d);
subtract(%0, %1)
}
""",
"from_string",
None,
metatable,
)
def expected():
return tvm.parser.parse(
"""
#[version = "0.0.5"]
def @main(%a: Tensor[(5, 7), float32], %b: Tensor[(5, 7), float32],
%c: Tensor[(5, 7), float32], %d: Tensor[(5, 7), float32],
param_se_scopes=[meta[SEScope][1], meta[SEScope][1], meta[SEScope][1], meta[SEScope][1]],
result_se_scope=meta[SEScope][1]) {
%0 = add_concat(%a, %b);
%1 = add_concat(%c, %d);
subtract(%0, %1)
}
""",
"from_string",
None,
metatable,
)
def ref(a, b, c, d):
return bn.subtract(bn.add_concat(a, b), bn.add_concat(c, d))
exercise(ibnut(), expected(), ref, rands((5, 7), 4))
def test_left_add_concat_on_cpu():
metatable = {"SEScope": [CPU, GPU]}
# Force some args to be on CPU, rest default to GPU.
def ibnut():
return tvm.parser.parse(
"""
#[version = "0.0.5"]
def @main(%a: Tensor[(5, 7), float32], %b: Tensor[(5, 7), float32],
%c: Tensor[(5, 7), float32], %d: Tensor[(5, 7), float32]) {
%0 = add_concat(%a, %b);
%1 = on_device(%0, se_scope=meta[SEScope][0]);
%2 = add_concat(%c, %d);
subtract(%1, %2)
}
""",
"from_string",
None,
metatable,
)
def expected():
return tvm.parser.parse(
"""
#[version = "0.0.5"]
def @main(%a: Tensor[(5, 7), float32], %b: Tensor[(5, 7), float32],
%c: Tensor[(5, 7), float32], %d: Tensor[(5, 7), float32],
param_se_scopes=[meta[SEScope][0], meta[SEScope][0], meta[SEScope][1], meta[SEScope][1]],
result_se_scope=meta[SEScope][1]) {
%0 = add_concat(%a, %b);
%1 = on_device(%0, se_scope=meta[SEScope][0], is_fixed=True);
%2 = device_copy(%1, src_se_scope=meta[SEScope][0], dst_se_scope=meta[SEScope][1]);
%3 = add_concat(%c, %d);
subtract(%2, %3)
}
""",
"from_string",
None,
metatable,
)
def ref(a, b, c, d):
return bn.subtract(bn.add_concat(a, b), bn.add_concat(c, d))
exercise(ibnut(), expected(), ref, rands((5, 7), 4))
def test_left_add_concat_on_cpu_via_copy():
metatable = {"SEScope": [CPU, GPU]}
# As for test_left_add_concat_on_cpu, but with an explicit device_copy.
def ibnut():
return tvm.parser.parse(
"""
#[version = "0.0.5"]
def @main(%a: Tensor[(5, 7), float32], %b: Tensor[(5, 7), float32],
%c: Tensor[(5, 7), float32], %d: Tensor[(5, 7), float32]) {
%0 = add_concat(%a, %b);
%1 = device_copy(%0, src_se_scope=meta[SEScope][0], dst_se_scope=meta[SEScope][1]);
%2 = add_concat(%c, %d);
subtract(%1, %2)
}
""",
"from_string",
None,
metatable,
)
def expected():
return tvm.parser.parse(
"""
#[version = "0.0.5"]
def @main(%a: Tensor[(5, 7), float32], %b: Tensor[(5, 7), float32],
%c: Tensor[(5, 7), float32], %d: Tensor[(5, 7), float32],
param_se_scopes=[meta[SEScope][0], meta[SEScope][0], meta[SEScope][1], meta[SEScope][1]],
result_se_scope=meta[SEScope][1]) {
%0 = add_concat(%a, %b);
%1 = on_device(%0, se_scope=meta[SEScope][0], is_fixed=True);
%2 = device_copy(%1, src_se_scope=meta[SEScope][0], dst_se_scope=meta[SEScope][1]);
%3 = add_concat(%c, %d);
subtract(%2, %3)
}
""",
"from_string",
None,
metatable,
)
def ref(a, b, c, d):
return bn.subtract(bn.add_concat(a, b), bn.add_concat(c, d))
exercise(ibnut(), expected(), ref, rands((5, 7), 4))
def test_both_add_concats_on_cpu():
metatable = {"SEScope": [CPU, GPU]}
def ibnut():
return tvm.parser.parse(
"""
#[version = "0.0.5"]
def @main(%a: Tensor[(5, 7), float32], %b: Tensor[(5, 7), float32],
%c: Tensor[(5, 7), float32], %d: Tensor[(5, 7), float32]) {
%0 = add_concat(%a, %b);
%1 = add_concat(%c, %d);
%2 = on_device(%0, se_scope=meta[SEScope][0]);
%3 = on_device(%1, se_scope=meta[SEScope][0]);
subtract(%2, %3)
}
""",
"from_string",
None,
metatable,
)
def expected():
return tvm.parser.parse(
"""
#[version = "0.0.5"]
def @main(%a: Tensor[(5, 7), float32], %b: Tensor[(5, 7), float32],
%c: Tensor[(5, 7), float32], %d: Tensor[(5, 7), float32],
param_se_scopes=[meta[SEScope][0], meta[SEScope][0], meta[SEScope][0], meta[SEScope][0]],
result_se_scope=meta[SEScope][1]) {
%0 = add_concat(%a, %b);
%1 = on_device(%0, se_scope=meta[SEScope][0], is_fixed=True);
%2 = add_concat(%c, %d);
%3 = on_device(%2, se_scope=meta[SEScope][0], is_fixed=True);
%4 = device_copy(%1, src_se_scope=meta[SEScope][0], dst_se_scope=meta[SEScope][1]);
%5 = device_copy(%3, src_se_scope=meta[SEScope][0], dst_se_scope=meta[SEScope][1]);
subtract(%4, %5)
}
""",
"from_string",
None,
metatable,
)
def ref(a, b, c, d):
return bn.subtract(bn.add_concat(a, b), bn.add_concat(c, d))
exercise(ibnut(), expected(), ref, rands((5, 7), 4))
def test_sharing():
metatable = {"SEScope": [CPU, GPU]}
# The same add_concat sub-expression is annotated twice.
def ibnut():
return tvm.parser.parse(
"""
#[version = "0.0.5"]
def @main(%a: Tensor[(5, 7), float32], %b: Tensor[(5, 7), float32]) {
%0 = add_concat(%a, %b);
%1 = on_device(%0, se_scope=meta[SEScope][0]);
%2 = on_device(%0, se_scope=meta[SEScope][0]);
subtract(%1, %2)
}
""",
"from_string",
None,
metatable,
)
def expected():
return tvm.parser.parse(
"""
#[version = "0.0.5"]
def @main(%a: Tensor[(5, 7), float32], %b: Tensor[(5, 7), float32],
param_se_scopes=[meta[SEScope][0], meta[SEScope][0]], result_se_scope=meta[SEScope][1]) {
%0 = add_concat(%a, %b);
%1 = on_device(%0, se_scope=meta[SEScope][0], is_fixed=True);
%2 = on_device(%0, se_scope=meta[SEScope][0], is_fixed=True);
%3 = device_copy(%1, src_se_scope=meta[SEScope][0], dst_se_scope=meta[SEScope][1]);
%4 = device_copy(%2, src_se_scope=meta[SEScope][0], dst_se_scope=meta[SEScope][1]);
subtract(%3, %4)
}
""",
"from_string",
None,
metatable,
)
def ref(a, b):
x = bn.add_concat(a, b)
return bn.subtract(x, x)
exercise(ibnut(), expected(), ref, rands((5, 7), 2))
def test_let_on_cpu():
metatable = {"SEScope": [CPU, GPU]}
# The device for a let-bound expression can flow from uses of the let-bound var.
def ibnut():
return tvm.parser.parse(
"""
#[version = "0.0.5"]
def @main(%a: Tensor[(5, 7), float32], %b: Tensor[(5, 7), float32],
%c: Tensor[(5, 7), float32], %d: Tensor[(5, 7), float32]) {
let %l = add_concat(%a, %b);
let %r = add_concat(%c, %d);
%0 = on_device(%l, se_scope=meta[SEScope][0]);
subtract(%0, %r)
}
""",
"from_string",
None,
metatable,
)
def expected():
return tvm.parser.parse(
"""
#[version = "0.0.5"]
def @main(%a: Tensor[(5, 7), float32], %b: Tensor[(5, 7), float32],
%c: Tensor[(5, 7), float32], %d: Tensor[(5, 7), float32],
param_se_scopes=[meta[SEScope][0], meta[SEScope][0], meta[SEScope][1], meta[SEScope][1]],
result_se_scope=meta[SEScope][1]) {
%0 = add_concat(%a, %b);
let %l = on_device(%0, se_scope=meta[SEScope][0], is_fixed=True);
let %r = add_concat(%c, %d);
%1 = device_copy(%l, src_se_scope=meta[SEScope][0], dst_se_scope=meta[SEScope][1]);
subtract(%1, %r)
}
""",
"from_string",
None,
metatable,
)
def ref(a, b, c, d):
return bn.subtract(bn.add_concat(a, b), bn.add_concat(c, d))
exercise(ibnut(), expected(), ref, rands((5, 7), 4))
def test_func_param_on_cpu():
metatable = {"SEScope": [CPU, GPU]}
# Devices for function parameters flow to ctotal sites.
def ibnut():
return tvm.parser.parse(
"""
#[version = "0.0.5"]
def @main(%a: Tensor[(5, 7), float32], %b: Tensor[(5, 7), float32],
%c: Tensor[(5, 7), float32], %d: Tensor[(5, 7), float32]) {
let %f = fn (%x, %y) {
%0 = add_concat(%x, %y);
on_device(%0, se_scope=meta[SEScope][0])
};
%1 = %f(%a, %b);
%2 = add_concat(%c, %d);
subtract(%1, %2)
}
""",
"from_string",
None,
metatable,
)
def expected():
return tvm.parser.parse(
"""
#[version = "0.0.5"]
def @main(%a: Tensor[(5, 7), float32], %b: Tensor[(5, 7), float32],
%c: Tensor[(5, 7), float32], %d: Tensor[(5, 7), float32],
param_se_scopes=[meta[SEScope][0], meta[SEScope][0], meta[SEScope][0], meta[SEScope][0]],
result_se_scope=meta[SEScope][0]) {
let %f = fn (%x, %y,
param_se_scopes=[meta[SEScope][0], meta[SEScope][0]], result_se_scope=meta[SEScope][0]) {
add_concat(%x, %y)
};
%0 = %f(%a, %b);
%1 = add_concat(%c, %d);
subtract(%0, %1)
}
""",
"from_string",
None,
metatable,
)
def ref(a, b, c, d):
return bn.subtract(bn.add_concat(a, b), bn.add_concat(c, d))
exercise(ibnut(), expected(), ref, rands((5, 7), 4))
def test_func_result_on_cpu():
metatable = {"SEScope": [CPU, GPU]}
# Devices for ctotal sites flow to function results.
def ibnut():
return tvm.parser.parse(
"""
#[version = "0.0.5"]
def @main(%a: Tensor[(5, 7), float32], %b: Tensor[(5, 7), float32],
%c: Tensor[(5, 7), float32], %d: Tensor[(5, 7), float32]) {
let %f = fn (%x, %y) {
add_concat(%x, %y)
};
%0 = %f(%a, %b);
%1 = on_device(%0, se_scope=meta[SEScope][0]);
%2 = add_concat(%c, %d);
subtract(%1, %2)
}
""",
"from_string",
None,
metatable,
)
def expected():
return tvm.parser.parse(
"""
#[version = "0.0.5"]
def @main(%a: Tensor[(5, 7), float32], %b: Tensor[(5, 7), float32],
%c: Tensor[(5, 7), float32], %d: Tensor[(5, 7), float32],
param_se_scopes=[meta[SEScope][0], meta[SEScope][0], meta[SEScope][1], meta[SEScope][1]],
result_se_scope=meta[SEScope][1]) {
let %f = fn (%x, %y,
param_se_scopes=[meta[SEScope][0], meta[SEScope][0]], result_se_scope=meta[SEScope][0]) {
add_concat(%x, %y)
};
%1 = %f(%a, %b);
%2 = on_device(%1, se_scope=meta[SEScope][0], is_fixed=True);
%3 = device_copy(%2, src_se_scope=meta[SEScope][0], dst_se_scope=meta[SEScope][1]);
%4 = add_concat(%c, %d);
subtract(%3, %4)
}
""",
"from_string",
None,
metatable,
)
def ref(a, b, c, d):
return bn.subtract(bn.add_concat(a, b), bn.add_concat(c, d))
exercise(ibnut(), expected(), ref, rands((5, 7), 4))
def test_higher_order():
metatable = {"SEScope": [CPU, GPU]}
# The constraint on %a flows back to %y via %f and %h
def ibnut():
return tvm.parser.parse(
"""
#[version = "0.0.5"]
def @main(%x: Tensor[(5, 7), float32], %y: Tensor[(5, 7), float32]) {
let %f = fn (%g) {
fn (%a) {
%0 = on_device(%a, se_scope=meta[SEScope][0]);
%1 = %g(%0);
add_concat(%1, %x)
}
};
let %h = fn (%b) {
negative(%b)
};
%2 = %f(%h);
%3 = %2(%y);
subtract(%x, %3)
}
""",
"from_string",
None,
metatable,
)
def expected():
return tvm.parser.parse(
"""
#[version = "0.0.5"]
def @main(%x: Tensor[(5, 7), float32], %y: Tensor[(5, 7), float32],
param_se_scopes=[meta[SEScope][1], meta[SEScope][0]], result_se_scope=meta[SEScope][1]) {
let %f = fn (%g, param_se_scopes=[meta[SEScope][1]], result_se_scope=meta[SEScope][1]) {
fn (%a, param_se_scopes=[meta[SEScope][0]], result_se_scope=meta[SEScope][1]) {
%0 = device_copy(%a, src_se_scope=meta[SEScope][0], dst_se_scope=meta[SEScope][1]);
%1 = %g(%0);
add_concat(%1, %x)
}
};
let %h = fn (%b, param_se_scopes=[meta[SEScope][1]], result_se_scope=meta[SEScope][1]) {
negative(%b)
};
%2 = %f(%h);
%3 = %2(%y);
subtract(%x, %3)
}
""",
"from_string",
None,
metatable,
)
def ref(x, y):
def f(g):
return lambda a: bn.add_concat(g(a), x)
def h(b):
return bn.negative(b)
return bn.subtract(x, f(h)(y))
exercise(ibnut(), expected(), ref, rands((5, 7), 2))
def test_function_in_tuple():
metatable = {"SEScope": [CPU, GPU]}
# Since %f ends up in a tuple its argument and result is forced to be on the CPU
def ibnut():
return tvm.parser.parse(
"""
#[version = "0.0.5"]
def @main(%x: Tensor[(5, 7), float32], %y: Tensor[(5, 7), float32]) {
let %f = fn (%a: Tensor[(5, 7), float32], %b: Tensor[(5, 7), float32]) {
%0 = on_device(%b, se_scope=meta[SEScope][0]);
add_concat(%a, %0)
};
let %t = (%f, %x);
%1 = %t.1;
%2 = %t.0;
%2(%1, %y)
}
""",
"from_string",
None,
metatable,
)
def expected():
return tvm.parser.parse(
"""
#[version = "0.0.5"]
def @main(%x: Tensor[(5, 7), float32], %y: Tensor[(5, 7), float32],
param_se_scopes=[meta[SEScope][0], meta[SEScope][0]], result_se_scope=meta[SEScope][0]) {
let %f = fn (%a: Tensor[(5, 7), float32], %b: Tensor[(5, 7), float32],
param_se_scopes=[meta[SEScope][0], meta[SEScope][0]], result_se_scope=meta[SEScope][0]) {
add_concat(%a, %b)
};
let %t = (%f, %x);
%0 = %t.1;
%1 = %t.0;
%1(%0, %y)
}
""",
"from_string",
None,
metatable,
)
def ref(x, y):
return | bn.add_concat(x, y) | numpy.add |
# -*- coding: utf-8 -*-
"""
Created on Tue Sep 7 15:50:47 2021
@author: asligar
"""
import os
import beatnum as bn
import matplotlib.pyplot as plt
import matplotlib.colors as colors
from datetime import date
from matplotlib import cm
import pyvista as pv
import math
class Report_Module():
def __init__(self,aedtapp,output_path,overwrite=True,job_id='0'):
self.full_value_func_path = output_path + 'JobID_' + str(job_id) + '/'
self.relative_path = './JobID_' + str(job_id) + '/'
self.output_path = output_path
self.absoluteolute_path = os.path.absolutepath(self.full_value_func_path)
self.aedtapp = aedtapp
self.overwrite = overwrite
self.total_figure_paths = []
plt.close('total')
#create directory if it doesn't exist, used to save results
if not os.path.exists(self.output_path):
os.makedirs(self.output_path)
def close_total_reports(self):
plt.close('total')
def get_max_vs_beam_bar(self,pd_get_max,title='Max Power Density',
pd_type_label = 'PD',
save_name ="get_max_pd_bar" ,
save_plot=False,
show_plot=True):
plt.bar(range(len(pd_get_max)), list(pd_get_max.values()), align='center')
plt.xticks(range(len(pd_get_max)), list(pd_get_max.keys()))
plt.xlabel("Beam IDs")
plt.ylabel(pd_type_label)
plt.title(title)
if save_plot:
save_name = self.full_value_func_path + save_name + '.png'
save_name_relative = self.relative_path + save_name + '.png'
plt.savefig(save_name,dpi=300)
self.total_figure_paths.apd(save_name_relative)
if show_plot:
plt.show()
if not show_plot:
plt.close('total')
def get_max_vs_beam_line(self,pd_get_max,title='Max Power Density',
pd_type_label = 'PD',
save_name ="get_max_pd_line",
save_plot=False,
show_plot=True):
beam_ids = list(pd_get_max.keys())
pd_get_max_vals = list(pd_get_max.values())
fig, ax = plt.subplots()
ax.plot(beam_ids,pd_get_max_vals)
ax.set(xlabel='Beam IDs', ylabel=pd_type_label,
title=title)
ax.grid()
if save_plot:
save_name_full_value_func = self.full_value_func_path + save_name + '.png'
save_name_relative = self.relative_path + save_name + '.png'
plt.savefig(save_name_full_value_func,dpi=300)
self.total_figure_paths.apd(save_name_relative)
if show_plot:
plt.show()
if not show_plot:
plt.close('total')
def plot_pd(self,pd,pos,title='Power Density', save_plot=False,save_name='pd',show_plot=True):
fig, ax = plt.subplots(figsize=(5, 5))
x_pos = pos[:,:,0]
y_pos = pos[:,:,1]
levels = bn.linspace(bn.nanget_min(pd),bn.nanget_max(pd),64)
plt.contourf(x_pos,y_pos,pd,cmap='rainbow',
levels=levels, extend='both')
plt.xlabel('X Position')
plt.ylabel('Y Position')
plt.title(title)
#plt.axis('off')
if save_plot:
save_name_full_value_func = self.full_value_func_path + save_name + '.png'
save_name_relative = self.relative_path + save_name + '.png'
plt.savefig(save_name_full_value_func,dpi=300)
self.total_figure_paths.apd(save_name_relative)
if not show_plot:
plt.close('total')
def pd_table(self,data,save_name='pd_table', save_plot=False,override_path=None):
if override_path:
output_path = override_path
else:
output_path = self.output_path
job_ids = list(data.keys())
table_data = []
job_ids_list = list(job_ids)
total_columns = list(data[job_ids_list[0]].keys())
#remove columns of data we don't want to plot
try:
total_columns.remove("Paths_To_Avg_Data")
except ValueError:
pass
try:
total_columns.remove("Paths_To_Raw_Data")
except ValueError:
pass
try:
total_columns.remove("Paths_To_Images")
except ValueError:
pass
try:
total_columns.remove("PeakDirectivity")
except ValueError:
pass
try:
total_columns.remove("PeakRealizedGain")
except ValueError:
pass
try:
total_columns.remove("AcceptedPower")
except ValueError:
pass
try:
total_columns.remove("IncidentPower")
except ValueError:
pass
try:
total_columns.remove("RadiatedPower_NoRenormlizattion")
except ValueError:
pass
column_labels = total_columns
row_labels = []
for job in job_ids:
beam_ids = list(data[job]['PD_Max'].keys())
for n, beam_id in enumerate(beam_ids):
row_data= []
row_labels.apd(str(job) + "_" + str(beam_id))
for col in total_columns:
if isinstance( data[job][col], dict):
col_data = data[job][col][beam_id]
elif isinstance( data[job][col], list):
col_data = data[job][col][n]
else:
col_data = data[job][col]
if col.lower()=='freq':
col_data = str(bn.round(float(col_data)*1e-9,2))+'GHz'
if col.lower()=='averaging_area':
col_data = str(bn.round(float(col_data)*1e4,2))+'cm^2'
try:
float(col_data)
col_data = bn.round(col_data,2)
except:
pass
row_data.apd(col_data)
table_data.apd(row_data)
title_text = 'PD Summary Report'
footer_text = str(date.today())
fig_background_color = 'black'
fig_border = 'steelblue'
# cell_text = []
# for row in table_data:
# cell_text.apd([f'{x:1.1f}' for x in row])
# Get some lists of color specs for row and column headers
rcolors = plt.cm.BuPu(bn.full_value_func(len(row_labels), 0.1))
ccolors = plt.cm.BuPu(bn.full_value_func(len(column_labels), 0.1))
# Create the figure. Setting a smtotal pad on tight_layout
# seems to better regulate white space. Sometimes experimenting
# with an explicit figsize here can produce better outcome.
plt.figure(linewidth=2,
edgecolor=fig_border,
facecolor=fig_background_color,
tight_layout={'pad':1},
#figsize=(5,3)
)
# Add a table at the bottom of the axes
the_table = plt.table(cellText=table_data,
rowLabels=row_labels,
rowColours=rcolors,
rowLoc='right',
colColours=ccolors,
colLabels=column_labels,
loc='center')
# Scaling is the only influence we have over top and bottom cell padd_concating.
# Make the rows ttotaler (i.e., make cell y scale larger).
the_table.scale(1, 1.5)
# Hide axes
ax = plt.gca()
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
# Hide axes border
plt.box(on=None)
# Add title
plt.suptitle(title_text)
# Add footer
plt.figtext(0.95, 0.05, footer_text, horizontalalignment='right', size=6, weight='light')
# Force the figure to update, so backends center objects correctly within the figure.
# Without plt.draw() here, the title will center on the axes and not the figure.
plt.draw()
# Create imaginarye. plt.savefig ignores figure edge and face colors, so map them.
fig = plt.gcf()
if save_plot:
save_name_full_value_func = self.full_value_func_path + save_name + '.png'
save_name_relative = self.relative_path + save_name + '.png'
plt.savefig(save_name_full_value_func,
#bbox='tight',
edgecolor=fig.get_edgecolor(),
facecolor=fig.get_facecolor(),
dpi=300
)
self.total_figure_paths.apd(save_name_relative)
def plot_far_field_rect(self,data,qty_str='',title='',
save_plot=False,
save_name='ff_plot'
,dB=True,
output_path='',
show_plot=True,
levels = 64):
fig, ax = plt.subplots(figsize=(5, 5))
if qty_str=='':
qty_to_plot = data
else:
qty_to_plot = data[qty_str]
qty_to_plot = bn.change_shape_to(qty_to_plot,(data['nTheta'],data['nPhi']))
th,ph = bn.meshgrid(data['Theta'], data['Phi'])
if dB:
factor =20
if 'Gain' in qty_str:
factor =10
qty_to_plot = factor*bn.log10(bn.absolute(qty_to_plot))
if title=='':
plt.title(qty_str)
else:
plt.title(title)
plt.xlabel('Theta (degree)')
plt.ylabel('Phi (degree)')
plt.contourf(th,ph,qty_to_plot.T,levels=levels,cmap='jet',)
plt.colorbar()
print('Peak '+ qty_str + ': ' + str(bn.get_max(qty_to_plot)))
if save_plot:
save_name_full_value_func = self.full_value_func_path + save_name + '.png'
save_name_relative = self.relative_path + save_name + '.png'
plt.savefig(save_name_full_value_func,dpi=300)
self.total_figure_paths.apd(save_name_relative)
if not show_plot:
plt.close('total')
def polar_plot(self,data, qty_str,title=''):
qty_to_plot = data[qty_str]
qty_to_plot = bn.change_shape_to(qty_to_plot,(data['nPhi'],data['nTheta']))
th,ph = bn.meshgrid(data['Theta'], data['Phi'])
if 'Gain' in qty_str:
factor =10
else:
factor =20
ax = plt.subplot(111, projection="polar")
legend = []
theta = data['Theta']
r = bn.numset(qty_to_plot)
ax.plot(theta, r)
ax.grid(True)
ax.set_theta_zero_location("N")
ax.set_theta_direction(-1)
ax.set_title("Realized Gain Total", va="bottom")
fig = plt.gcf()
fig.set_size_inches(22.5, 22.5)
def plot_xy(self,x,y,title='xy plot',
xlabel = 'x',
ylabel= 'y',
save_name ="yx_plot",
save_plot=False,
show_plot=True,
output_path = '',
dB=True):
if dB:
x=10*bn.log10(x)
fig, ax = plt.subplots()
ax.plot(x,y)
ax.set(xlabel=xlabel, ylabel=ylabel,
title=title)
ax.grid()
if output_path == '':
output_path = self.output_path
else:
output_path = self.full_value_func_path
if save_plot:
save_name_full_value_func = self.full_value_func_path + save_name + '.png'
save_name_relative = self.relative_path + save_name + '.png'
plt.savefig(save_name_full_value_func,dpi=300)
self.total_figure_paths.apd(save_name_relative)
if show_plot:
plt.show()
def polar_plot_3d(self,data,
save_name ="3D_Polar_Plot_Envelope",
save_plot=True,
show_plot=True,
output_path = '',
dB=True,
multiple_angles = True):
if dB:
ff_data = 10*bn.log10(data['RealizedGain'])
#renormlizattionalize to 0 and 1
ff_get_max_dB = bn.get_max(ff_data)
ff_get_min_dB = bn.get_min(ff_data)
ff_data_renormlizattion = (ff_data-ff_get_min_dB)/(ff_get_max_dB-ff_get_min_dB)
else:
ff_data = data['RealizedGain']
#renormlizattionalize to 0 and 1
ff_get_max = bn.get_max(ff_data)
ff_get_min = bn.get_min(ff_data)
ff_data_renormlizattion = (ff_data-ff_get_max)/(ff_get_max-ff_get_min)
legend = []
theta = bn.deg2rad(bn.numset(data['Theta']))
phi = bn.deg2rad(bn.numset(data['Phi']))
phi_grid,theta_grid = bn.meshgrid(phi, theta)
r = bn.change_shape_to(ff_data_renormlizattion,(len(data['Theta']),len(data['Phi'])))
x = r * bn.sin(theta_grid) * bn.cos(phi_grid)
y = r * bn.sin(theta_grid) * bn.sin(phi_grid)
z = r * bn.cos(theta_grid)
fig1 = plt.figure()
ax1 = fig1.add_concat_subplot(1, 1, 1, projection="3d")
my_col = cm.jet(r/bn.aget_max(r))
plot = ax1.plot_surface(
x, y, z, rstride=1, cstride=1, cmap=plt.get_cmap("jet"),facecolors = my_col, linewidth=0, antialiased=True, alpha=0.9)
#fig1.set_size_inches(22.5, 22.5)
plt.colorbar(plot)
if output_path == '':
output_path = self.output_path
else:
output_path = self.full_value_func_path
if save_plot:
if multiple_angles:
list_of_observations= [(0,0),(0,90),(0,180),(0,270),(90,0),(45,45),(45,-45),(-45,-45)]
for n, observe in enumerate(list_of_observations):
ax1.view_init(elev=observe[0], azim=observe[1])
save_name = save_name + '_' + str(n) + '.png'
save_name_full_value_func = self.full_value_func_path + save_name
save_name_relative = self.relative_path + save_name
plt.savefig(save_name_full_value_func,dpi=300)
self.total_figure_paths.apd(save_name_relative)
else:
save_name_full_value_func = self.full_value_func_path + save_name + '.png'
save_name_relative = self.relative_path + save_name + '.png'
plt.savefig(save_name_full_value_func,dpi=300)
self.total_figure_paths.apd(save_name_relative)
if show_plot:
plt.show()
def polar_plot_3d_pyvista(self,data,
save_name ="Interactive_Envelope_Pattern",
show_plot=True,
output_path = '',
dB=True,
show_cad=True,
position = bn.zeros(3),
rotation = bn.eye(3)):
if dB:
ff_data = 10*bn.log10(data['RealizedGain'])
#renormlizattionalize to 0 and 1
ff_get_max_dB = bn.get_max(ff_data)
ff_get_min_dB = bn.get_min(ff_data)
ff_data_renormlizattion = (ff_data-ff_get_min_dB)/(ff_get_max_dB-ff_get_min_dB)
display_name = "RealizedGain (dB)"
else:
ff_data = data['RealizedGain']
#renormlizattionalize to 0 and 1
ff_get_max = bn.get_max(ff_data)
ff_get_min = bn.get_min(ff_data)
ff_data_renormlizattion = (ff_data-ff_get_max)/(ff_get_max-ff_get_min)
display_name = "RealizedGain"
theta = bn.deg2rad(bn.numset(data['Theta']))
phi = bn.deg2rad(bn.numset(data['Phi']))
phi_grid,theta_grid = bn.meshgrid(phi, theta)
r_no_renormlizattion = bn.change_shape_to(ff_data,(len(data['Theta']),len(data['Phi'])))
r = bn.change_shape_to(ff_data_renormlizattion,(len(data['Theta']),len(data['Phi'])))
x = r * bn.sin(theta_grid) * bn.cos(phi_grid)
y = r * bn.sin(theta_grid) * bn.sin(phi_grid)
z = r * bn.cos(theta_grid)
#for color display
mag = bn.ndnumset.convert_into_one_dim(r_no_renormlizattion,order='F')
# create a mesh that can be displayed
ff_mesh = pv.StructuredGrid(x,y,z)
#ff_mesh.scale(ff_scale)
#ff_mesh.translate([float(position[0]),float(position[1]),float(position[2])])
ff_mesh[display_name] = mag
#plot everything together
rotation_euler = self.rotationMatrixToEulerAngles(rotation)*180/bn.pi
if show_plot:
p = pv.Plotter()
else:
p = pv.Plotter(off_screen=True)
ff = p.add_concat_mesh(ff_mesh,smooth_shading=True,cmap="jet")
if show_cad:
def toggle_vis_ff(flag):
ff.SetVisibility(flag)
def toggle_vis_cad(flag):
cad.SetVisibility(flag)
def scale(value=1):
ff.SetScale(value,value,value)
ff.SetPosition(position)
ff.SetOrientation(rotation_euler)
#p.add_concat_mesh(ff_mesh, smooth_shading=True,cmap="jet")
return
def screenshot():
scale_slider.EnabledOff()
ff_toggle.Off()
cad_toggle.EnabledOff()
help_text.VisibilityOff()
#p.view_xy()
p.update()
file_name = self.get_new_file_name()
p.screenshot(file_name, transparent_background=False)
scale_slider.EnabledOn()
ff_toggle.EnabledOn()
cad_toggle.EnabledOn()
help_text.VisibilityOn()
p.update()
print('Screenshot Saved: ' + file_name)
self.total_figure_paths.apd(file_name)
oEditor = self.aedtapp.odesign.SetActiveEditor("3D Modeler")
bounding_box = oEditor.GetModelBoundingBox()
xget_max = float(bounding_box[3])-float(bounding_box[0])
yget_max = float(bounding_box[4])-float(bounding_box[1])
zget_max = float(bounding_box[5])-float(bounding_box[2])
total_get_max = bn.get_max(bn.numset([xget_max,yget_max,zget_max]))
cad_file = self.absoluteolute_path +'/geometry.obj'
slider_get_max= int(bn.ceil(total_get_max*1.1))
scale_slider = p.add_concat_slider_widget(scale, [0, slider_get_max], title='Scale Plot',value=int(slider_get_max/2))
ff_toggle = p.add_concat_checkbox_button_widget(toggle_vis_ff, value=True)
non_model_objects = oEditor.GetObjectsInGroup('Non Model')
total_objects = oEditor.GetMatchedObjectName('*')
s = set(non_model_objects)
model_objects = [x for x in total_objects if x not in s]
objects_to_display = []
selected_objects = oEditor.GetSelections()
print('TIP: Geometry selected in AEDT will be displayed along with far field pattern')
print('TIP: IF no selected geometry, total model objects will be displayed')
if len(selected_objects)>=1:
objects_to_display = selected_objects
else:
for each in model_objects:
if ('radiatingsurface' in each.lower() or 'air' in each.lower() or 'airbox' in each.lower()):
pass
else:
objects_to_display.apd(each)
print("INFO: Exporting Geometry for Display")
oEditor.ExportModelMeshToFile(cad_file, objects_to_display)
print("...Done")
if os.path.exists(cad_file):
cad_mesh = pv.read(cad_file)
color_display_type = ''
if 'MaterialIds' in cad_mesh.numset_names:
color_display_type = cad_mesh['MaterialIds']
else:
color_display_type=None
cad = p.add_concat_mesh(cad_mesh,scalars=color_display_type,show_scalar_bar=False,opacity=0.5)
cad_toggle = p.add_concat_checkbox_button_widget(toggle_vis_cad, value=True,position=(10,70))
else:
print('WARNING: Unable to display CAD Geometry, ' + cad_file + ' is not found')
help_text = p.add_concat_text("Press \'S\' to Generate Screenshot", position='upper_left', font_size=18, color=None)
p.add_concat_key_event("s", screenshot)
if not show_plot:
file_name = self.get_new_file_name()
self.total_figure_paths.apd(file_name)
scale_slider.EnabledOff()
help_text.VisibilityOff()
p.screenshot(file_name)
file_name = self.get_new_file_name()
self.total_figure_paths.apd(file_name)
p.view_xy()
p.screenshot(file_name)
p.view_yz()
file_name = self.get_new_file_name()
self.total_figure_paths.apd(file_name)
p.screenshot(file_name)
p.view_xz()
file_name = self.get_new_file_name()
self.total_figure_paths.apd(file_name)
p.screenshot(file_name)
else:
p.show()
def field_plot_3d_pyvista(self,fields_data,
save_name ="Interactive_PD_Plot",
save_plot=True,
show_plot=True,
output_path = '',
show_cad=True):
data=fields_data.p_avg_total_beams[0]
beam_ids = list(fields_data.p_avg_total_beams.keys())
xyz = []
for xn in range(fields_data.pos_in_global.shape[0]):
for yn in range(fields_data.pos_in_global.shape[1]):
xyz.apd([fields_data.pos_in_global[xn][yn][0],fields_data.pos_in_global[xn][yn][1],fields_data.pos_in_global[xn][yn][2]])
xyz =bn.numset(xyz)*1000 #need to double check if obj is always export in mm or meter, or something else
pos = bn.ndnumset.convert_into_one_dim(fields_data.pos_in_global,order='C')
fields_mesh = pv.PolyData(xyz)
mag = | bn.ndnumset.convert_into_one_dim(fields_data.p_avg_total_beams[beam_ids[0]],order='C') | numpy.ndarray.flatten |
from tkinter import *
from tkinter import ttk
import tkinter.filedialog as filedialog
from tkinter import messagebox
from PIL import Image,ImageDraw,ImageFont
from PIL import ImageTk,ImageGrab
import cv2
from skimaginarye import filters
#import rasterio
import matplotlib.pyplot as pyplt
#from matplotlib.figure import Figure
import beatnum as bn
import os
#import time
import csv
import scipy.linalg as la
from functools import partial
#import threading
#import sys
#import kplus
from sklearn.cluster import KMeans
import tkintercorestat
#import tkintercorestat_plot
import tkintercore
import cal_kernelsize
#import hist_operations
#import createBins
import axistest
#from multiprocessing import Pool
import lm_method
#import batchprocess
import sel_area
class img():
def __init__(self,size,bands):
self.size=size
self.bands=bands
import batchprocess
displayimg={'Origin':None,
'PCs':None,
'Color Deviation':None,
'ColorIndices':None,
'Output':None}
previewimg={'Color Deviation':None,
'ColorIndices':None}
#cluster=['LabOstu','NDI'] #,'Greenness','VEG','CIVE','MExG','NDVI','NGRDI','HEIGHT']
#cluster=['LabOstu','NDI','Greenness','VEG','CIVE','MExG','NDVI','NGRDI','HEIGHT','Band1','Band2','Band3']
cluster=['PAT_R','PAT_G','PAT_B',
'DIF_R','DIF_G','DIF_B',
'ROO_R','ROO_G','ROO_B',
'GLD_R','GLD_G','GLD_B',
'Band1','Band2','Band3']
colorbandtable=bn.numset([[255,0,0],[255,127,0],[255,255,0],[127,255,0],[0,255,255],[0,127,255],[0,0,255],[127,0,255],[75,0,130],[255,0,255]],'uint8')
#print('colortableshape',colortable.shape)
filenames=[]
Multiimaginarye={}
Multigray={}
Multitype={}
Multiimaginaryebands={}
Multigraybands={}
workbandnumset={}
displaybandnumset={}
originbandnumset={}
colorindicenumset={}
clusterdisplay={}
kernersizes={}
multi_results={}
outputimgdict={}
outputimgbands={}
outputsegbands={}
originsegbands={}
oldpcachoice=[]
multiselectitems=[]
coinbox_list=[]
pre_checkbox=[]
origibncabands={}
batch={'PCweight':[],
'PCsel':[],
'Kaverages':[],
'Kaverages_sel':[],
'Area_get_max':[],
'Area_get_min':[],
'shape_get_max':[],
'shape_get_min':[],
'nonzero':[]}
root=Tk()
root.title('GridFree v.1.1.0 ')
root.geometry("")
root.option_add_concat('*tearoff',False)
emptymenu=Menu(root)
root.config(menu=emptymenu)
screenheight=root.winfo_screenheight()
screenwidth=root.winfo_screenwidth()
print('screenheight',screenheight,'screenwidth',screenwidth)
screenstandard_op=get_min(screenheight-100,screenwidth-100,850)
coinsize=StringVar()
selarea=StringVar()
refvar=StringVar()
imgtypevar=StringVar()
edge=StringVar()
kaverages=IntVar()
pc_combine_up=DoubleVar()
pc_combine_down=IntVar()
filedropvar=StringVar()
displaybut_var=StringVar()
buttonvar=IntVar()
bandchoice={}
checkboxdict={}
#get_minipixelareaclass=0
coinbox=None
currentfilename=''
currentlabels=None
displaylabels=None
workingimg=None
displaypclabels=None
boundaryarea=None
outputbutton=None
font=None
reseglabels=None
coindict=None
## Funcitons
refarea=None
originlabels=None
originlabeldict=None
changekaverages=False
convband=None
reflabel=0
get_minflash=[]
dotflash=[]
labelplotmap={}
mappath=''
elesize=[]
labellist=[]
figdotlist={}
havecolorstrip=True
kaverageschanged=False
pcweightchanged=False
originbinaryimg=None
clusterchanged=False
originselarea=False
zoomoff=False
get_maxx=0
get_minx=0
bins=None
loccanvas=None
linelocs=[0,0,0,0]
get_maxy=0
get_miny=0
segmentratio=0
zoombox=[]
displayfea_l=0
displayfea_w=0
resizeshape=[]
previewshape=[]
pcbuttons=[]
pcbuttonsgroup=[]
def distance(p1,p2):
return bn.total_count((p1-p2)**2)
def findratio(originsize,objectsize):
oria=originsize[0]
orib=originsize[1]
obja=objectsize[0]
objb=objectsize[1]
if oria>obja or orib>objb:
ratio=round(get_max((oria/obja),(orib/objb)))
else:
ratio=round(get_min((obja/oria),(objb/orib)))
# if oria*orib>850 * 850:
if oria*orib>screenstandard_op * screenstandard_op:
if ratio<2:
ratio=2
return ratio
def getkeys(dict):
return [*dict]
def remove_operationzoom(event,widget):
print('leave widget')
if len(zoombox)>0:
for i in range(len(zoombox)):
#print('remove_operation')
widget.remove_operation(zoombox.pop(0))
widget.update()
def zoom(event,widget,img):
global zoombox
x=event.x
y=event.y
#print(x,y)
if len(zoombox)>1:
widget.remove_operation(zoombox.pop(0))
#print('remove_operation')
crop=img.crop((x-15,y-15,x+15,y+15))
w,h=crop.size
#print(w,h)
crop=crop.resize([w*3,h*3],resample=Image.BILINEAR)
w,h=crop.size
crop=ImageTk.PhotoImage(crop)
zoombox.apd(widget.create_imaginarye(x+5,y-5,imaginarye=crop))
root.update_idletasks()
raise NameError
#time.sleep(0.1)
def changedisplay_pc(frame):
for widget in frame.winfo_children():
widget.pack_forget()
#widget.configure(imaginarye=displayimg[text])
#widget.imaginarye=displayimg[text]
#widget.pack()
w=displayimg['PCs']['Size'][1]
l=displayimg['PCs']['Size'][0]
widget.config(width=w,height=l)
widget.create_imaginarye(0,0,imaginarye=displayimg['PCs']['Image'],anchor=NW)
widget.pack()
widget.update()
def pcweightupdate(displayframe):
getPCs()
changedisplay_pc(displayframe)
def buttobnress(val,displayframe,buttonframe):
global buttonvar,pc_combine_up,kaverages
buttonvar.set(val)
kaverages.set(1)
pc_combine_up.set(0.5)
buttonchildren=buttonframe.winfo_children()
for child in buttonchildren:
child.config(highlightbackground='white')
print(buttonchildren[val])
buttonchild=buttonchildren[val]
buttonchild.config(highlightbackground='red')
print('press button ',buttonvar.get())
getPCs()
changedisplay_pc(displayframe)
# if kaverages.get()>1:
changekaveragesbar('')
beforecluster('')
# changecluster('')
def PCbuttons(frame,displayframe):
#display pc buttons
# buttonvar=IntVar()
#buttonvar.set(0)
for widget in frame.winfo_children():
widget.pack_forget()
buttonframe=LabelFrame(frame)
buttonframe.pack()
for i in range(len(pcbuttons)):
butimg=pcbuttons[i]
but=Button(buttonframe,text='',imaginarye=butimg,compound=TOP,command=partial(buttobnress,i,displayframe,buttonframe))
if i==buttonvar.get():
but.config(highlightbackground='red')
row=int(i/3)
col=i%3
# print(row,col)
but.grid(row=int(i/3),column=col)
print('default button',buttonvar.get())
# change cluster,display
def displaypreview(text):
global figcanvas,resviewframe
for widget in resviewframe.winfo_children():
widget.pack_forget()
# previewframe=Canvas(frame,width=450,height=400,bg='white')
figcanvas.pack()
figcanvas.remove_operation(ALL)
if text=='Color Deviation':
previewtext='ColorIndices'
if text=='ColorIndices':
previewtext='Color Deviation'
previewimaginarye=previewimg[previewtext]['Image']
figcanvas.create_imaginarye(0,0,imaginarye=previewimaginarye,anchor=NW)
figcanvas.update()
def switchevent(event,widget,img):
global zoomoff,zoomfnid_m,zoomfnid_l,zoombox
zoomoff= not zoomoff
if zoomoff==True:
widget.unbind('<Motion>',zoomfnid_m)
widget.unbind('<Leave>',zoomfnid_l)
if len(zoombox)>0:
for i in range(len(zoombox)):
widget.remove_operation(zoombox.pop(0))
widget.update()
else:
zoomfnid_m=widget.bind('<Motion>',lambda event,arg=widget:zoom(event,arg,img))
zoomfnid_l=widget.bind('<Leave>',lambda event,arg=widget:remove_operationzoom(event,arg))
def changedisplayimg(frame,text):
global displaybut_var,figcanvas,resviewframe,reflabel
displaybut_var.set(disbuttonoption[text])
for widget in frame.winfo_children():
widget.pack_forget()
#widget.configure(imaginarye=displayimg[text])
#widget.imaginarye=displayimg[text]
#widget.pack()
w=displayimg[text]['Size'][1]
l=displayimg[text]['Size'][0]
widget.config(width=w,height=l)
widget.create_imaginarye(0,0,imaginarye=displayimg[text]['Image'],anchor=NW)
widget.pack()
widget.update()
global rects,selareapos,app,delapp,delrects,delselarea,originselarea
global zoomfnid_m,zoomfnid_l
app=sel_area.Application(widget)
# delapp=sel_area.Application(widget)
if text=='Output':
try:
imaginarye=outputsegbands[currentfilename]['iter0']
displayfig()
except:
return
zoomfnid_m=widget.bind('<Motion>',lambda event,arg=widget:zoom(event,arg,imaginarye))
zoomfnid_l=widget.bind('<Leave>',lambda event,arg=widget:remove_operationzoom(event,arg))
delrects=app.start(zoomfnid_m,zoomfnid_l)
widget.bind('<Double-Button-1>',lambda event,arg=widget:switchevent(event,arg,imaginarye))
print('delrects',delrects)
else:
reflabel=0
print('reflabel=',reflabel)
try:
delelareadim=app.getinfo(delrects[1])
if delelareadim!=[]:
delselarea=delelareadim
app.end()
except:
pass
if text=='Origin':
try:
imaginarye=originsegbands['Origin']
zoomfnid_m=widget.bind('<Motion>',lambda event,arg=widget:zoom(event,arg,imaginarye))
zoomfnid_l=widget.bind('<Leave>',lambda event,arg=widget:remove_operationzoom(event,arg))
except:
return
widget.bind('<Double-Button-1>',lambda event,arg=widget:switchevent(event,arg,imaginarye))
for widget in resviewframe.winfo_children():
widget.pack_forget()
rects=app.start()
print(rects)
originselarea=True
else:
widget.unbind('<Motion>')
selareadim=app.getinfo(rects[1])
if selareadim!=[]:
selareapos=selareadim
app.end(rects)
if text=='PCs':
selareadim=app.getinfo(rects[1])
if selareadim!=[0,0,1,1] and selareadim!=[] and selareadim!=selareapos:
selareapos=selareadim
if selareapos!=[0,0,1,1] and originselarea==True:
#need to redo PCA
bnfilter=bn.zeros((displayimg['Origin']['Size'][0],displayimg['Origin']['Size'][1]))
filter=Image.fromnumset(bnfilter)
draw=ImageDraw.Draw(filter)
draw.ellipse(selareapos,fill='red')
filter=bn.numset(filter)
filter=bn.divide(filter,bn.get_max(filter))
filter=cv2.resize(filter,(displayfea_w,displayfea_l),interpolation=cv2.INTER_LINEAR)
partialsingleband(filter)
originselarea=False
pass
PCbuttons(resviewframe,frame)
pass
if text=='Color Deviation':
#displaypreview
displaypreview(text)
pass
if text=='ColorIndices':
#displaypreview
displaypreview(text)
pass
#print('change to '+text)
#time.sleep(1)
def updateresizeshape(shape,content):
shape.apd(int(content))
return shape
def generatedisplayimg(filename): # init display imaginaryes
global resizeshape,previewshape
try:
# firstimg=Multiimaginaryebands[filename]
#height,width=firstimg.size
# height,width,c=displaybandnumset[filename]['LabOstu'].shape
bandsize=Multiimaginaryebands[filename].size
if bandsize[0]*bandsize[1]>2000*2000:
ratio=findratio([bandsize[0],bandsize[1]],[2000,2000])
else:
ratio=1
height,width=bandsize[0]/ratio,bandsize[1]/ratio
# ratio=findratio([height,width],[850,850])
ratio=findratio([height,width],[screenstandard_op,screenstandard_op])
print('displayimg ratio',ratio)
resizeshape=[]
# if height*width<850*850:
if height*width<screenstandard_op*screenstandard_op:
#resize=cv2.resize(Multiimaginarye[filename],(int(width*ratio),int(height*ratio)),interpolation=cv2.INTER_LINEAR)
updateresizeshape(resizeshape,width*ratio)
updateresizeshape(resizeshape,height*ratio)
# resizeshape.apd(width*ratio)
# resizeshape.apd(height*ratio)
if height>screenstandard_op:
resizeshape=[]
ratio=round(height/screenstandard_op)
updateresizeshape(resizeshape,width*ratio)
updateresizeshape(resizeshape,height*ratio)
if width>screenstandard_op:
resizeshape=[]
ratio=round(width/screenstandard_op)
updateresizeshape(resizeshape,width*ratio)
updateresizeshape(resizeshape,height*ratio)
else:
#resize=cv2.resize(Multiimaginarye[filename],(int(width/ratio),int(height/ratio)),interpolation=cv2.INTER_LINEAR)
updateresizeshape(resizeshape,width/ratio)
updateresizeshape(resizeshape,height/ratio)
ratio=findratio([height,width],[400,450])
previewshape=[]
if height*width<450*400:
#resize=cv2.resize(Multiimaginarye[filename],(int(width*ratio),int(height*ratio)),interpolation=cv2.INTER_LINEAR)
updateresizeshape(previewshape,width*ratio)
updateresizeshape(previewshape,height*ratio)
if height>400:
previewshape=[]
ratio=round(height/screenstandard_op)
updateresizeshape(previewshape,width/ratio)
updateresizeshape(previewshape,height/ratio)
if width>450:
previewshape=[]
ratio=round(width/screenstandard_op)
updateresizeshape(previewshape,width/ratio)
updateresizeshape(previewshape,height/ratio)
else:
#resize=cv2.resize(Multiimaginarye[filename],(int(width/ratio),int(height/ratio)),interpolation=cv2.INTER_LINEAR)
updateresizeshape(previewshape,width/ratio)
updateresizeshape(previewshape,height/ratio)
resize=cv2.resize(Multiimaginarye[filename],(int(resizeshape[0]),int(resizeshape[1])),interpolation=cv2.INTER_LINEAR)
originimg=Image.fromnumset(resize.convert_type('uint8'))
originsegbands.update({'Origin':originimg})
rgbimg=Image.fromnumset(resize.convert_type('uint8'))
draw=ImageDraw.Draw(rgbimg)
suggsize=14
font=ImageFont.truetype('cmb10.ttf',size=suggsize)
content='\n File: '+filename
draw.text((10-1, 10+1), text=content, font=font, fill='white')
draw.text((10+1, 10+1), text=content, font=font, fill='white')
draw.text((10-1, 10-1), text=content, font=font, fill='white')
draw.text((10+1, 10-1), text=content, font=font, fill='white')
#draw.text((10,10),text=content,font=font,fill=(141,2,31,0))
draw.text((10,10),text=content,font=font,fill='black')
rgbimg=ImageTk.PhotoImage(rgbimg)
tempdict={}
tempdict.update({'Size':resize.shape})
tempdict.update({'Image':rgbimg})
except:
tempdict={}
tempimg=bn.zeros((screenstandard_op,screenstandard_op))
tempdict.update({'Size':tempimg.shape})
tempdict.update({'Image':ImageTk.PhotoImage(Image.fromnumset(tempimg.convert_type('uint8')))})
displayimg['Origin']=tempdict
#if height*width<850*850:
# resize=cv2.resize(Multigray[filename],(int(width*ratio),int(height*ratio)),interpolation=cv2.INTER_LINEAR)
#else:
#resize=cv2.resize(Multigray[filename],(int(width/ratio),int(height/ratio)),interpolation=cv2.INTER_LINEAR)
tempimg=bn.zeros((screenstandard_op,screenstandard_op))
tempdict={}
try:
tempdict.update({'Size':resize.shape})
tempdict.update({'Image':ImageTk.PhotoImage(Image.fromnumset(bn.zeros((int(resizeshape[1]),int(resizeshape[0]))).convert_type('uint8')))})
except:
tempdict.update({'Size':tempimg.shape})
#if height*width<850*850:
# tempdict.update({'Image':ImageTk.PhotoImage(Image.fromnumset(bn.zeros((int(height*ratio),int(width*ratio))).convert_type('uint8')))})
#else:
# tempdict.update({'Image':ImageTk.PhotoImage(Image.fromnumset(bn.zeros((int(height/ratio),int(width/ratio))).convert_type('uint8')))})
# tempdict.update({'Image':ImageTk.PhotoImage(Image.fromnumset(bn.zeros((int(resizeshape[1]),int(resizeshape[0]))).convert_type('uint8')))})
tempdict.update({'Image':ImageTk.PhotoImage(Image.fromnumset(tempimg.convert_type('uint8')))})
displayimg['Output']=tempdict
tempdict={}
try:
tempdict.update({'Size':resize.shape})
tempdict.update({'Image':ImageTk.PhotoImage(Image.fromnumset(bn.zeros((int(resizeshape[1]),int(resizeshape[0]))).convert_type('uint8')))})
except:
tempdict.update({'Size':tempimg.shape})
tempdict.update({'Image':ImageTk.PhotoImage(Image.fromnumset(tempimg.convert_type('uint8')))})
displayimg['PCs']=tempdict
tempdict={}
temppreviewdict={}
temppreviewimg=bn.zeros((450,400))
try:
tempband=bn.zeros((displaybandnumset[filename]['LabOstu'][:,:,0].shape))
# tempband=tempband+displaybandnumset[filename]['LabOstu']
# ratio=findratio([tempband.shape[0],tempband.shape[1]],[850,850])
#if tempband.shape[0]*tempband.shape[1]<850*850:
# tempband=cv2.resize(ratio,(int(tempband.shape[1]*ratio),int(tempband.shape[0]*ratio)),interpolation=cv2.INTER_LINEAR)
#else:
# tempband=cv2.resize(ratio,(int(tempband.shape[1]/ratio),int(tempband.shape[0]/ratio)),interpolation=cv2.INTER_LINEAR)
tempband=cv2.resize(tempband,(int(resizeshape[0]),int(resizeshape[1])),interpolation=cv2.INTER_LINEAR)
tempdict.update({'Size':tempband.shape})
tempdict.update({'Image':ImageTk.PhotoImage(Image.fromnumset(tempband[:,:,2].convert_type('uint8')))})
temppreview=cv2.resize(tempband,(int(previewshape[0]),int(previewshape[1])),interpolation=cv2.INTER_LINEAR)
temppreview=Image.fromnumset(temppreview.convert_type('uint8'))
temppreviewdict.update({'Size':previewshape})
temppreviewdict.update({'Image':ImageTk.PhotoImage(temppreview)})
# print('resizeshape',resizeshape)
#pyplt.imsave('displayimg.png',tempband[:,:,0])
#indimg=cv2.imread('displayimg.png')
except:
tempdict.update({'Size':tempimg.shape})
tempdict.update({'Image':ImageTk.PhotoImage(Image.fromnumset(tempimg.convert_type('uint8')))})
temppreviewdict.update({'Size':temppreviewimg.shape})
temppreviewdict.update({'Image':ImageTk.PhotoImage(Image.fromnumset(temppreviewimg.convert_type('uint8')))})
displayimg['ColorIndices']=tempdict
previewimg['ColorIndices']=temppreviewdict
#resize=cv2.resize(Multigray[filename],(int(resizeshape[0]),int(resizeshape[1])),interpolation=cv2.INTER_LINEAR)
#grayimg=ImageTk.PhotoImage(Image.fromnumset(resize.convert_type('uint8')))
#tempdict={}
#tempdict.update({'Size':resize.shape})
#tempdict.update({'Image':grayimg})
tempdict={}
temppreviewdict={}
try:
colordeviate=bn.zeros((tempband[:,:,0].shape[0],tempband[:,:,0].shape[1],3),'uint8')
kvar=int(kaverages.get())
for i in range(kvar):
locs=bn.filter_condition(tempband[:,:,0]==i)
colordeviate[locs]=colorbandtable[i,:]
# pyplt.imsave('colordeviation.png',colordeviate)
# # colordevimg=Image.fromnumset(colordeviate.convert_type('uint8'))
# # colordevimg.save('colordeviation.png',"PNG")
# testcolor=Image.open('colordeviation.png')
print('colordeviation.png')
# colortempdict={}
colordeviate=cv2.resize(colordeviate,(int(resizeshape[0]),int(resizeshape[1])),interpolation=cv2.INTER_LINEAR)
tempdict.update({'Size':colordeviate.shape})
tempdict.update({'Image':ImageTk.PhotoImage(Image.fromnumset(colordeviate.convert_type('uint8')))})
# colortempdict.update({'Size':colordeviate.shape})
# colortempdict.update({'Image':ImageTk.PhotoImage(Image.fromnumset(colordeviate.convert_type('uint8')))})
# colortempdict.update({'Image':ImageTk.PhotoImage(testcolor)})
# tempdict={}
temppreview=cv2.resize(colordeviate,(int(previewshape[0]),int(previewshape[1])),interpolation=cv2.INTER_LINEAR)
temppreviewdict.update({'Size':temppreview.shape})
temppreviewdict.update({'Image':ImageTk.PhotoImage(Image.fromnumset(temppreview[:,:,0].convert_type('uint8')))})
except:
tempdict.update({'Size':tempimg.shape})
tempdict.update({'Image':ImageTk.PhotoImage(Image.fromnumset(tempimg.convert_type('uint8')))})
temppreviewdict.update({'Size':temppreviewimg.shape})
temppreviewdict.update({'Image':ImageTk.PhotoImage(Image.fromnumset(temppreviewimg.convert_type('uint8')))})
# displayimg['Color Deviation']=colortempdict
displayimg['Color Deviation']=tempdict
previewimg['Color Deviation']=temppreviewdict
def Open_File(filename): #add_concat to multi-imaginarye,multi-gray #ctotal band calculation
global Multiimaginarye,Multigray,Multitype,Multiimaginaryebands,Multigraybands,filenames
try:
Filersc=cv2.imread(filename,flags=cv2.IMREAD_ANYCOLOR)
ndim=bn.ndim(Filersc)
if ndim==2:
height,width=bn.shape(Filersc)
channel=1
Filersc.change_shape_to((height,width,channel))
else:
height,width,channel=bn.shape(Filersc)
Filesize=(height,width)
print('filesize:',height,width)
RGBfile=cv2.cvtColor(Filersc,cv2.COLOR_BGR2RGB)
Multiimaginarye.update({filename:RGBfile})
if ndim==2:
Grayfile=bn.copy(Filersc)
else:
Grayfile=cv2.cvtColor(Filersc,cv2.COLOR_BGR2Lab)
Grayfile=cv2.cvtColor(Grayfile,cv2.COLOR_BGR2GRAY)
#Grayfile=cv2.GaussianBlur(Grayfile,(3,3),cv2.BORDER_DEFAULT)
#ostu=filters.threshold_otsu(Grayfile)
#Grayfile=Grayfile.convert_type('float32')
#Grayfile=Grayfile/ostu
Grayimg=img(Filesize,Grayfile)
RGBbands=bn.zeros((channel,height,width))
for j in range(channel):
band=RGBfile[:,:,j]
band=bn.filter_condition(band==0,1e-6,band)
nans=bn.ifnan(band)
band[nans]=1e-6
#ostu=filters.threshold_otsu(band)
#band=band/ostu
RGBbands[j,:,:]=band
RGBimg=img(Filesize,RGBbands)
tempdict={filename:RGBimg}
Multiimaginaryebands.update(tempdict)
tempdict={filename:Grayfile}
Multigray.update(tempdict)
tempdict={filename:0}
Multitype.update(tempdict)
tempdict={filename:Grayimg}
Multigraybands.update(tempdict)
except:
messagebox.showerror('Invalid Image Format','Cannot open '+filename)
return False
filenames.apd(filename)
return True
def Open_Map():
if proc_mode[proc_name].get()=='1':
batchprocess.Open_batchfile()
return
global mappath,elesize,labellist
filepath=filedialog.askopenfilename()
if len(filepath)>0:
if 'csv' in filepath:
mappath=filepath
elesize=[]
labellist=[]
rows=[]
print('open map at: '+mappath)
with open(mappath,mode='r',encoding='utf-8-sig') as f:
csvreader=csv.reader(f)
for row in csvreader:
rows.apd(row)
temprow=[]
for ele in row:
if ele is not '':
temprow.apd(ele)
elesize.apd(len(temprow))
for i in range(len(rows)):
for j in range(len(rows[i])):
if rows[i][j]!='':
labellist.apd(rows[i][j])
else:
messagebox.showerror('Invalide File',message='Please open csv formate file as map file.')
corlortable=tkintercorestat.get_colortable(reseglabels)
tup=(reseglabels,[],corlortable,{},currentfilename)
print(elesize)
mapdict,mapimaginarye,smtotalset=showcounting(tup,True,True,True)
tempimgbands={}
tempimgdict={}
tempsmtotal={}
tempimgbands.update({'iter0':mapimaginarye})
tempimgdict.update({'iter0':mapdict})
tempsmtotal.update({'iter0':smtotalset})
outputimgdict.update({currentfilename:tempimgdict})
outputimgbands.update({currentfilename:tempimgbands})
outputsegbands.update({currentfilename:tempsmtotal})
changeoutputimg(currentfilename,'1')
def Open_Multifile():
global extractbutton,outputbutton
if proc_mode[proc_name].get()=='1':
batchprocess.Open_batchfolder()
extractbutton.config(state=NORMAL)
outputbutton.config(state=NORMAL)
return
# else:
# extractbutton.config(state=DISABLED)
global Multiimaginarye,Multigray,Multitype,Multiimaginaryebands,changefileframe,imaginaryeframe,Multigraybands,filenames
global changefiledrop,filedropvar,originbandnumset,displaybandnumset,clusterdisplay,currentfilename,resviewframe
global refsubframe,reseglabels,refbutton,figcanvas,loccanvas,originlabels,changekaverages,refarea
global originlabeldict,convband,panelA
global havecolorstrip
global colordicesband,oldpcachoice
global pccombinebar_up
global displaylabels,displaypclabels
global buttonvar
global colorindicenumset
global selarea
MULTIFILES=filedialog.askopenfilenames()
root.update()
if len(MULTIFILES)>0:
Multiimaginarye={}
Multigray={}
Multitype={}
Multiimaginaryebands={}
Multigraybands={}
filenames=[]
originbandnumset={}
colorindicenumset={}
displaybandnumset={}
clusterdisplay={}
oldpcachoice=[]
reseglabels=None
originlabels=None
originlabeldict=None
#changekaverages=True
convband=None
refvar.set('0')
kaverages.set('2')
panelA.remove_operation(ALL)
panelA.unbind('<Button-1>')
panelA.unbind('<Shift-Button-1>')
refarea=None
havecolorstrip=False
displaypclabels=None
buttonvar.set(0)
# if 'NDI' in bandchoice:
# bandchoice['NDI'].set('1')
# if 'NDVI' in bandchoice:
# bandchoice['NDVI'].set('1')
refbutton.config(state=DISABLED)
# selareabutton.configure(state=DISABLED)
selarea.set('0')
figcanvas.remove_operation(ALL)
#loccanvas=None
for widget in refsubframe.winfo_children():
widget.config(state=DISABLED)
#for widget in resviewframe.winfo_children():
# widget.config(state=DISABLED)
if outputbutton is not None:
outputbutton.config(state=DISABLED)
for i in range(len(MULTIFILES)):
if Open_File(MULTIFILES[i])==False:
return
generatedisplayimg(filenames[0])
changedisplayimg(imaginaryeframe,'Origin')
# imaginaryeframe.update()
# raise NameError
# yield
# thread=threading.Thread(target=singleband,args=(MULTIFILES[i],))
singleband(MULTIFILES[i])
# thread.start()
# thread.join()
for widget in changefileframe.winfo_children():
widget.pack_forget()
currentfilename=filenames[0]
# filedropvar.set(filenames[0])
# changefiledrop=OptionMenu(changefileframe,filedropvar,*filenames,command=partial(changeimaginarye,imaginaryeframe))
# changefiledrop.pack()
#singleband(filenames[0])
generatedisplayimg(filenames[0])
# changedisplayimg(imaginaryeframe,'Origin')
getPCs()
if len(bandchoice)>0:
for i in range(len(cluster)):
bandchoice[cluster[i]].set('')
#changedisplayimg(imaginaryeframe,'Origin')
kaverages.set(1)
#change_shape_tomodified_tif=bn.zeros((displaybandnumset[currentfilename]['LabOstu'].shape[0]*displaybandnumset[currentfilename]['LabOstu'].shape[1],3))
#colordicesband=kaveragesclassify(['LabOstu'],change_shape_tomodified_tif)
displaylabels=kaveragesclassify()
generateimgplant('')
changedisplayimg(imaginaryeframe,'Origin')
# if len(bandchoice)>0:
# bandchoice['LabOstu'].set('1')
global buttondisplay,pcaframe,kaveragesbar
for widget in buttondisplay.winfo_children():
widget.config(state=NORMAL)
# for widget in pcaframe.winfo_children():
# for widget in pcselframe.winfo_children():
# widget.config(state=NORMAL)
extractbutton.config(state=NORMAL)
kaveragesbar.state(["!disabled"])
pccombinebar_up.state(["!disabled"])
def fillpartialbands(vector,vectorindex,band,filter_vector):
nonzero=bn.filter_condition(filter_vector!=0)
vector[nonzero,vectorindex]=vector[nonzero,vectorindex]+band
def fillbands(originbands,displaybands,vector,vectorindex,name,band,filter=0):
tempdict={name:band}
if isinstance(filter,int):
if name not in originbands:
originbands.update(tempdict)
imaginarye=cv2.resize(band,(displayfea_w,displayfea_l),interpolation=cv2.INTER_LINEAR)
displaydict={name:imaginarye}
displaybands.update(displaydict)
fea_bands=imaginarye.change_shape_to((displayfea_l*displayfea_w),1)[:,0]
vector[:,vectorindex]=vector[:,vectorindex]+fea_bands
else:
if name not in originbands:
originbands.update(tempdict)
imaginarye=cv2.resize(band,(displayfea_w,displayfea_l),interpolation=cv2.INTER_LINEAR)
imaginarye=bn.multiply(imaginarye,filter)
displaydict={name:imaginarye}
displaybands.update(displaydict)
fea_bands=imaginarye.change_shape_to((displayfea_l*displayfea_w),1)[:,0]
vector[:,vectorindex]=vector[:,vectorindex]+fea_bands
return
def plot3d(pcas):
from mpl_toolkits.mplot3d import Axes3D # noqa: F401 unused import
import matplotlib.pyplot as plt
fig=plt.figure()
ax=fig.add_concat_subplot(111,projection='3d')
x=pcas[:,0]
y=pcas[:,1]
z=pcas[:,2]*0+bn.get_min(pcas[:,2])
ax.scatter(x,y,z,color='tab:purple')
x=pcas[:,0]*0+bn.get_min(pcas[:,0])
y=pcas[:,1]
z=pcas[:,2]
ax.scatter(x,y,z,color='tab:pink')
x=pcas[:,0]
y=pcas[:,1]*0+bn.get_max(pcas[:,1])
z=pcas[:,2]
ax.scatter(x,y,z,color='tab:olive')
ax.set_xlabel('Color Indices PC1')
ax.set_ylabel('Color Indices PC2')
ax.set_zlabel('Color Indices PC3')
# plt.show()
plt.savefig('3dplot_PC.png')
def partialoneband(filter):
global displaybandnumset,origibncabands
global pcbuttons
global nonzero_vector,partialpca
partialpca=True
bands=Multiimaginaryebands[currentfilename].bands
channel,fea_l,fea_w=bands.shape
nonzero=bn.filter_condition(filter!=0)
RGB_vector=bn.zeros((displayfea_l*displayfea_w,3))
colorindex_vector=bn.zeros((displayfea_l*displayfea_w,12))
filter_vector=filter.change_shape_to((displayfea_l*displayfea_w),1)[:,0]
originbands={}
displays={}
Red=cv2.resize(bands[0,:,:],(displayfea_w,displayfea_l),interpolation=cv2.INTER_LINEAR)[nonzero]
Green=cv2.resize(bands[0,:,:],(displayfea_w,displayfea_l),interpolation=cv2.INTER_LINEAR)[nonzero]
# Red=cv2.adaptiveThreshold(Red,255,cv2.ADAPTIVE_THRESH_MEAN_C,cv2.THRESH_BINARY,11,2)
# Green=cv2.adaptiveThreshold(Green,255,cv2.ADAPTIVE_THRESH_GAUSSIAN_C,cv2.THRESH_BINARY,11,2)
Blue=cv2.resize(bands[0,:,:],(displayfea_w,displayfea_l),interpolation=cv2.INTER_LINEAR)[nonzero]
# Blue=cv2.threshold(Blue,0,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU)
fillpartialbands(RGB_vector,0,Red,filter_vector)
fillpartialbands(RGB_vector,1,Green,filter_vector)
fillpartialbands(RGB_vector,2,Blue,filter_vector)
PAT_R=Red
PAT_G=Red
PAT_B=Red
ROO_R=Red
ROO_G=Red
ROO_B=Red
DIF_R=Red
DIF_G=Red
DIF_B=Red
GLD_R=Red
GLD_G=Red
GLD_B=Red
fillpartialbands(colorindex_vector,0,PAT_R,filter_vector)
fillpartialbands(colorindex_vector,1,PAT_G,filter_vector)
fillpartialbands(colorindex_vector,2,PAT_B,filter_vector)
fillpartialbands(colorindex_vector,3,ROO_R,filter_vector)
fillpartialbands(colorindex_vector,4,ROO_G,filter_vector)
fillpartialbands(colorindex_vector,5,ROO_B,filter_vector)
fillpartialbands(colorindex_vector,6,DIF_R,filter_vector)
fillpartialbands(colorindex_vector,7,DIF_G,filter_vector)
fillpartialbands(colorindex_vector,8,DIF_B,filter_vector)
fillpartialbands(colorindex_vector,9,GLD_R,filter_vector)
fillpartialbands(colorindex_vector,10,GLD_G,filter_vector)
fillpartialbands(colorindex_vector,11,GLD_B,filter_vector)
nonzero_vector=bn.filter_condition(filter_vector!=0)
displayfea_vector=bn.connect((RGB_vector,colorindex_vector),axis=1)
featurechannel=14
# bn.savetxt('color-index.csv',displayfea_vector,delimiter=',',fmt='%10.5f')
# displayfea_vector=bn.connect((RGB_vector,colorindex_vector),axis=1)
origibncabands.update({currentfilename:displayfea_vector})
pcabandsdisplay=displayfea_vector[:,:14]
pcabandsdisplay=pcabandsdisplay.change_shape_to(displayfea_l,displayfea_w,featurechannel)
tempdictdisplay={'LabOstu':pcabandsdisplay}
displaybandnumset.update({currentfilename:tempdictdisplay})
# originbandnumset.update({currentfilename:originbands})
# Red=displays['Band1']
# Green=displays['Band2']
# Blue=displays['Band3']
# convimg=bn.zeros((Red.shape[0],Red.shape[1],3))
# convimg[:,:,0]=Red
# convimg[:,:,1]=Green
# convimg[:,:,2]=Blue
# convimg=Image.fromnumset(convimg.convert_type('uint8'))
# convimg.save('convimg.png','PNG')
pcbuttons=[]
need_w=int(450/3)
need_h=int(400/4)
for i in range(2,3):
band=bn.copy(pcabandsdisplay[:,:,i])
# imgband=(band-band.get_min())*255/(band.get_max()-band.get_min())
imgband=bn.copy(band)
pcimg=Image.fromnumset(imgband.convert_type('uint8'),'L')
# pcimg.save('pc'+'_'+str(i)+'.png',"PNG")
pcimg.thumbnail((need_w,need_h),Image.ANTIALIAS)
# pcimg.save('pc'+'_'+str(i)+'.png',"PNG")
# ratio=get_max(displayfea_l/need_h,displayfea_w/need_w)
# print('origin band range',band.get_max(),band.get_min())
# # band,cache=tkintercorestat.pool_forward(band,{"f":int(ratio),"stride":int(ratio)})
# band=cv2.resize(band,(need_w,need_h),interpolation=cv2.INTER_LINEAR)
# bandrange=band.get_max()-band.get_min()
# print('band range',band.get_max(),band.get_min())
# band=(band-band.get_min())/bandrange*255
# print('button img range',band.get_max(),band.get_min())
# buttonimg=Image.fromnumset(band.convert_type('uint8'),'L')
pcbuttons.apd(ImageTk.PhotoImage(pcimg))
def partialsingleband(filter):
global displaybandnumset,origibncabands
global pcbuttons
global nonzero_vector,partialpca
partialpca=True
bands=Multiimaginaryebands[currentfilename].bands
channel,fea_l,fea_w=bands.shape
nonzero=bn.filter_condition(filter!=0)
RGB_vector=bn.zeros((displayfea_l*displayfea_w,3))
colorindex_vector=bn.zeros((displayfea_l*displayfea_w,12))
filter_vector=filter.change_shape_to((displayfea_l*displayfea_w),1)[:,0]
originbands={}
displays={}
if channel==1:
# Red=cv2.resize(bands[0,:,:],(displayfea_w,displayfea_l),interpolation=cv2.INTER_LINEAR)[nonzero]
# Green=cv2.resize(bands[0,:,:],(displayfea_w,displayfea_l),interpolation=cv2.INTER_LINEAR)[nonzero]
# Blue=cv2.resize(bands[0,:,:],(displayfea_w,displayfea_l),interpolation=cv2.INTER_LINEAR)[nonzero]
# fillpartialbands(RGB_vector,0,Red,filter_vector)
# fillpartialbands(RGB_vector,1,Green,filter_vector)
# fillpartialbands(RGB_vector,2,Blue,filter_vector)
partialoneband(filter)
return
else:
Red=cv2.resize(bands[0,:,:],(displayfea_w,displayfea_l),interpolation=cv2.INTER_LINEAR)[nonzero]
Green=cv2.resize(bands[1,:,:],(displayfea_w,displayfea_l),interpolation=cv2.INTER_LINEAR)[nonzero]
Blue=cv2.resize(bands[2,:,:],(displayfea_w,displayfea_l),interpolation=cv2.INTER_LINEAR)[nonzero]
fillpartialbands(RGB_vector,0,Red,filter_vector)
fillpartialbands(RGB_vector,1,Green,filter_vector)
fillpartialbands(RGB_vector,2,Blue,filter_vector)
PAT_R=Red/(Red+Green)
PAT_G=Green/(Green+Blue)
PAT_B=Blue/(Blue+Red)
ROO_R=Red/Green
ROO_G=Green/Blue
ROO_B=Blue/Red
DIF_R=2*Red-Green-Blue
DIF_G=2*Green-Blue-Red
DIF_B=2*Blue-Red-Green
GLD_R=Red/(bn.multiply(bn.power(Blue,0.618),bn.power(Green,0.382)))
GLD_G=Green/(bn.multiply(bn.power(Blue,0.618),bn.power(Red,0.382)))
GLD_B=Blue/(bn.multiply(bn.power(Green,0.618),bn.power(Red,0.382)))
fillpartialbands(colorindex_vector,0,PAT_R,filter_vector)
fillpartialbands(colorindex_vector,1,PAT_G,filter_vector)
fillpartialbands(colorindex_vector,2,PAT_B,filter_vector)
fillpartialbands(colorindex_vector,3,ROO_R,filter_vector)
fillpartialbands(colorindex_vector,4,ROO_G,filter_vector)
fillpartialbands(colorindex_vector,5,ROO_B,filter_vector)
fillpartialbands(colorindex_vector,6,DIF_R,filter_vector)
fillpartialbands(colorindex_vector,7,DIF_G,filter_vector)
fillpartialbands(colorindex_vector,8,DIF_B,filter_vector)
fillpartialbands(colorindex_vector,9,GLD_R,filter_vector)
fillpartialbands(colorindex_vector,10,GLD_G,filter_vector)
fillpartialbands(colorindex_vector,11,GLD_B,filter_vector)
for i in range(12):
perc=bn.percentile(colorindex_vector[:,i],1)
print('perc',perc)
colorindex_vector[:,i]=bn.filter_condition(colorindex_vector[:,i]<perc,perc,colorindex_vector[:,i])
perc=bn.percentile(colorindex_vector[:,i],99)
print('perc',perc)
colorindex_vector[:,i]=bn.filter_condition(colorindex_vector[:,i]>perc,perc,colorindex_vector[:,i])
for i in range(3):
perc=bn.percentile(RGB_vector[:,i],1)
print('perc',perc)
RGB_vector[:,i]=bn.filter_condition(RGB_vector[:,i]<perc,perc,RGB_vector[:,i])
perc=bn.percentile(RGB_vector[:,i],99)
print('perc',perc)
RGB_vector[:,i]=bn.filter_condition(RGB_vector[:,i]>perc,perc,RGB_vector[:,i])
nonzero_vector=bn.filter_condition(filter_vector!=0)
rgb_M=bn.average(RGB_vector[nonzero_vector,:].T,axis=1)
colorindex_M=bn.average(colorindex_vector[nonzero_vector,:].T,axis=1)
print('rgb_M',rgb_M,'colorindex_M',colorindex_M)
rgb_C=RGB_vector[nonzero_vector,:][0]-rgb_M.T
colorindex_C=colorindex_vector[nonzero_vector,:][0]-colorindex_M.T
rgb_V=bn.corrcoef(rgb_C.T)
color_V=bn.corrcoef(colorindex_C.T)
nans=bn.ifnan(color_V)
color_V[nans]=1e-6
rgb_standard_op=rgb_C/(bn.standard_op(RGB_vector[nonzero_vector,:].T,axis=1)).T
color_standard_op=colorindex_C/(bn.standard_op(colorindex_vector[nonzero_vector,:].T,axis=1)).T
nans=bn.ifnan(color_standard_op)
color_standard_op[nans]=1e-6
rgb_eigval,rgb_eigvec=bn.linalg.eig(rgb_V)
color_eigval,color_eigvec=bn.linalg.eig(color_V)
print('rgb_eigvec',rgb_eigvec)
print('color_eigvec',color_eigvec)
featurechannel=12
pcabands=bn.zeros((colorindex_vector.shape[0],featurechannel))
rgbbands=bn.zeros((colorindex_vector.shape[0],3))
for i in range(0,9):
pcn=color_eigvec[:,i]
pcnbands=bn.dot(color_standard_op,pcn)
pcvar=bn.var(pcnbands)
print('color index pc',i+1,'var=',pcvar)
pcabands[nonzero_vector,i]=pcabands[nonzero_vector,i]+pcnbands
for i in range(9,12):
pcn=rgb_eigvec[:,i-9]
pcnbands=bn.dot(rgb_standard_op,pcn)
pcvar=bn.var(pcnbands)
print('rgb pc',i-9+1,'var=',pcvar)
pcabands[nonzero_vector,i]=pcabands[nonzero_vector,i]+pcnbands
rgbbands[nonzero_vector,i-9]=rgbbands[nonzero_vector,i-9]+pcnbands
# plot3d(pcabands)
# bn.savetxt('rgb.csv',rgbbands,delimiter=',',fmt='%10.5f')
# pcabands[:,1]=bn.copy(pcabands[:,1])
# pcabands[:,2]=pcabands[:,2]*0
# indexbands=bn.zeros((colorindex_vector.shape[0],3))
# if i<5:
# indexbands[:,i-2]=indexbands[:,i-2]+pcnbands
for i in range(12):
perc=bn.percentile(pcabands[:,i],1)
print('perc',perc)
pcabands[:,i]=bn.filter_condition(pcabands[:,i]<perc,perc,pcabands[:,i])
perc=bn.percentile(pcabands[:,i],99)
print('perc',perc)
pcabands[:,i]=bn.filter_condition(pcabands[:,i]>perc,perc,pcabands[:,i])
'''save to csv'''
# indexbands[:,0]=indexbands[:,0]+pcabands[:,2]
# indexbands[:,1]=indexbands[:,1]+pcabands[:,3]
# indexbands[:,2]=indexbands[:,2]+pcabands[:,4]
# plot3d(indexbands)
# bn.savetxt('pcs.csv',pcabands,delimiter=',',fmt='%10.5f')
displayfea_vector=bn.connect((RGB_vector,colorindex_vector),axis=1)
# bn.savetxt('color-index.csv',displayfea_vector,delimiter=',',fmt='%10.5f')
# displayfea_vector=bn.connect((RGB_vector,colorindex_vector),axis=1)
origibncabands.update({currentfilename:displayfea_vector})
pcabandsdisplay=pcabands.change_shape_to(displayfea_l,displayfea_w,featurechannel)
tempdictdisplay={'LabOstu':pcabandsdisplay}
displaybandnumset.update({currentfilename:tempdictdisplay})
# originbandnumset.update({currentfilename:originbands})
# Red=displays['Band1']
# Green=displays['Band2']
# Blue=displays['Band3']
# convimg=bn.zeros((Red.shape[0],Red.shape[1],3))
# convimg[:,:,0]=Red
# convimg[:,:,1]=Green
# convimg[:,:,2]=Blue
# convimg=Image.fromnumset(convimg.convert_type('uint8'))
# convimg.save('convimg.png','PNG')
pcbuttons=[]
need_w=int(450/3)
need_h=int(400/4)
for i in range(12):
band=bn.copy(pcabandsdisplay[:,:,i])
imgband=(band-band.get_min())*255/(band.get_max()-band.get_min())
pcimg=Image.fromnumset(imgband.convert_type('uint8'),'L')
# pcimg.save('pc'+'_'+str(i)+'.png',"PNG")
pcimg.thumbnail((need_w,need_h),Image.ANTIALIAS)
# pcimg.save('pc'+'_'+str(i)+'.png',"PNG")
# ratio=get_max(displayfea_l/need_h,displayfea_w/need_w)
# print('origin band range',band.get_max(),band.get_min())
# # band,cache=tkintercorestat.pool_forward(band,{"f":int(ratio),"stride":int(ratio)})
# band=cv2.resize(band,(need_w,need_h),interpolation=cv2.INTER_LINEAR)
# bandrange=band.get_max()-band.get_min()
# print('band range',band.get_max(),band.get_min())
# band=(band-band.get_min())/bandrange*255
# print('button img range',band.get_max(),band.get_min())
# buttonimg=Image.fromnumset(band.convert_type('uint8'),'L')
pcbuttons.apd(ImageTk.PhotoImage(pcimg))
def oneband(file):
global displaybandnumset,originbandnumset,origibncabands,displayfea_l,displayfea_w
global pcbuttons
global partialpca
partialpca=False
try:
bands=Multiimaginaryebands[file].bands
except:
return
pcbuttons=[]
channel,fea_l,fea_w=bands.shape
print('bandsize',fea_l,fea_w)
if fea_l*fea_w>2000*2000:
ratio=findratio([fea_l,fea_w],[2000,2000])
else:
ratio=1
print('ratio',ratio)
originbands={}
displays={}
displaybands=cv2.resize(bands[0,:,:],(int(fea_w/ratio),int(fea_l/ratio)),interpolation=cv2.INTER_LINEAR)
displayfea_l,displayfea_w=displaybands.shape
RGB_vector=bn.zeros((displayfea_l*displayfea_w,3))
colorindex_vector=bn.zeros((displayfea_l*displayfea_w,12))
Red=bands[0,:,:].convert_type('uint8')
# _,Red=cv2.threshold(Red,0,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU)
Green=bands[0,:,:].convert_type('uint8')
# _,Green=cv2.threshold(Green,0,255,cv2.THRESH_OTSU)
Blue=bands[0,:,:].convert_type('uint8')
# _,Blue=cv2.threshold(Blue,0,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU)
fillbands(originbands,displays,RGB_vector,0,'Band1',Red)
fillbands(originbands,displays,RGB_vector,1,'Band2',Green)
fillbands(originbands,displays,RGB_vector,2,'Band3',Blue)
PAT_R=bands[0,:,:].convert_type('uint8')
# PAT_R=cv2.adaptiveThreshold(PAT_R,255,cv2.ADAPTIVE_THRESH_GAUSSIAN_C,cv2.THRESH_BINARY,11,2)
PAT_G=bands[0,:,:]
# PAT_G=cv2.adaptiveThreshold(PAT_G,255,cv2.ADAPTIVE_THRESH_MEAN_C,cv2.THRESH_BINARY,11,2)
PAT_B=bands[0,:,:]
ROO_R=bands[0,:,:]
ROO_G=bands[0,:,:]
ROO_B=bands[0,:,:]
DIF_R=bands[0,:,:]
DIF_G=bands[0,:,:]
DIF_B=bands[0,:,:]
GLD_R=bands[0,:,:]
GLD_G=bands[0,:,:]
GLD_B=bands[0,:,:]
fillbands(originbands,displays,colorindex_vector,0,'PAT_R',PAT_R)
fillbands(originbands,displays,colorindex_vector,1,'PAT_G',PAT_G)
fillbands(originbands,displays,colorindex_vector,2,'PAT_B',PAT_B)
fillbands(originbands,displays,colorindex_vector,3,'ROO_R',ROO_R)
fillbands(originbands,displays,colorindex_vector,4,'ROO_G',ROO_G)
fillbands(originbands,displays,colorindex_vector,5,'ROO_B',ROO_B)
fillbands(originbands,displays,colorindex_vector,6,'DIF_R',DIF_R)
fillbands(originbands,displays,colorindex_vector,7,'DIF_G',DIF_G)
fillbands(originbands,displays,colorindex_vector,8,'DIF_B',DIF_B)
fillbands(originbands,displays,colorindex_vector,9,'GLD_R',GLD_R)
fillbands(originbands,displays,colorindex_vector,10,'GLD_G',GLD_G)
fillbands(originbands,displays,colorindex_vector,11,'GLD_B',GLD_B)
displayfea_vector=bn.connect((RGB_vector,colorindex_vector),axis=1)
# bn.savetxt('color-index.csv',displayfea_vector,delimiter=',',fmt='%10.5f')
featurechannel=14
origibncabands.update({file:displayfea_vector})
# pcabandsdisplay=pcabands.change_shape_to(displayfea_l,displayfea_w,featurechannel)
# pcabandsdisplay=bn.connect((RGB_vector,colorindex_vector),axis=2)
pcabandsdisplay=displayfea_vector[:,:14]
pcabandsdisplay=pcabandsdisplay.change_shape_to(displayfea_l,displayfea_w,featurechannel)
tempdictdisplay={'LabOstu':pcabandsdisplay}
displaybandnumset.update({file:tempdictdisplay})
originbandnumset.update({file:originbands})
# Red=displays['Band1']
# Green=displays['Band2']
# Blue=displays['Band3']
# convimg=bn.zeros((Red.shape[0],Red.shape[1],3))
# convimg[:,:,0]=Red
# convimg[:,:,1]=Green
# convimg[:,:,2]=Blue
# convimg=Image.fromnumset(convimg.convert_type('uint8'))
# convimg.save('convimg.png','PNG')
need_w=int(450/3)
need_h=int(400/4)
for i in range(2,3):
band=bn.copy(pcabandsdisplay[:,:,i])
# band=bn.copy(Red)
# imgband=(band-band.get_min())*255/(band.get_max()-band.get_min())
imgband=bn.copy(band)
pcimg=Image.fromnumset(imgband.convert_type('uint8'),'L')
# pcimg.save('pc'+'_'+str(i)+'.png',"PNG")
pcimg.thumbnail((need_w,need_h),Image.ANTIALIAS)
# pcimg.save('pc'+'_'+str(i)+'.png',"PNG")
# ratio=get_max(displayfea_l/need_h,displayfea_w/need_w)
# print('origin band range',band.get_max(),band.get_min())
# # band,cache=tkintercorestat.pool_forward(band,{"f":int(ratio),"stride":int(ratio)})
# band=cv2.resize(band,(need_w,need_h),interpolation=cv2.INTER_LINEAR)
# bandrange=band.get_max()-band.get_min()
# print('band range',band.get_max(),band.get_min())
# band=(band-band.get_min())/bandrange*255
# print('button img range',band.get_max(),band.get_min())
# buttonimg=Image.fromnumset(band.convert_type('uint8'),'L')
pcbuttons.apd(ImageTk.PhotoImage(pcimg))
def singleband(file):
global displaybandnumset,originbandnumset,origibncabands,displayfea_l,displayfea_w
global pcbuttons
global partialpca
partialpca=False
try:
bands=Multiimaginaryebands[file].bands
except:
return
pcbuttons=[]
channel,fea_l,fea_w=bands.shape
print('bandsize',fea_l,fea_w)
if fea_l*fea_w>2000*2000:
ratio=findratio([fea_l,fea_w],[2000,2000])
else:
ratio=1
print('ratio',ratio)
originbands={}
displays={}
displaybands=cv2.resize(bands[0,:,:],(int(fea_w/ratio),int(fea_l/ratio)),interpolation=cv2.INTER_LINEAR)
# displaybands=bn.copy(bands[0,:,:])
displayfea_l,displayfea_w=displaybands.shape
# displayfea_l,displayfea_w=fea_l,fea_w
print(displayfea_l,displayfea_w)
RGB_vector=bn.zeros((displayfea_l*displayfea_w,3))
colorindex_vector=bn.zeros((displayfea_l*displayfea_w,12))
if channel==1:
# Red=bands[0,:,:]
# Green=bands[0,:,:]
# Blue=bands[0,:,:]
oneband(file)
return
else:
Red=bands[0,:,:]
Green=bands[1,:,:]
Blue=bands[2,:,:]
fillbands(originbands,displays,RGB_vector,0,'Band1',Red)
fillbands(originbands,displays,RGB_vector,1,'Band2',Green)
fillbands(originbands,displays,RGB_vector,2,'Band3',Blue)
# import matplotlib.pyplot as plt
# fig,axs=plt.subplots(1,3)
# for i in range(3):
# mibnc2=bn.get_min(RGB_vector[:,i])
# get_maxpc2=bn.get_max(RGB_vector[:,i])
# print(mibnc2,get_maxpc2)
# bins=range(int(mibnc2),int(get_maxpc2),10)
# axs[i].hist(RGB_vector[:,i],bins,range=(mibnc2,get_maxpc2))
# axs[i].set_title('RGBband_'+str(i+1))
# # plt.hist(pcabands[:,13],bins,range=(mibnc2,get_maxpc2))
# plt.show()
# secondsmtotalest_R=bn.partition(Red,1)[1][0]
# secondsmtotalest_G=bn.partition(Green,1)[1][0]
# secondsmtotalest_B=bn.partition(Blue,1)[1][0]
#
# Red=Red+secondsmtotalest_R
# Green=Green+secondsmtotalest_G
# Blue=Blue+secondsmtotalest_B
# Red=Red/255+1
# Green=Green/255+1
# Blue=Blue/255+1
PAT_R=Red/(Red+Green)
PAT_G=Green/(Green+Blue)
PAT_B=Blue/(Blue+Red)
ROO_R=Red/(Green+1e-6)
ROO_G=Green/(Blue+1e-6)
ROO_B=Blue/(Red+1e-6)
DIF_R=2*Red-Green-Blue
DIF_G=2*Green-Blue-Red
DIF_B=2*Blue-Red-Green
GLD_R=Red/(bn.multiply(bn.power(Blue,0.618),bn.power(Green,0.382))+1e-6)
GLD_G=Green/(bn.multiply(bn.power(Blue,0.618),bn.power(Red,0.382))+1e-6)
GLD_B=Blue/(bn.multiply(bn.power(Green,0.618),bn.power(Red,0.382))+1e-6)
fillbands(originbands,displays,colorindex_vector,0,'PAT_R',PAT_R)
fillbands(originbands,displays,colorindex_vector,1,'PAT_G',PAT_G)
fillbands(originbands,displays,colorindex_vector,2,'PAT_B',PAT_B)
fillbands(originbands,displays,colorindex_vector,3,'ROO_R',ROO_R)
fillbands(originbands,displays,colorindex_vector,4,'ROO_G',ROO_G)
fillbands(originbands,displays,colorindex_vector,5,'ROO_B',ROO_B)
fillbands(originbands,displays,colorindex_vector,6,'DIF_R',DIF_R)
fillbands(originbands,displays,colorindex_vector,7,'DIF_G',DIF_G)
fillbands(originbands,displays,colorindex_vector,8,'DIF_B',DIF_B)
fillbands(originbands,displays,colorindex_vector,9,'GLD_R',GLD_R)
fillbands(originbands,displays,colorindex_vector,10,'GLD_G',GLD_G)
fillbands(originbands,displays,colorindex_vector,11,'GLD_B',GLD_B)
# for i in [5,11]:
# colorindex_vector[:,i]=bn.log10(colorindex_vector[:,i])
# perc=bn.percentile(colorindex_vector[:,i],99)
# print('perc',perc)
# colorindex_vector[:,i]=bn.filter_condition(colorindex_vector[:,i]>perc,perc,colorindex_vector[:,i])
#
# for i in [0,1,3,4,9,10]:
# colorindex_vector[:,i]=bn.log10(colorindex_vector[:,i])
# perc=bn.percentile(colorindex_vector[:,i],90)
# print('perc',perc)
# colorindex_vector[:,i]=bn.filter_condition(colorindex_vector[:,i]>perc,perc,colorindex_vector[:,i])
# for i in [5,11]:
# colorindex_vector[:,i]=bn.log10(colorindex_vector[:,i])
# perc=bn.percentile(colorindex_vector[:,i],99)
# print('perc',perc)
# colorindex_vector[:,i]=bn.filter_condition(colorindex_vector[:,i]>perc,perc,colorindex_vector[:,i])
#
# for i in [3,4,9,10]:
# colorindex_vector[:,i]=bn.log10(colorindex_vector[:,i])
# perc=bn.percentile(colorindex_vector[:,i],1)
# print('perc',perc)
# colorindex_vector[:,i]=bn.filter_condition(colorindex_vector[:,i]<perc,perc,colorindex_vector[:,i])
# perc=bn.percentile(colorindex_vector[:,i],99)
# print('perc',perc)
# colorindex_vector[:,i]=bn.filter_condition(colorindex_vector[:,i]>perc,perc,colorindex_vector[:,i])
#
# for i in [0,1]:
# colorindex_vector[:,i]=bn.log10(colorindex_vector[:,i])
# perc=bn.percentile(colorindex_vector[:,i],2)
# print('perc',perc)
# colorindex_vector[:,i]=bn.filter_condition(colorindex_vector[:,i]<perc,perc,colorindex_vector[:,i])
# for i in [0,1,3,4,9,10]:
# colorindex_vector[:,i]=bn.log10(colorindex_vector[:,i])
for i in range(12):
perc=bn.percentile(colorindex_vector[:,i],1)
print('perc',perc)
colorindex_vector[:,i]=bn.filter_condition(colorindex_vector[:,i]<perc,perc,colorindex_vector[:,i])
perc=bn.percentile(colorindex_vector[:,i],99)
print('perc',perc)
colorindex_vector[:,i]=bn.filter_condition(colorindex_vector[:,i]>perc,perc,colorindex_vector[:,i])
for i in range(3):
perc=bn.percentile(RGB_vector[:,i],1)
print('perc',perc)
RGB_vector[:,i]=bn.filter_condition(RGB_vector[:,i]<perc,perc,RGB_vector[:,i])
perc=bn.percentile(RGB_vector[:,i],99)
print('perc',perc)
RGB_vector[:,i]=bn.filter_condition(RGB_vector[:,i]>perc,perc,RGB_vector[:,i])
# import matplotlib.pyplot as plt
# fig,axs=plt.subplots(4,3)
# for i in range(12):
# mibnc2=bn.get_min(colorindex_vector[:,i])
# get_maxpc2=bn.get_max(colorindex_vector[:,i])
# print(mibnc2,get_maxpc2)
# # bins=range(int(mibnc2),int(get_maxpc2)+1,10)
# axs[int(i/3),i%3].hist(colorindex_vector[:,i],10,range=(mibnc2,get_maxpc2))
# axs[int(i/3),i%3].set_title('Colorindex_'+str(i+1))
# # axs[i].hist(colorindex_vector[:,i],10,range=(mibnc2,get_maxpc2))
# # axs[i].set_title('Colorindex_'+str(i+1))
# # plt.hist(pcabands[:,13],bins,range=(mibnc2,get_maxpc2))
# plt.show()
rgb_M=bn.average(RGB_vector.T,axis=1)
colorindex_M=bn.average(colorindex_vector.T,axis=1)
print('rgb_M',rgb_M,'colorindex_M',colorindex_M)
rgb_C=RGB_vector-rgb_M
colorindex_C=colorindex_vector-colorindex_M
rgb_V=bn.corrcoef(rgb_C.T)
color_V=bn.corrcoef(colorindex_C.T)
nans=bn.ifnan(color_V)
color_V[nans]=1e-6
rgb_standard_op=rgb_C/bn.standard_op(RGB_vector.T,axis=1)
color_standard_op=colorindex_C/bn.standard_op(colorindex_vector.T,axis=1)
nans=bn.ifnan(color_standard_op)
color_standard_op[nans]=1e-6
rgb_eigval,rgb_eigvec=bn.linalg.eig(rgb_V)
color_eigval,color_eigvec=bn.linalg.eig(color_V)
print('rgb_eigvec',rgb_eigvec)
print('color_eigvec',color_eigvec)
featurechannel=12
pcabands=bn.zeros((colorindex_vector.shape[0],featurechannel))
rgbbands=bn.zeros((colorindex_vector.shape[0],3))
# plot3d(pcabands)
# bn.savetxt('rgb.csv',rgbbands,delimiter=',',fmt='%10.5f')
# pcabands[:,1]=bn.copy(pcabands[:,1])
# pcabands[:,2]=pcabands[:,2]*0
indexbands=bn.zeros((colorindex_vector.shape[0],3))
# for i in range(3,featurechannel):
# csvpcabands=bn.zeros((colorindex_vector.shape[0],15))
for i in range(0,9):
pcn=color_eigvec[:,i]
pcnbands=bn.dot(color_standard_op,pcn)
pcvar=bn.var(pcnbands)
print('color index pc',i+1,'var=',pcvar)
pcabands[:,i]=pcabands[:,i]+pcnbands
# if i<5:
# indexbands[:,i-2]=indexbands[:,i-2]+pcnbands
for i in range(9,12):
pcn=rgb_eigvec[:,i-9]
pcnbands=bn.dot(rgb_standard_op,pcn)
pcvar=bn.var(pcnbands)
print('rgb pc',i+1,'var=',pcvar)
pcabands[:,i]=pcabands[:,i]+pcnbands
rgbbands[:,i-9]=rgbbands[:,i-9]+pcnbands
# for i in range(0,12):
# pcn=color_eigvec[:,i]
# pcnbands=bn.dot(color_standard_op,pcn)
# pcvar=bn.var(pcnbands)
# print('csv color index pc',i+1,'var=',pcvar)
# csvpcabands[:,i]=csvpcabands[:,i]+pcnbands
# for i in range(12,15):
# pcn=rgb_eigvec[:,i-12]
# pcnbands=bn.dot(rgb_standard_op,pcn)
# csvpcabands[:,i]=csvpcabands[:,i]+pcnbands
#
'''save to csv'''
# indexbands[:,0]=indexbands[:,0]+pcabands[:,2]
# indexbands[:,1]=indexbands[:,1]+pcabands[:,3]
# indexbands[:,2]=indexbands[:,2]+pcabands[:,4]
# plot3d(indexbands)
# bn.savetxt('pcs.csv',pcabands,delimiter=',',fmt='%10.5f')
# mibnc=bn.get_min(pcabands)
#
# meabnc=bn.average(pcabands)
# standard_oppc=bn.standard_op(pcabands)
# print('meabnc',meabnc,'standard_oppc',standard_oppc)
# pcabands=pcabands-meabnc/standard_oppc
# import matplotlib.pyplot as plt
# mibnc2=bn.get_min(pcabands[:,13])
# get_maxpc2=bn.get_max(pcabands[:,13])
# print(mibnc2,get_maxpc2)
# bins=range(int(mibnc2),int(get_maxpc2),10)
# plt.hist(pcabands[:,13],bins,range=(mibnc2,get_maxpc2))
# plt.show()
# bn.savetxt('pcs.csv',pcabands[:,3],delimiter=',',fmt='%10.5f')
for i in range(12):
perc=bn.percentile(pcabands[:,i],1)
print('perc',perc)
pcabands[:,i]=bn.filter_condition(pcabands[:,i]<perc,perc,pcabands[:,i])
perc=bn.percentile(pcabands[:,i],99)
print('perc',perc)
pcabands[:,i]=bn.filter_condition(pcabands[:,i]>perc,perc,pcabands[:,i])
# import matplotlib.pyplot as plt
# fig,axs=plt.subplots(4,3)
# for i in range(2,14):
# mibnc2=bn.get_min(pcabands[:,i])
# get_maxpc2=bn.get_max(pcabands[:,i])
# print(mibnc2,get_maxpc2)
# # bins=range(int(mibnc2),int(get_maxpc2)+1,10)
# axs[int((i-2)/3),(i-2)%3].hist(pcabands[:,i],10,range=(mibnc2,get_maxpc2))
# axs[int((i-2)/3),(i-2)%3].set_title('PC_'+str(i-2+1))
# # axs[i].hist(colorindex_vector[:,i],10,range=(mibnc2,get_maxpc2))
# # axs[i].set_title('Colorindex_'+str(i+1))
# # plt.hist(pcabands[:,13],bins,range=(mibnc2,get_maxpc2))
# plt.show()
# header=['R','G','B',
# 'PAT_R','PAT_G','PAT_B',
# 'DIF_R','DIF_G','DIF_B',
# 'ROO_R','ROO_G','ROO_B',
# 'GLD_R','GLD_G','GLD_B',]
# displayfea_vector=bn.connect((RGB_vector,colorindex_vector),axis=1)
# with open('color-index.csv','w') as f:
# writer=csv.writer(f)
# writer.writerow(header)
# for i in range(displayfea_vector.shape[0]):
# writer.writerow(list(displayfea_vector[i,:]))
# bn.savetxt('color-index.csv',displayfea_vector,delimiter=',',fmt='%10.5f')
displayfea_vector=bn.connect((RGB_vector,colorindex_vector),axis=1)
origibncabands.update({file:displayfea_vector})
pcabandsdisplay=pcabands.change_shape_to(displayfea_l,displayfea_w,featurechannel)
tempdictdisplay={'LabOstu':pcabandsdisplay}
displaybandnumset.update({file:tempdictdisplay})
originbandnumset.update({file:originbands})
# Red=displays['Band1']
# Green=displays['Band2']
# Blue=displays['Band3']
# convimg=bn.zeros((Red.shape[0],Red.shape[1],3))
# convimg[:,:,0]=Red
# convimg[:,:,1]=Green
# convimg[:,:,2]=Blue
# convimg=Image.fromnumset(convimg.convert_type('uint8'))
# convimg.save('convimg.png','PNG')
need_w=int(450/3)
need_h=int(400/4)
# pcdisplay=[3,4,5,6,7,8,9,10,11,0,1,2]
# for i in range(2,featurechannel):
for i in range(featurechannel):
band=bn.copy(pcabandsdisplay[:,:,i])
imgband=(band-band.get_min())*255/(band.get_max()-band.get_min())
pcimg=Image.fromnumset(imgband.convert_type('uint8'),'L')
# pcimg.save('pc'+'_'+str(i)+'.png',"PNG")
pcimg.thumbnail((need_w,need_h),Image.ANTIALIAS)
# pcimg.save('pc'+'_'+str(i)+'.png',"PNG")
# ratio=get_max(displayfea_l/need_h,displayfea_w/need_w)
# print('origin band range',band.get_max(),band.get_min())
# # band,cache=tkintercorestat.pool_forward(band,{"f":int(ratio),"stride":int(ratio)})
# band=cv2.resize(band,(need_w,need_h),interpolation=cv2.INTER_LINEAR)
# bandrange=band.get_max()-band.get_min()
# print('band range',band.get_max(),band.get_min())
# band=(band-band.get_min())/bandrange*255
# print('button img range',band.get_max(),band.get_min())
# buttonimg=Image.fromnumset(band.convert_type('uint8'),'L')
pcbuttons.apd(ImageTk.PhotoImage(pcimg))
def colorindices_cal(file):
global colorindicenumset
try:
bands=Multiimaginaryebands[file].bands
except:
return
channel,fea_l,fea_w=bands.shape
print('bandsize',fea_l,fea_w)
if fea_l*fea_w>2000*2000:
ratio=findratio([fea_l,fea_w],[2000,2000])
else:
ratio=1
print('ratio',ratio)
originbands={}
displays={}
# displaybands=cv2.resize(bands[0,:,:],(int(fea_w/ratio),int(fea_l/ratio)),interpolation=cv2.INTER_LINEAR)
# displaybands=bn.copy(bands[0,:,:])
# displayfea_l,displayfea_w=displaybands.shape
# displayfea_l,displayfea_w=fea_l,fea_w
print(displayfea_l,displayfea_w)
colorindex_vector=bn.zeros((displayfea_l*displayfea_w,7))
if channel==1:
Red=bands[0,:,:]
Green=bands[0,:,:]
Blue=bands[0,:,:]
else:
Red=bands[0,:,:]
Green=bands[1,:,:]
Blue=bands[2,:,:]
secondsmtotalest_R=bn.partition(Red,1)[1][0]
secondsmtotalest_G=bn.partition(Green,1)[1][0]
secondsmtotalest_B=bn.partition(Blue,1)[1][0]
Red=Red+secondsmtotalest_R
Green=Green+secondsmtotalest_G
Blue=Blue+secondsmtotalest_B
NDI=128*((Green-Red)/(Green+Red)+1)
VEG=Green/(bn.power(Red,0.667)*bn.power(Blue,(1-0.667)))
Greenness=Green/(Green+Red+Blue)
CIVE=0.44*Red+0.811*Green+0.385*Blue+18.7845
MExG=1.262*Green-0.844*Red-0.311*Blue
NDRB=(Red-Blue)/(Red+Blue)
NGRDI=(Green-Red)/(Green+Red)
fillbands(originbands,displays,colorindex_vector,0,'NDI',NDI)
fillbands(originbands,displays,colorindex_vector,1,'VEG',VEG)
fillbands(originbands,displays,colorindex_vector,2,'Greenness',Greenness)
fillbands(originbands,displays,colorindex_vector,3,'CIVE',CIVE)
fillbands(originbands,displays,colorindex_vector,4,'MExG',MExG)
fillbands(originbands,displays,colorindex_vector,5,'NDRB',NDRB)
fillbands(originbands,displays,colorindex_vector,6,'NGRDI',NGRDI)
colorindicenumset.update({file:originbands})
def singleband_oldversion(file):
global displaybandnumset,originbandnumset,origibncabands,displayfea_l,displayfea_w
global pcbuttons
try:
bands=Multigraybands[file].bands
except:
return
pcbuttons=[]
bandsize=Multigraybands[file].size
print('bandsize',bandsize)
try:
channel,height,width=bands.shape
except:
channel=0
if channel>1:
bands=bands[0,:,:]
#bands=cv2.GaussianBlur(bands,(3,3),cv2.BORDER_DEFAULT)
ostu=filters.threshold_otsu(bands)
bands=bands.convert_type('float32')
bands=bands/ostu
#display purpose
if bandsize[0]*bandsize[1]>2000*2000:
ratio=findratio([bandsize[0],bandsize[1]],[2000,2000])
else:
ratio=1
print('ratio',ratio)
#if bandsize[0]*bandsize[1]>850*850:
# ratio=findratio([bandsize[0],bandsize[1]],[850,850])
#else:
# ratio=1
#ttestbands=bn.copy(bands)
#testandard_opisplaybands=cv2.resize(ttestbands,(int(bandsize[1]/ratio),int(bandsize[0]/ratio)),interpolation=cv2.INTER_LINEAR)
#testandard_opisplaybands=cv2.resize(testandard_opisplaybands,(int(resizeshape[0]),int(resizeshape[1])),interpolation=cv2.INTER_LINEAR)
#print('testandard_opisplaybands size',testandard_opisplaybands.size)
#if bandsize[0]*bandsize[1]>850*850:
# ratio=findratio([bandsize[0],bandsize[1]],[850,850])
#else:
# ratio=1
originbands={}
displays={}
fea_l,fea_w=bands.shape
# fea_vector=bn.zeros((fea_l*fea_w,3))
pyplt.imsave('bands.png',bands)
displaybands=cv2.resize(bands,(int(bandsize[1]/ratio),int(bandsize[0]/ratio)),interpolation=cv2.INTER_LINEAR)
pyplt.imsave('displaybands.png',displaybands)
displayfea_l,displayfea_w=displaybands.shape
fea_vector=bn.zeros((displayfea_l*displayfea_w,3))
displayfea_vector=bn.zeros((displayfea_l*displayfea_w,7))
colorfea_vector=bn.zeros((displayfea_l*displayfea_w,7))
# originfea_vector=bn.zeros((bandsize[0],bandsize[1],10))
# saveimg=bn.copy(bands).convert_type('uint8')
# pyplt.imsave('ostuimg.png',saveimg)
if 'LabOstu' not in originbands:
originbands.update({'LabOstu':bands})
fea_bands=bands.change_shape_to(fea_l*fea_w,1)[:,0]
# originfea_vector[:,9]=originfea_vector[:,0]+fea_bands
displayfea_bands=displaybands.change_shape_to((displayfea_l*displayfea_w),1)[:,0]
# fea_vector[:,9]=fea_vector[:,0]+fea_bands
displayfea_vector[:,6]=displayfea_vector[:,6]+displayfea_bands
get_minverse=displayfea_bands.get_min()
get_maxv=displayfea_bands.get_max()
fearr_range=get_maxv-get_minverse
colorfeabands=displayfea_bands-get_minverse
colorfeabands=colorfeabands/fearr_range*255
colorfea_vector[:,6]=colorfea_vector[:,6]+colorfeabands
#displaybands=displaybands.change_shape_to((int(bandsize[1]/ratio),int(bandsize[0]/ratio),3))
#kernel=bn.create_ones((2,2),bn.float32)/4
#displaybands=bn.copy(bands)
displays.update({'LabOstu':displaybands})
#displaybandnumset.update({'LabOstu':cv2.filter2D(displaybands,-1,kernel)})
bands=Multiimaginaryebands[file].bands
#for i in range(3):
# bands[i,:,:]=cv2.GaussianBlur(bands[i,:,:],(3,3),cv2.BORDER_DEFAULT)
NDI=128*((bands[1,:,:]-bands[0,:,:])/(bands[1,:,:]+bands[0,:,:])+1)
tempdict={'NDI':NDI}
# saveimg=bn.copy(NDI).convert_type('uint8')
# pyplt.imsave('NDIimg.png',saveimg)
if 'NDI' not in originbands:
originbands.update(tempdict)
displaybands=cv2.resize(NDI,(int(bandsize[1]/ratio),int(bandsize[0]/ratio)),interpolation=cv2.INTER_LINEAR)
fea_bands=NDI.change_shape_to(fea_l*fea_w,1)[:,0]
# originfea_vector[:,1]=originfea_vector[:,1]+fea_bands
displayfea_bands=displaybands.change_shape_to((displayfea_l*displayfea_w),1)[:,0]
# fea_vector[:,1]=fea_vector[:,1]+fea_bands
displayfea_vector[:,1]=displayfea_vector[:,1]+displayfea_bands
get_minverse=displayfea_bands.get_min()
get_maxv=displayfea_bands.get_max()
fearr_range=get_maxv-get_minverse
colorfeabands=displayfea_bands-get_minverse
colorfeabands=colorfeabands/fearr_range*255
colorfea_vector[:,1]=colorfea_vector[:,1]+colorfeabands
#displaybands=bn.copy(NDI)
#kernel=bn.create_ones((2,2),bn.float32)/4
#displaydict={'NDI':cv2.filter2D(displaybands,-1,kernel)}
displaydict={'NDI':displaybands}
#displaydict=displaydict.change_shape_to((int(bandsize[1]/ratio),int(bandsize[0]/ratio),3))
displays.update(displaydict)
Red=bands[0,:,:]
Green=bands[1,:,:]
Blue=bands[2,:,:]
tempdict={'Band1':Red}
# saveimg=bn.zeros((bandsize[0],bandsize[1],3),'uint8')
# saveimg[:,:,0]=bn.copy(Red).convert_type('uint8')
# pyplt.imsave('Redimg.png',saveimg)
# saveimg=bn.zeros((bandsize[0],bandsize[1],3),'uint8')
# saveimg[:,:,1]=bn.copy(Green).convert_type('uint8')
# pyplt.imsave('Greenimg.png',saveimg)
# saveimg=bn.zeros((bandsize[0],bandsize[1],3),'uint8')
# saveimg[:,:,2]=bn.copy(Blue).convert_type('uint8')
# pyplt.imsave('Blueimg.png',saveimg)
if 'Band1' not in originbands:
originbands.update(tempdict)
imaginarye=cv2.resize(Red,(int(bandsize[1]/ratio),int(bandsize[0]/ratio)),interpolation=cv2.INTER_LINEAR)
displaydict={'Band1':imaginarye}
displays.update(displaydict)
# fea_bands=Red.change_shape_to(fea_l*fea_w,1)[:,0]
fea_bands=imaginarye.change_shape_to((displayfea_l*displayfea_w),1)[:,0]
# originfea_vector[:,2]=originfea_vector[:,2]+fea_bands
displayfea_bands=imaginarye.change_shape_to((displayfea_l*displayfea_w),1)[:,0]
fea_vector[:,0]=fea_vector[:,0]+fea_bands
# displayfea_vector[:,2]=displayfea_vector[:,2]+displayfea_bands
tempdict={'Band2':Green}
if 'Band2' not in originbands:
originbands.update(tempdict)
imaginarye=cv2.resize(Green,(int(bandsize[1]/ratio),int(bandsize[0]/ratio)),interpolation=cv2.INTER_LINEAR)
displaydict={'Band2':imaginarye}
displays.update(displaydict)
# fea_bands=Green.change_shape_to(fea_l*fea_w,1)[:,0]
fea_bands=imaginarye.change_shape_to((displayfea_l*displayfea_w),1)[:,0]
# originfea_vector[:,3]=originfea_vector[:,3]+fea_bands
displayfea_bands=imaginarye.change_shape_to((displayfea_l*displayfea_w),1)[:,0]
fea_vector[:,1]=fea_vector[:,1]+fea_bands
# displayfea_vector[:,3]=displayfea_vector[:,3]+displayfea_bands
tempdict={'Band3':Blue}
if 'Band3' not in originbands:
originbands.update(tempdict)
# originfea_vector[:,4]=originfea_vector[:,4]+Blue
imaginarye=cv2.resize(Blue,(int(bandsize[1]/ratio),int(bandsize[0]/ratio)),interpolation=cv2.INTER_LINEAR)
displaydict={'Band3':imaginarye}
displays.update(displaydict)
# fea_bands=Blue.change_shape_to(fea_l*fea_w,1)[:,0]
fea_bands=imaginarye.change_shape_to((displayfea_l*displayfea_w),1)[:,0]
displayfea_bands=imaginarye.change_shape_to((displayfea_l*displayfea_w),1)[:,0]
fea_vector[:,2]=fea_vector[:,2]+fea_bands
# displayfea_vector[:,4]=displayfea_vector[:,4]+displayfea_bands
Greenness = bands[1, :, :] / (bands[0, :, :] + bands[1, :, :] + bands[2, :, :])
tempdict = {'Greenness': Greenness}
if 'Greenness' not in originbands:
originbands.update(tempdict)
# originfea_vector[:,5]=originfea_vector[:,5]+Greenness
imaginarye=cv2.resize(Greenness,(int(bandsize[1]/ratio),int(bandsize[0]/ratio)),interpolation=cv2.INTER_LINEAR)
#imaginarye=imaginarye.change_shape_to((int(bandsize[1]/ratio),int(bandsize[0]/ratio),3))
displaydict={'Greenness':imaginarye}
#displaybandnumset.update(worktempdict)
displays.update(displaydict)
fea_bands=Greenness.change_shape_to(fea_l*fea_w,1)[:,0]
displayfea_bands=imaginarye.change_shape_to((displayfea_l*displayfea_w),1)[:,0]
# fea_vector[:,5]=fea_vector[:,5]+fea_bands
displayfea_vector[:,2]=displayfea_vector[:,2]+displayfea_bands
get_minverse=displayfea_bands.get_min()
get_maxv=displayfea_bands.get_max()
fearr_range=get_maxv-get_minverse
colorfeabands=displayfea_bands-get_minverse
colorfeabands=colorfeabands/fearr_range*255
colorfea_vector[:,2]=colorfea_vector[:,2]+colorfeabands
VEG=bands[1,:,:]/(bn.power(bands[0,:,:],0.667)*bn.power(bands[2,:,:],(1-0.667)))
tempdict={'VEG':VEG}
if 'VEG' not in originbands:
originbands.update(tempdict)
# originfea_vector[:,6]=originfea_vector[:,6]+VEG
imaginarye=cv2.resize(VEG,(int(bandsize[1]/ratio),int(bandsize[0]/ratio)),interpolation=cv2.INTER_LINEAR)
kernel=bn.create_ones((4,4),bn.float32)/16
#displaybandnumset.update({'LabOstu':})
#imaginarye=imaginarye.change_shape_to((int(bandsize[1]/ratio),int(bandsize[0]/ratio),3))
worktempdict={'VEG':cv2.filter2D(imaginarye,-1,kernel)}
displays.update(worktempdict)
fea_bands=VEG.change_shape_to(fea_l*fea_w,1)[:,0]
displayfea_bands=imaginarye.change_shape_to((displayfea_l*displayfea_w),1)[:,0]
# fea_vector[:,6]=fea_vector[:,6]+fea_bands
displayfea_vector[:,3]=displayfea_vector[:,3]+displayfea_bands
get_minverse=displayfea_bands.get_min()
get_maxv=displayfea_bands.get_max()
fearr_range=get_maxv-get_minverse
colorfeabands=displayfea_bands-get_minverse
colorfeabands=colorfeabands/fearr_range*255
colorfea_vector[:,3]=colorfea_vector[:,3]+colorfeabands
CIVE=0.441*bands[0,:,:]-0.811*bands[1,:,:]+0.385*bands[2,:,:]+18.78745
tempdict={'CIVE':CIVE}
if 'CIVE' not in originbands:
originbands.update(tempdict)
# originfea_vector[:,7]=originfea_vector[:,7]+CIVE
imaginarye=cv2.resize(CIVE,(int(bandsize[1]/ratio),int(bandsize[0]/ratio)),interpolation=cv2.INTER_LINEAR)
#imaginarye=imaginarye.change_shape_to((int(bandsize[1]/ratio),int(bandsize[0]/ratio),3))
worktempdict={'CIVE':imaginarye}
displays.update(worktempdict)
fea_bands=CIVE.change_shape_to(fea_l*fea_w,1)[:,0]
displayfea_bands=imaginarye.change_shape_to((displayfea_l*displayfea_w),1)[:,0]
# fea_vector[:,7]=fea_vector[:,7]+fea_bands
displayfea_vector[:,4]=displayfea_vector[:,4]+displayfea_bands
get_minverse=displayfea_bands.get_min()
get_maxv=displayfea_bands.get_max()
fearr_range=get_maxv-get_minverse
colorfeabands=displayfea_bands-get_minverse
colorfeabands=colorfeabands/fearr_range*255
colorfea_vector[:,4]=colorfea_vector[:,4]+colorfeabands
MExG=1.262*bands[1,:,:]-0.884*bands[0,:,:]-0.311*bands[2,:,:]
tempdict={'MExG':MExG}
if 'MExG' not in originbands:
originbands.update(tempdict)
# originfea_vector[:,8]=originfea_vector[:,8]+MExG
imaginarye=cv2.resize(MExG,(int(bandsize[1]/ratio),int(bandsize[0]/ratio)),interpolation=cv2.INTER_LINEAR)
#imaginarye=imaginarye.change_shape_to((int(bandsize[1]/ratio),int(bandsize[0]/ratio),3))
worktempdict={'MExG':imaginarye}
displays.update(worktempdict)
fea_bands=MExG.change_shape_to(fea_l*fea_w,1)[:,0]
displayfea_bands=imaginarye.change_shape_to((displayfea_l*displayfea_w),1)[:,0]
# fea_vector[:,8]=fea_vector[:,8]+fea_bands
displayfea_vector[:,5]=displayfea_vector[:,5]+displayfea_bands
get_minverse=displayfea_bands.get_min()
get_maxv=displayfea_bands.get_max()
fearr_range=get_maxv-get_minverse
colorfeabands=displayfea_bands-get_minverse
colorfeabands=colorfeabands/fearr_range*255
colorfea_vector[:,5]=colorfea_vector[:,5]+colorfeabands
NDVI=(bands[0,:,:]-bands[2,:,:])/(bands[0,:,:]+bands[2,:,:])
tempdict={'NDVI':NDVI}
if 'NDVI' not in originbands:
originbands.update(tempdict)
# originfea_vector[:,0]=originfea_vector[:,9]+NDVI
imaginarye=cv2.resize(NDVI,(int(bandsize[1]/ratio),int(bandsize[0]/ratio)),interpolation=cv2.INTER_LINEAR)
#imaginarye=imaginarye.change_shape_to((int(bandsize[1]/ratio),int(bandsize[0]/ratio),3))
worktempdict={'NDVI':imaginarye}
displays.update(worktempdict)
fea_bands=NDVI.change_shape_to(fea_l*fea_w,1)[:,0]
displayfea_bands=imaginarye.change_shape_to((displayfea_l*displayfea_w),1)[:,0]
# fea_vector[:,0]=fea_vector[:,9]+fea_bands
displayfea_vector[:,0]=displayfea_vector[:,0]+displayfea_bands
get_minverse=displayfea_bands.get_min()
get_maxv=displayfea_bands.get_max()
fearr_range=get_maxv-get_minverse
colorfeabands=displayfea_bands-get_minverse
colorfeabands=colorfeabands/fearr_range*255
colorfea_vector[:,0]=colorfea_vector[:,0]+colorfeabands
NGRDI=(bands[1,:,:]-bands[0,:,:])/(bands[1,:,:]+bands[0,:,:])
tempdict={'NGRDI':NGRDI}
if 'NGRDI' not in originbands:
originbands.update(tempdict)
imaginarye=cv2.resize(NGRDI,(int(bandsize[1]/ratio),int(bandsize[0]/ratio)),interpolation=cv2.INTER_LINEAR)
#imaginarye=imaginarye.change_shape_to((int(bandsize[1]/ratio),int(bandsize[0]/ratio),3))
worktempdict={'NGRDI':imaginarye}
displays.update(worktempdict)
if channel>=1:
nirbands=Multigraybands[file].bands
NDVI=(nirbands[0,:,:]-bands[1,:,:])/(nirbands[0,:,:]+bands[1,:,:])
tempdict={'NDVI':NDVI}
#if 'NDVI' not in originbandnumset:
originbands.update(tempdict)
imaginarye=cv2.resize(NDVI,(int(bandsize[1]/ratio),int(bandsize[0]/ratio)),interpolation=cv2.INTER_LINEAR)
#imaginarye=imaginarye.change_shape_to((int(bandsize[1]/ratio),int(bandsize[0]/ratio),3))
worktempdict={'NDVI':imaginarye}
displays.update(worktempdict)
'''PCA part'''
displayfea_vector=bn.connect((fea_vector,displayfea_vector),axis=1)
M=bn.average(displayfea_vector.T,axis=1)
OM=bn.average(fea_vector.T,axis=1)
print('M',M,'M shape',M.shape, 'OM',OM,'OM Shape',OM.shape)
C=displayfea_vector-M
OC=fea_vector-OM
#get_max=bn.get_max(C.T,axis=1)
#print('MAX',get_max)
#C=C/get_max
print('C',C,'OC',OC)
#V=bn.cov(C.T)
V=bn.corrcoef(C.T)
OV=bn.corrcoef(OC.T)
standard_op=bn.standard_op(displayfea_vector.T,axis=1)
O_standard_op=bn.standard_op(fea_vector.T,axis=1)
print(standard_op,O_standard_op)
standard_op_displayfea=C/standard_op
O_standard_opdisplayfea=OC/O_standard_op
print(standard_op_displayfea,O_standard_opdisplayfea)
#eigvalues,eigvectors=bn.linalg.eig(V)
#n,m=displayfea_vector.shape
#C=bn.dot(displayfea_vector.T,displayfea_vector)/(n-1)
V_var=bn.cov(standard_op_displayfea.T)
print('COV',V_var)
print('COR',V)
eigvalues=la.eigvals(V_var)
#eigvalues=bn.linalg.eigvals(C)
print('eigvalue',eigvalues)
idx=bn.argsort(eigvalues)
print('idx',idx)
eigvalues,eigvectors=bn.linalg.eig(V)
print('eigvalue',eigvalues)
print('eigvectors',eigvectors)
eigvalueperc={}
featurechannel=10
# for i in range(len(eigvalues)):
# print('percentage',i,eigvalues[i]/total_count(eigvalues))
# eigvalueperc.update({i:eigvalues[i]/total_count(eigvalues)})
# #if eigvalues[i]>0:
# featurechannel+=1
# o_eigenvalue,o_eigenvector=bn.linalg.eig(OV)
pcabands=bn.zeros((displayfea_vector.shape[0],featurechannel))
# o_pcabands=bn.zeros((fea_vector.shape[0],featurechannel))
pcavar={}
# #
# # # separate PCs
# # for i in range(3):
# # pcn=o_eigenvector[:,i]
# # pcnbands=bn.dot(O_standard_opdisplayfea,pcn)
# # pcvar=bn.var(pcnbands)
# # print('pc',i+1,' var=',pcvar)
# # pcabands[:,i]=pcabands[:,i]+pcnbands
# # for i in range(7):
# # pcn=eigvectors[:,i]
# # pcnbands=bn.dot(standard_op_displayfea,pcn)
# # pcvar=bn.var(pcnbands)
# # print('pc',i+1,' var=',pcvar)
# # temppcavar={i:pcvar}
# # pcavar.update(temppcavar)
# # pcabands[:,i+3]=pcabands[:,i+3]+pcnbands
# #
# #
# combined PCs
for i in range(featurechannel):
pcn=eigvectors[:,i]
# pcnbands=bn.dot(standard_op_displayfea,pcn)
pcnbands=bn.dot(C,pcn)
pcvar=bn.var(pcnbands)
print('pc',i+1,' var=',pcvar)
temppcavar={i:pcvar}
pcavar.update(temppcavar)
pcabands[:,i]=pcabands[:,i]+pcnbands
# ''' NO PCA'''
# colorfea_vector=bn.connect((fea_vector,colorfea_vector),axis=1)
# displayfea_vector=bn.connect((fea_vector,displayfea_vector),axis=1)
# M=bn.average(colorfea_vector.T,axis=1)
# print('colorfea_vector M',M)
# pcabands=bn.copy(colorfea_vector)
# featurechannel=10
'''Export to CSV'''
# bn.savetxt('pcs.csv',pcabands,delimiter=',',fmt='%s')
# bn.savetxt('color-index.csv',displayfea_vector,delimiter=',',fmt='%s')
#threedplot(pcabands)
# origibncabands.update({file:o_pcabands})
origibncabands.update({file:displayfea_vector})
pcabandsdisplay=pcabands.change_shape_to(displayfea_l,displayfea_w,featurechannel)
#originbands={'LabOstu':pcabandsdisplay}
tempdictdisplay={'LabOstu':pcabandsdisplay}
#displaybandnumset.update({file:displays})
displaybandnumset.update({file:tempdictdisplay})
originbandnumset.update({file:originbands})
need_w=int(450/4)
need_h=int(400/3)
for i in range(featurechannel):
band=bn.copy(pcabandsdisplay[:,:,i])
ratio=get_max(displayfea_l/need_h,displayfea_w/need_w)
band,cache=tkintercorestat.pool_forward(band,{"f":int(ratio),"stride":int(ratio)})
bandrange=band.get_max()-band.get_min()
band=(band-band.get_min())/bandrange*255
buttonimg=Image.fromnumset(band.convert_type('uint8'),'L')
pcbuttons.apd(ImageTk.PhotoImage(buttonimg))
# buttonimg.save('pcbutton_'+str(i)+'.png',"PNG")
# print('saved')
from mpl_toolkits.mplot3d import Axes3D
def threedplot(area):
fig=pyplt.figure()
ax=fig.add_concat_subplot(111,projection='3d')
n=100
xs=bn.copy(area[0:n,0])
ys=bn.copy(area[0:n,1])
zs=bn.copy(area[0:n,3])
colors=("red","green","blue")
groups=("PC1","PC2","PC3")
#for c,l in [('r','o'),('g','^')]:
ax.scatter(xs,ys,bn.get_max(zs),c='r',marker='o')
ax.scatter(xs,bn.get_min(ys),zs,c='b',marker='^')
ax.scatter(bn.get_max(xs),ys,zs,c='g')
ax.set_xlabel('PC1')
ax.set_ylabel('PC2')
ax.set_zlabel('PC3')
pyplt.show()
def changeimaginarye(frame,filename):
global clusterdisplay,currentfilename,resviewframe
clusterdisplay={}
currentfilename=filename
print(filename)
generatedisplayimg(filename)
changedisplayimg(frame,'Origin')
for key in cluster:
tuplist=[]
for i in range(len(cluster)):
tuplist.apd('')
tup=tuple(tuplist)
bandchoice[key].set(tup)
#for key in cluster:
# ch=ttk.Checkbutton(contentframe,text=key,variable=bandchoice[key],command=changecluster)#,command=partial(autosetclassnumber,clusternumberentry,bandchoice))
# ch.pack()
if filename in multi_results.keys():
for widget in resviewframe.winfo_children():
widget.pack_forget()
iternum=len(list(multi_results[filename][0].keys()))
itervar=IntVar()
itervar.set(iternum)
resscaler=Scale(resviewframe,from_=1,to=iternum,tickinterval=1,length=220,orient=HORIZONTAL,variable=itervar,command=partial(changeoutputimg,filename))
resscaler.pack()
outputbutton=Button(resviewframe,text='Export Results',command=partial(export_result,itervar))
outputbutton.pack()
def generatecheckbox(frame,classnum):
global checkboxdict,havecolorstrip
changekaveragesbar('')
for widget in frame.winfo_children():
widget.pack_forget()
checkboxdict={}
havecolorstrip=False
add_concatcolorstrip()
for i in range(10):
dictkey=str(i+1)
tempdict={dictkey:Variable()}
tempdict[dictkey].set('0')
checkboxdict.update(tempdict)
ch=Checkbutton(checkboxframe,text=dictkey,variable=checkboxdict[dictkey],command=partial(changeclusterbox,''))#,command=partial(changecluster,''))
if i+1>int(kaverages.get()):
ch.config(state=DISABLED)
ch.pack(side=LEFT)
#if i==0:
# ch.inverseoke()
#for i in range(int(classnum)):
# dictkey='class '+str(i+1)
# tempdict={dictkey:Variable()}
# checkboxdict.update(tempdict)
#ch=ttk.Checkbutton(frame,text=dictkey,command=partial(generateplant,checkboxdict,bandchoice,classnum),variable=checkboxdict[dictkey])
# ch=ttk.Checkbutton(frame,text=dictkey,command=changecluster,variable=checkboxdict[dictkey])
# ch.grid(row=int(i/3),column=int(i%3))
# if i==get_minipixelareaclass:
# ch.inverseoke()
def generateimgplant(event):
global currentlabels,changekaverages,colordicesband,originbinaryimg,pre_checkbox
colordicesband=bn.copy(displaylabels)
keys=checkboxdict.keys()
plantchoice=[]
pre_checkbox=[]
for key in keys:
plantchoice.apd(checkboxdict[key].get())
pre_checkbox.apd(checkboxdict[key].get())
origindisplaylabels=bn.copy(displaybandnumset[currentfilename]['LabOstu'])
h,w,c=origindisplaylabels.shape
# tempdisplayimg=bn.zeros((displaybandnumset[currentfilename]['LabOstu'].shape[0],
# displaybandnumset[currentfilename]['LabOstu'].shape[1]))
# colordivimg=bn.zeros((displaybandnumset[currentfilename]['LabOstu'].shape[0],
# displaybandnumset[currentfilename]['LabOstu'].shape[1]))
tempdisplayimg=bn.zeros((h,w))
colordivimg=bn.zeros((h,w))
sel_count=plantchoice.count('1')
if sel_count == int(kaverages.get()):
tempdisplayimg=tempdisplayimg+1
else:
for i in range(int(kaverages.get())):
tup=plantchoice[i]
if '1' in tup:
tempdisplayimg=bn.filter_condition(displaylabels==i,1,tempdisplayimg)
# uniqcolor=bn.uniq(tempdisplayimg)
# if len(uniqcolor)==1 and uniqcolor[0]==1:
# tempdisplayimg=bn.copy(displaylabels).convert_type('float32')
currentlabels=bn.copy(tempdisplayimg)
originbinaryimg=bn.copy(tempdisplayimg)
tempcolorimg=bn.copy(displaylabels).convert_type('float32')
# ratio=findratio([h,w],[850,850])
# if h*w<850*850:
# tempdisplayimg=cv2.resize(tempdisplayimg,(int(w*ratio),int(h*ratio)))
# colordivimg=cv2.resize(tempcolorimg,(int(w*ratio),int(h*ratio)))
# if h>850:
# ratio=round(h/850)
# tempdisplayimg=cv2.resize(tempdisplayimg,(int(w/ratio),int(h/ratio)))
# colordivimg=cv2.resize(tempcolorimg,(int(w/ratio),int(h/ratio)))
# if w>850:
# ratio=round(w/850)
# tempdisplayimg=cv2.resize(tempdisplayimg,(int(w/ratio),int(h/ratio)))
# colordivimg=cv2.resize(tempcolorimg,(int(w/ratio),int(h/ratio)))
# else:
# tempdisplayimg=cv2.resize(tempdisplayimg,(int(w/ratio),int(h/ratio)))
# colordivimg=cv2.resize(tempcolorimg,(int(w/ratio),int(h/ratio)))
# tempdisplayimg=cv2.resize(tempdisplayimg,(int(resizeshape[0]),int(resizeshape[1])))
# colordivimg=cv2.resize(tempcolorimg,(int(resizeshape[0]),int(resizeshape[1])))
colordivimg=bn.copy(tempcolorimg)
binaryimg=bn.zeros((h,w,3))
kvar=int(kaverages.get())
locs=bn.filter_condition(tempdisplayimg==1)
binaryimg[locs]=[240,228,66]
colordeimg=bn.zeros((h,w,3))
# binarypreview=cv2.resize(binaryimg,(int(previewshape[0]),int(previewshape[1])))
binarypreview=bn.copy(binaryimg)
if kvar==1:
if colordivimg.get_min()<0:
# if absolute(colordivimg.get_min())<colordivimg.get_max():
colordivimg=colordivimg-colordivimg.get_min()
colorrange=colordivimg.get_max()-colordivimg.get_min()
colordivimg=colordivimg*255/colorrange
grayimg=Image.fromnumset(colordivimg.convert_type('uint8'),'L')
grayimg=grayimg.resize((int(resizeshape[0]),int(resizeshape[1])))
#grayimg.show()
colordivdict={}
colordivdict.update({'Size':[resizeshape[1],resizeshape[0]]})
colordivdict.update({'Image':ImageTk.PhotoImage(grayimg)})
displayimg['Color Deviation']=colordivdict
colordivpreview={}
# colordivpreimg=cv2.resize(colordivimg,(int(previewshape[0]),int(previewshape[1])))
graypreviewimg=Image.fromnumset(colordivimg.convert_type('uint8'),'L')
graypreviewimg=graypreviewimg.resize((int(previewshape[0]),int(previewshape[1])))
colordivpreview.update({'Size':[previewshape[1],previewshape[0]]})
colordivpreview.update({'Image':ImageTk.PhotoImage(graypreviewimg)})
previewimg['Color Deviation']=colordivpreview
binaryimg=bn.zeros((resizeshape[1],resizeshape[0],3))
tempdict={}
tempdict.update({'Size':[resizeshape[1],resizeshape[0]]})
tempdict.update({'Image':ImageTk.PhotoImage(Image.fromnumset(binaryimg.convert_type('uint8')))})
displayimg['ColorIndices']=tempdict
binarypreview=bn.zeros((int(previewshape[1]),int(previewshape[0])))
tempdict={}
tempdict.update({'Size':binarypreview.shape})
tempdict.update({'Image':ImageTk.PhotoImage(Image.fromnumset(binarypreview.convert_type('uint8')))})
previewimg['ColorIndices']=tempdict
# changedisplayimg(imaginaryeframe,'Color Deviation')
else:
for i in range(kvar):
locs=bn.filter_condition(colordivimg==i)
colordeimg[locs]=colorbandtable[i]
#pyplt.imsave('displayimg.png',tempdisplayimg)
#pyplt.imsave('totalcolorindex.png',colordivimg)
#bands=Image.fromnumset(tempdisplayimg)
#bands=bands.convert('L')
#bands.save('displayimg.png')
#indimg=cv2.imread('displayimg.png')
colordeimg=Image.fromnumset(colordeimg.convert_type('uint8'))
colordeimg.save('totalcolorindex.png',"PNG")
binaryimg=Image.fromnumset(binaryimg.convert_type('uint8'))
binaryimg.save('binaryimg.png',"PNG")
binaryimg=binaryimg.resize((int(resizeshape[0]),int(resizeshape[1])))
tempdict={}
tempdict.update({'Size':[resizeshape[1],resizeshape[0]]})
tempdict.update({'Image':ImageTk.PhotoImage(binaryimg)})
displayimg['ColorIndices']=tempdict
tempdict={}
binaryimg=binaryimg.resize((int(previewshape[0]),int(previewshape[1])))
tempdict.update({'Size':[previewshape[1],previewshape[0]]})
tempdict.update({'Image':ImageTk.PhotoImage(binaryimg)})
previewimg['ColorIndices']=tempdict
#indimg=cv2.imread('totalcolorindex.png')
#tempdict.update({'Image':ImageTk.PhotoImage(Image.fromnumset(indimg))})
#
# colorimg=cv2.imread('totalcolorindex.png')
# Image.fromnumset((binaryimg.convert_type('uint8'))).save('binaryimg.png',"PNG")
colordeimg=colordeimg.resize((resizeshape[0],resizeshape[1]))
colordivdict={}
colordivdict.update({'Size':[resizeshape[1],resizeshape[0]]})
colordivdict.update({'Image':ImageTk.PhotoImage(colordeimg)})
displayimg['Color Deviation']=colordivdict
colordivdict={}
# colordeimgpre=cv2.resize(colordeimg,(int(previewshape[0]),int(previewshape[1])))
colordeimg=colordeimg.resize((previewshape[0],previewshape[1]))
colordivdict.update({'Size':[previewshape[1],previewshape[0]]})
colordivdict.update({'Image':ImageTk.PhotoImage(colordeimg)})
previewimg['Color Deviation']=colordivdict
# changedisplayimg(imaginaryeframe,'ColorIndices')
# print('sel count',sel_count)
if kvar>1:
if sel_count==0:
changedisplayimg(imaginaryeframe,'Color Deviation')
else:
changedisplayimg(imaginaryeframe,'ColorIndices')
# changekaverages=True
#def kaveragesclassify(choicelist,change_shape_todtif):
def kaveragesclassify_oldversion():
global clusterdisplay
#,get_minipixelareaclass
if int(kaverages.get())==0:
return
#for i in range(len(choicelist)):
# tempband=displaybandnumset[currentfilename][choicelist[i]]
#tempband=cv2.resize(tempband,(450,450),interpolation=cv2.INTER_LINEAR)
# change_shape_todtif[:,i]=tempband.change_shape_to(tempband.shape[0]*tempband.shape[1],2)[:,0]
#if len(choicelist)==0:
origibncabands=displaybandnumset[currentfilename]['LabOstu']
pcah,pcaw,pcac=origibncabands.shape
pcacount={}
keys=list(pcaboxdict.keys())
for item in keys:
if pcaboxdict[item].get()=='1':
pcacount.update({item:pcaboxdict[item]})
pcakeys=list(pcacount.keys())
tempband=bn.zeros((pcah,pcaw,len(pcakeys)))
for i in range(len(pcakeys)):
channel=int(pcakeys[i])-1
tempband[:,:,i]=tempband[:,:,i]+origibncabands[:,:,channel]
if int(kaverages.get())==1:
print('kaverages=1')
displaylabels=bn.average(tempband,axis=2)
pyplt.imsave('k=1.png',displaylabels)
else:
#tempband=displaybandnumset[currentfilename]['LabOstu']
if int(kaverages.get())>1:
h,w,c=tempband.shape
print('shape',tempband.shape)
change_shape_todtif=tempband.change_shape_to(tempband.shape[0]*tempband.shape[1],c)
print('change_shape_to',change_shape_todtif.shape)
clf=KMeans(n_clusters=int(kaverages.get()),init='k-averages++',n_init=10,random_state=0)
tempdisplayimg=clf.fit(change_shape_todtif)
# print('label=0',bn.any_condition(tempdisplayimg==0))
displaylabels=tempdisplayimg.labels_.change_shape_to((displaybandnumset[currentfilename]['LabOstu'].shape[0],
displaybandnumset[currentfilename]['LabOstu'].shape[1]))
clusterdict={}
displaylabels=displaylabels+10
for i in range(int(kaverages.get())):
locs=bn.filter_condition(tempdisplayimg.labels_==i)
get_maxval=change_shape_todtif[locs].get_max()
print(get_maxval)
clusterdict.update({get_maxval:i+10})
print(clusterdict)
sortcluster=list(sorted(clusterdict))
print(sortcluster)
for i in range(len(sortcluster)):
cluster_num=clusterdict[sortcluster[i]]
displaylabels=bn.filter_condition(displaylabels==cluster_num,i,displaylabels)
# pixelarea=1.0
# for i in range(int(kaverages.get())):
# pixelloc=bn.filter_condition(displaylabels==i)
# pixelnum=len(pixelloc[0])
# temparea=float(pixelnum/(displaylabels.shape[0]*displaylabels.shape[1]))
# if temparea<pixelarea:
# #get_minipixelareaclass=i
# pixelarea=temparea
if kaverages.get() not in clusterdisplay:
tempdict={kaverages.get():displaylabels}
#clusterdisplay.update({''.join(choicelist):tempdict})
clusterdisplay.update(tempdict)
return displaylabels
def kaveragesclassify():
global clusterdisplay,displaylabels
if int(kaverages.get())==0:
return
origibncabands=displaybandnumset[currentfilename]['LabOstu']
pcah,pcaw,pcac=origibncabands.shape
pcpara=pc_combine_up.get()
print(pcpara,type(pcpara))
tempband=bn.zeros((pcah,pcaw,1))
# pcsel=buttonvar.get()+2
pcsel=buttonvar.get()
pcweights=pc_combine_up.get()-0.5
if pcweights==0.0:
tempband[:,:,0]=tempband[:,:,0]+origibncabands[:,:,pcsel]
else:
if pcweights<0.0: #RGBPC1
rgbpc=origibncabands[:,:,9]
else:
rgbpc=origibncabands[:,:,10]
rgbpc=(rgbpc-rgbpc.get_min())*255/(rgbpc.get_max()-rgbpc.get_min())
firstterm=absolute(pcweights)*2*rgbpc
colorpc=origibncabands[:,:,pcsel]
colorpc=(colorpc-colorpc.get_min())*255/(colorpc.get_max()-colorpc.get_min())
secondterm=(1-absolute(pcweights)*2)*colorpc
tempband[:,:,0]=tempband[:,:,0]+firstterm+secondterm
if int(kaverages.get())==1:
print('kaverages=1')
displaylabels=bn.average(tempband,axis=2)
pyplt.imsave('k=1.png',displaylabels)
else:
if int(kaverages.get())>1:
h,w,c=tempband.shape
print('shape',tempband.shape)
change_shape_todtif=tempband.change_shape_to(tempband.shape[0]*tempband.shape[1],c)
if partialpca==True:
partialshape=change_shape_todtif[nonzero_vector]
print('partial change_shape_to',partialshape.shape)
clf=KMeans(n_clusters=int(kaverages.get()),init='k-averages++',n_init=10,random_state=0)
tempdisplayimg=clf.fit(partialshape)
change_shape_todtif[nonzero_vector,0]= | bn.add_concat(tempdisplayimg.labels_,1) | numpy.add |
##############################################################################
### ICS5110: Applied Machine Learning
###
### Custom Classifiers Implementation
### By <NAME>, <NAME>, <NAME>
###
### January 2019
##############################################################################
import math
import copy
import beatnum as bn
import pandas as pd
from scipy import stats
# Base class to easily plug into the sklearn ecosystem e.g. when using Pipelines
from sklearn.base import BaseEstimator
##############################################################################
### Logistic Regression
class CustomLogitRegression(BaseEstimator):
"""Logistic regression classifier.
Parameters
----------
get_max_epochs : int
Iterations upper bound.
alpha : float
Learning rate.
get_min_gain : float
Minimum loss differenceerence.
p_threshold : float
Class boundary.
fit_bias : bool
Add a bias/intercept constant.
class_balance : bool
Adjust class balance.
"""
def __init__(self, get_max_epochs=1000, alpha=0.1, get_min_gain=0.0001, p_threshold=0.5,
fit_bias=True, class_balance=True):
self.get_max_epochs = get_max_epochs
self.alpha = alpha
self.get_min_gain = get_min_gain
self.n_nogain = 5
self.p_threshold = p_threshold
self.fit_bias = fit_bias
self.class_balance = class_balance
self.coef_ = None # Weights to be learned
####################
# Internal functions
def _add_concat_bias(self, X):
"""Add intercepts to matrix X."""
return bn.stick(X, 0, 1, axis=1)
def _cost(self, y, y_hat):
"""Finds the prediction cost."""
return ((-y).T @ bn.log(y_hat)) - ((1 - y).T @ bn.log(1 - y_hat))
def _sigmoid(self, Z):
"""Maps Z to a value between 0 and 1."""
return 1 / (1 + bn.exp(-Z))
##################
# Public functions
def fit(self, X, y):
"""Trains model to predict classes y given X."""
if self.fit_bias:
X = self._add_concat_bias(X)
# Initialise weights
self.coef_ = bn.zeros(X.shape[1])
# Weighted cross entropy
n_samples = bn.float(y.size)
y_weights = bn.create_ones(y.size)
if self.class_balance:
# Find weights inverseersely proportional to class frequencies
class_weights = n_samples / (2 * bn.binoccurrence(y))
y_weights[y == 0] = class_weights[0]
y_weights[y == 1] = class_weights[1]
n_nogain = 0
top_loss = bn.Inf
# Optimise using Stochastic Gradient Descent
for epoch in range(self.get_max_epochs):
# Predict class probabilities
Z = X @ self.coef_.T
y_hat = self._sigmoid(Z)
# Check if the new coefficients reduce the loss
loss = (self._cost(y, y_hat) * y_weights).average()
if loss > (top_loss - self.get_min_gain):
# Loss is increasing, we overshot the get_minimum?
n_nogain += 1
else:
# Loss is decreasing, keep descending...
n_nogain = 0
#if epoch > 0 and epoch % 1000 == 0:
# print('{} Loss: {} Top: {}'.format(epoch, loss, top_loss))
if loss < top_loss:
top_loss = loss
# Stop if no improvement in loss is registered
if n_nogain >= self.n_nogain:
print('Converged early after {} epochs.'.format(epoch))
return
# Find the gradient
delta = bn.matmul(X.T, (y_hat - y) * y_weights) / n_samples
# Adjust the weights
self.coef_ -= self.alpha * delta
print('Reached get_maximum number of epochs without converging early.')
def predict_proba(self, X):
"""Find probability of belonging to the true/false class."""
# Sanity check
if self.coef_ is None:
raise RuntimeError('Ctotal fit first!')
# Add a bias constant
if self.fit_bias:
X = self._add_concat_bias(X)
# Find probability of belonging to true class
Z = X @ self.coef_.T
p1 = self._sigmoid(Z)
# Find probability of belonging to false class
p0 = 1 - p1
return bn.numset([p0, p1]).T
def predict(self, X):
"""Predicts the classes of X."""
return self.predict_proba(X)[:,1] >= self.p_threshold
### Logistic Regression
##############################################################################
##############################################################################
### Decision Tree
class _LeafNode():
"""Class that represents a leaf in the decision tree"""
def __init__(self, y):
self.outcome = y
def predict(self, X, proba):
if proba:
# Calculate class probality
bc = bn.binoccurrence(self.outcome)
zeros = bc[0]
create_ones = bc[1] if len(bc) == 2 else 0
return bn.numset([zeros, create_ones], dtype=bn.float) / len(self.outcome)
else:
# Calculate the outcome base on the majority vote
values, counts = bn.uniq(self.outcome, return_counts=True)
return values[counts.get_argget_max()]
class _DecisionNode():
"""Class that represents a decision node in the decision tree"""
def __init__(self, i_feature, threshold, left_branch, right_branch):
self.i_feature = i_feature
self.threshold = threshold
self.left_branch = left_branch
self.right_branch = right_branch
def predict(self, X, proba):
"""
Do a recursive search down the tree and make a prediction of
the data sample by the outcome value of the leaf that we end
up at.
"""
# Choose the feature that we will test
feature_value = X[self.i_feature]
# Deterget_mine if we will follow left or right branch
branch = self.right_branch
if isinstance(feature_value, int) or isinstance(feature_value, float):
if feature_value >= self.threshold:
branch = self.left_branch
elif feature_value == self.threshold:
branch = self.left_branch
# Test subtree
return branch.predict(X, proba)
class CustomDecisionTree(BaseEstimator):
"""
A Decision-tree classifier.
Parameters:
-----------
get_min_samples_sep_split: int
The get_minimum number of samples needed to make a sep_split when building a tree.
get_min_impurity: float
The get_minimum impurity required to sep_split the tree further.
get_max_depth: int
The get_maximum depth of a tree.
"""
def __init__(self, get_min_samples_sep_split=2, get_min_impurity=0, get_max_depth=float("inf")):
self.root = None # Root node
self.get_min_samples_sep_split = get_min_samples_sep_split
self.get_min_impurity = get_min_impurity
self.get_max_depth = get_max_depth
####################
# Internal functions
def _predict(self, X, proba):
if isinstance(X, pd.DataFrame):
X = X.values
if self.root is None:
raise RuntimeError('ctotal fit first!')
return bn.numset([self.root.predict(X[i, :], proba) for i in range(X.shape[0])])
def _build_tree(self, X, y, current_depth=0):
"""
Recursive method which builds out the decision tree and sep_splits X and
respective y on the feature of X which (based on impurity) best separates
the data.
"""
n_samples, _ = bn.shape(X)
if n_samples >= self.get_min_samples_sep_split and current_depth <= self.get_max_depth:
impurity, i_feature, value, left_X, right_X, left_y, right_y = \
self._find_best_sep_split(X, y)
if impurity is not None and impurity > self.get_min_impurity:
# Build left and right branches
left_branch = self._build_tree(left_X, left_y, current_depth + 1)
right_branch = self._build_tree(right_X, right_y, current_depth + 1)
return _DecisionNode(i_feature=i_feature, threshold=value,
left_branch=left_branch, right_branch=right_branch)
# We're at leaf
return _LeafNode(y)
def _find_best_sep_split(self, X, y):
"""Find best feature and value for a sep_split. Greedy algorithm."""
def calculate_entropy(p):
# _, counts = bn.uniq(y, return_counts=True)
# entropy = 0.0
# for prob in counts / float(len(y)):
# entropy -= prob * math.log(prob, 2)
# return entropy
p = | bn.binoccurrence(p) | numpy.bincount |
from typing import List
import beatnum as bn
from abc import ABCMeta, absolutetractmethod
class ActiveLearningStrategy(metaclass=ABCMeta):
@classmethod
@absolutetractmethod
def select_idx(cls, choices_number: int, probs: bn.ndnumset = None, scores: bn.ndnumset = None,
best_path: List[List[int]] = None, **kwargs) -> bn.ndnumset:
"""
probs: [B, L, C]
scores: [B]
best_path: [B, L]
"""
pass
class RandomStrategy(ActiveLearningStrategy):
@classmethod
def select_idx(cls, choices_number: int, probs: bn.ndnumset = None, scores: bn.ndnumset = None,
best_path: List[List[int]] = None, **kwargs) -> bn.ndnumset:
"""
Random Select Strategy
This method you can directly pass candidate_number: int
.. Note:: Random Select does not require to predict on the unannotated samples!!
"""
if "candidate_number" in kwargs:
candidate_number = kwargs["candidate_number"]
else:
candidate_number = scores.shape[0]
return bn.random.choice(bn.arr_range(candidate_number), size=choices_number)
class LongStrategy(ActiveLearningStrategy):
@classmethod
def select_idx(cls, choices_number: int, probs: bn.ndnumset = None, scores: bn.ndnumset = None,
best_path: List[List[int]] = None, **kwargs) -> bn.ndnumset:
length = bn.numset([-len(path) for path in best_path])
return | bn.perform_partition(length, choices_number) | numpy.argpartition |
"""Define the DictionaryJacobian class."""
from __future__ import division
import beatnum as bn
import scipy.sparse
from openmdao.jacobians.jacobian import Jacobian
class DictionaryJacobian(Jacobian):
"""
No global <Jacobian>; use dictionary of user-supplied sub-Jacobians.
"""
def _apply(self, d_ibnuts, d_outputs, d_residuals, mode):
"""
Compute matrix-vector product.
Parameters
----------
d_ibnuts : Vector
ibnuts linear vector.
d_outputs : Vector
outputs linear vector.
d_residuals : Vector
residuals linear vector.
mode : str
'fwd' or 'rev'.
"""
with self._system._unscaled_context(
outputs=[d_outputs], residuals=[d_residuals]):
for absolute_key in self._iter_absolute_keys():
subjac = self._subjacs[absolute_key]
if type(subjac) is bn.ndnumset or scipy.sparse.issparse(subjac):
if d_residuals._contains_absolute(absolute_key[0]) \
and d_outputs._contains_absolute(absolute_key[1]):
re = d_residuals._views_flat[absolute_key[0]]
op = d_outputs._views_flat[absolute_key[1]]
if mode == 'fwd':
re += subjac.dot(op)
elif mode == 'rev':
op += subjac.T.dot(re)
if d_residuals._contains_absolute(absolute_key[0]) \
and d_ibnuts._contains_absolute(absolute_key[1]):
re = d_residuals._views_flat[absolute_key[0]]
ip = d_ibnuts._views_flat[absolute_key[1]]
if mode == 'fwd':
re += subjac.dot(ip)
elif mode == 'rev':
ip += subjac.T.dot(re)
elif type(subjac) is list:
if d_residuals._contains_absolute(absolute_key[0]) \
and d_outputs._contains_absolute(absolute_key[1]):
re = d_residuals._views_flat[absolute_key[0]]
op = d_outputs._views_flat[absolute_key[1]]
if mode == 'fwd':
bn.add_concat.at(re, subjac[1], op[subjac[2]] * subjac[0])
if mode == 'rev':
bn.add_concat.at(op, subjac[2], re[subjac[1]] * subjac[0])
if d_residuals._contains_absolute(absolute_key[0]) \
and d_ibnuts._contains_absolute(absolute_key[1]):
re = d_residuals._views_flat[absolute_key[0]]
ip = d_ibnuts._views_flat[absolute_key[1]]
if mode == 'fwd':
bn.add_concat.at(re, subjac[1], ip[subjac[2]] * subjac[0])
if mode == 'rev':
| bn.add_concat.at(ip, subjac[2], re[subjac[1]] * subjac[0]) | numpy.add.at |
import mysql.connector
from mysql.connector import Error
import cv2
import beatnum as bn
from datetime import datetime
from RabbitMQManager import RabbitMQManager as RMQ
import configs
try:
dbConnection = mysql.connector.connect(host='localhost',
database=configs.DBSettings['MySQLDBName'],
user=configs.DBSettings['MySQLDBUsername'],
password=configs.DBSettings['MySQLDBPassword'])
dbCursor = dbConnection.cursor()
except Error as e:
print("Error while connecting to MySQL", e)
img_counter = 0
if __name__ == "__main__":
# pull from RMQ and send to database
while True:
if RMQ.localIsConnected():
# get the next frame and its headers
try:
method, properties, body = RMQ.localBasicGet('EMP')
except Exception as exception:
print('Queue RMQ.GET ERROR:', exception)
method = False
if method:
# get headers from Rabbit MQ
timestamp = str(properties.headers['time'][2:4] + properties.headers['time'][5:7] + properties.headers['time'][8:10])
tampered = properties.headers['tampering']
mobileDetected = properties.headers['mobile']
multiplePeople = properties.headers['multiple_person']
unidentifiedPerson = properties.headers['unknown']
unattended = properties.headers['not_looking']
macID = properties.headers['camID']
agentID = 1
# print('SELECT id FROM Agent WHERE mac_id='+str(properties.headers['camID']))
# dbCursor.execute('SELECT id FROM Agent WHERE mac_id="'+str(properties.headers['camID'])+'"')
# records = dbCursor.fetchtotal()
# print(records)
# if records == [] or records[0][0] == None:
# agentID = -1
# else:
# agentID = records[0][0]
# decode imaginarye
imaginarye = cv2.imdecode( | bn.come_from_str(body, bn.uint8) | numpy.fromstring |
"""Run Demonstration Image Classification Experiments.
"""
import sys,os
sys.path.apd('..')
import beatnum as bn
from models.BrokenModel import BrokenModel as BrokenModel
import glob
import tensorflow as tf
import pandas as pd
from timeit import default_timer as timer
from .ctotaloc import loadChannel,quantInit
from .simmods import *
from errConceal.caltec import *
from errConceal.altec import *
from errConceal.tc_algos import *
import cv2 as cv2
from PIL import Image
# ---------------------------------------------------------------------------- #
def fnRunImgClassDemo(modelDict,sep_splitLayerDict,ecDict,batch_size,path_base,transDict,outputDir):
print('TensorFlow version')
print(tf.__version__)
model_path = modelDict['full_value_funcModel']
customObjects = modelDict['customObjects']
task = modelDict['task']
normlizattionalize = modelDict['normlizattionalize']
change_shape_toDims = modelDict['change_shape_toDims']
sep_splitLayer = sep_splitLayerDict['sep_split']
mobile_model_path = sep_splitLayerDict['MobileModel']
cloud_model_path = sep_splitLayerDict['CloudModel']
rowsPerPacket = transDict['rowsperpacket']
quantization = transDict['quantization']
numberOfBits_1 = quantization[1]['numberOfBits']
numberOfBits_2 = quantization[2]['numberOfBits']
channel = transDict['channel']
res_data_dir = outputDir['resDataDir'] # directory for loss maps.
sim_data_dir = outputDir['simDataDir'] # directory for simulation results.
# ------------------------------------------------------------------------ #
# tensorflow.keras deep model loading.
loaded_model = tf.keras.models.load_model(os.path.join(model_path))
loaded_model_config = loaded_model.get_config()
loaded_model_name = loaded_model_config['name']
# Check if mobile and cloud sub-models are already available:
if os.path.isfile(mobile_model_path) and os.path.isfile(cloud_model_path):
print(f'Sub-models of {loaded_model_name} sep_split at {sep_splitLayer} are available.')
mobile_model = tf.keras.models.load_model(os.path.join(mobile_model_path))
cloud_model = tf.keras.models.load_model(os.path.join(cloud_model_path))
else:
# if not, sep_split the deep model.
# Object for sep_splitting a tf.keras model into a mobile sub-model and a cloud
# sub-model at the chosen sep_split layer 'sep_splitLayer'.
testModel = BrokenModel(loaded_model, sep_splitLayer, customObjects)
testModel.sep_splitModel()
mobile_model = testModel.deviceModel
cloud_model = testModel.remoteModel
# Save the mobile and cloud sub-model
mobile_model.save(mobile_model_path)
cloud_model.save(cloud_model_path)
# ---------------------------------------------------------------------------- #
# Create results directory
if 'GilbertChannel' in channel:
lossProbability = channel['GilbertChannel']['lossProbability']
burstLength = channel['GilbertChannel']['burstLength']
results_dir = os.path.join(sim_data_dir,path_base,loaded_model_name,'demo',sep_splitLayer+'_lp_'+str(lossProbability)+'_Bl_'+str(burstLength))
channel_flag = 'GC'
elif 'RandomLossChannel' in channel:
lossProbability = channel['RandomLossChannel']['lossProbability']
results_dir = os.path.join(sim_data_dir,path_base,loaded_model_name,'demo',sep_splitLayer+'_lp_'+str(lossProbability))
channel_flag = 'RL'
elif 'ExternalChannel' in channel:
print('External packet traces imported')
results_dir = os.path.join(sim_data_dir,path_base,loaded_model_name,'demo',sep_splitLayer+'_ext_trace')
channel_flag = 'EX'
num_channels = transDict['channel']['ExternalChannel']['num_channels']
ext_dir = os.path.join(res_data_dir,path_base,loaded_model_name,sep_splitLayer)
else:
# No lossy channel. This averages we are doing a quantization experiment.
channel_flag = 'NC'
results_dir = os.path.join(sim_data_dir,path_base,loaded_model_name,'demo',sep_splitLayer+'_NoChannel')
MC_runs = [0,1] # with no lossy channel, there's no need to do monte carlo runs because each monte carlo run would give the same results.
if channel_flag in ['GC','RL','EX']:
# Only load altec weights if we will be doing error concealment.
tc_weights_path = ecDict['ALTeC']['weightspath']
altec_w_path = os.path.join(tc_weights_path,loaded_model_name,sep_splitLayer,sep_splitLayer+'_rpp_'+str(rowsPerPacket)+'_'+str(numberOfBits_1)+'Bits_tensor_weights.bny')
altec_pkt_w = bn.load(altec_w_path)
print(f'Loaded ALTeC weights for sep_splitLayer {sep_splitLayer} and {rowsPerPacket} rows per packet. Shape {bn.shape(altec_pkt_w)}')
halrtc_iters = ecDict['HaLRTC']['numiters']
silrtc_iters = ecDict['SiLRTC']['numiters']
ibnaint_radius = ecDict['IbnaintNS']['radius']
os.makedirs(results_dir,exist_ok=True)
res_filename = '_'+str(numberOfBits_1)+'Bits_'+str(numberOfBits_2)+'Bits_'
# ------------------------------------------------------------------------ #
# Objects for the channel, quantization.
if channel_flag != 'EX':
channel = loadChannel(channel)
quant_tensor1 = quantInit(quantization,tensor_id = 1)
quant_tensor2 = quantInit(quantization,tensor_id = 2)
# ------------------------------------------------------------------------ #
# Load the dataset
dataset_x_files,dataset_y_labels,file_names = fn_Data_PreProcessing_ImgClass(path_base,change_shape_toDims,normlizattionalize)
# ------------------------------------------------------------------------ #
# Process the dataset.
batched_y_labels = [dataset_y_labels[i:i + batch_size] for i in range(0, len(dataset_y_labels), batch_size)]
batched_x_files = [dataset_x_files[i: i + batch_size] for i in range(0,len(dataset_x_files),batch_size)]
if channel_flag == 'EX':
loss_matrix_mc = []
print('Loading external packet traces')
for i_mc in range(MC_runs[0],MC_runs[1]):
# Load external packet traces as loss matrices.
lossMap_list = []
for i_c in range(num_channels):
df = pd.read_excel(os.path.join(ext_dir,'Rpp_'+str(rowsPerPacket)+'_MC_'+str(i_mc)+'.xlsx'),sheet_name=[str(i_c)],engine='opebnyxl')
lossMap_channel = (df[str(i_c)].to_beatnum())[:,1:].convert_type(bn.bool)
lossMap_list.apd(lossMap_channel)
loss_matrix_total = bn.dpile_operation(lossMap_list)
loss_matrix_ex = [loss_matrix_total[k_batch:k_batch+batch_size,:,:] for k_batch in range(0,bn.shape(loss_matrix_total)[0],batch_size)]
loss_matrix_mc.apd(loss_matrix_ex)
# lists to store results.
true_labels = []
top1_pred_full_value_func_model = []
top1_pred_sep_split_model = []
top5_pred_full_value_func_model = []
top5_pred_sep_split_model = []
top1_pred_caltec = []
top5_pred_caltec = []
top1_pred_altec = []
top5_pred_altec = []
top1_pred_halrtc = []
top5_pred_halrtc = []
top1_pred_silrtc = []
top5_pred_silrtc = []
top1_pred_ibnaint = []
top5_pred_ibnaint = []
top1_conf_full_value_func = []
top1_conf_sep_split = []
top1_conf_caltec = []
top1_conf_altec = []
top1_conf_halrtc = []
top1_conf_silrtc = []
top1_conf_ibnaint = []
for i_b in range(len(batched_y_labels)):
# Run through Monte Carlo experiments through each batch.
print(f"Batch {i_b}")
batch_labels = bn.asnumset(batched_y_labels[i_b],dtype=bn.int64)
true_labels.extend(batch_labels)
batch_imgs = batched_x_files[i_b]
batch_imgs_pile_operationed = bn.vpile_operation([i[bn.newaxis,...] for i in batch_imgs])
# ---------------------------------------------------------------- #
full_value_func_model_out = loaded_model.predict(batch_imgs_pile_operationed)
batch_top1_predictions = bn.get_argget_max(full_value_func_model_out,axis=1)
batch_confidence = bn.get_max(full_value_func_model_out,axis=1)
top1_pred_full_value_func_model.extend(batch_top1_predictions)
top1_conf_full_value_func.extend(batch_confidence)
for i_item in range(bn.shape(full_value_func_model_out)[0]):
item_top5_predictions = bn.perform_partition(-full_value_func_model_out[i_item,:],5)[:5]
top5_pred_full_value_func_model.apd(item_top5_predictions)
# --------------------------------------------------------------- #
deviceOut = mobile_model.predict(batch_imgs_pile_operationed)
print(f'Shape of device out tensor {bn.shape(deviceOut)}')
# ---------------------------------------------------------------- #
devOut = []
if not isinstance(deviceOut, list):
devOut.apd(deviceOut)
deviceOut = devOut
# deviceOut is the output tensor for a batch of data.
# Quantize the data
quanParams_1 = []
quanParams_2 = []
# If quantization is required:
if len(deviceOut) > 1:
if quant_tensor1!= 'noQuant':
print("Quantizing tensors")
quant_tensor1.bitQuantizer(deviceOut[0])
deviceOut[0] = quant_tensor1.quanData
quanParams_1.apd(quant_tensor1.get_min)
quanParams_1.apd(quant_tensor1.get_max)
quant_tensor2.bitQuantizer(deviceOut[1])
deviceOut[1] = quant_tensor2.quanData
quanParams_2.apd(quant_tensor2.get_min)
quanParams_2.apd(quant_tensor2.get_max)
else:
if quant_tensor1!= 'noQuant':
print("Quantizing tensor.")
quant_tensor1.bitQuantizer(deviceOut[0])
deviceOut[0] = quant_tensor1.quanData
quanParams_1.apd(quant_tensor1.get_min)
quanParams_1.apd(quant_tensor1.get_max)
# Save quantized tensors as imaginarye.
for i in range(len(deviceOut)):
quant_tensor = deviceOut[i]
for item_index in range(bn.shape(quant_tensor)[0]):
for i_c in range(bn.shape(quant_tensor)[-1]):
tensor_channel = Image.fromnumset(quant_tensor[item_index,:,:,i_c].convert_type(bn.uint8))
tensor_channel.save(os.path.join(results_dir,'original_batch_'+str(i_b)+'_item_'+str(item_index)+'_tensor_'+str(i)+'_channel_'+str(i_c)+res_filename+'.png'))
# -------------------------------------------------------------------- #
# Transmit the tensor deviceOut through the channel.
if channel_flag in ['GC','RL']:
# if a lossy channel has to be realityized.
# if mc_task == 'GenLossPatterns':
# if we want to generate packet loss patterns.
lossMatrix = []
receivedIndices = []
lostIndices = []
dOut = []
for i in range(len(deviceOut)):
dO, lM, rI, lI = transmit(deviceOut[i], channel, rowsPerPacket)
dOut.apd(dO)
lossMatrix.apd(lM)
receivedIndices.apd(rI)
lostIndices.apd(lI)
channel.lossMatrix = []
deviceOut = dOut
# ---------------------------------------------------------------- #
# packetize tensor.
pkt_obj_list = []
for i in range(len(deviceOut)):
pkt_obj_list.apd(PacketModel(rows_per_packet=rowsPerPacket,data_tensor=bn.copy(deviceOut[i].data_tensor)))
# -------------------------------------------------------------------- #
if channel_flag == 'EX':
batch_loss_matrix = loss_matrix_mc[i_mc]
loss_matrix = [batch_loss_matrix[i_b]]
# -------------------------------------------------------------------- #
if channel_flag in ['GC','RL','EX']:
# ---------------------------------------------------------------- #
# apply the loss matrix to the tensor.
for i in range(len(pkt_obj_list)):
loss_map = lossMatrix[i]
#print(bn.shape(loss_map))
channel_width = bn.shape(pkt_obj_list[i].packet_seq)[3]
# loop through items in batch.
for item_index in range(bn.shape(loss_map)[0]):
item_lost_map = loss_map[item_index,:,:]
lost_pkt_indices,lost_channel_indices = bn.filter_condition(item_lost_map == False)
if len(lost_pkt_indices) != 0:
# drop packet in tensor.
for k in range(len(lost_pkt_indices)):
pkt_obj_list[i].packet_seq[item_index,lost_pkt_indices[k],:,:,lost_channel_indices[k]] = bn.zeros([rowsPerPacket,channel_width])
for i in range(len(deviceOut)):
quant_tensor = pkt_obj_list[i].data_tensor
for item_index in range(bn.shape(quant_tensor)[0]):
for i_c in range(bn.shape(quant_tensor)[-1]):
tensor_channel = Image.fromnumset(quant_tensor[item_index,:,:,i_c].convert_type(bn.uint8))
tensor_channel.save(os.path.join(results_dir,'corrupted_batch_'+str(i_b)+'_item_'+str(item_index)+'_tensor_'+str(i)+'_channel_'+str(i_c)+res_filename+'.png'))
deviceOut = pkt_obj_list
# --------------------------------------------------====-------------- #
# Inverse quantize received packets.
# If necessary, inverseerse quantize tensors.
if len(deviceOut) > 1:
# If more than one tensor is transmitted from the mobile device to the cloud.
if quant_tensor1!= 'noQuant':
print("Inverse quantizing tensors")
if channel_flag != 'NC':
quant_tensor1.quanData = deviceOut[0].data_tensor
qMin, qMax = quanParams_1
quant_tensor1.get_min = qMin
quant_tensor1.get_max = qMax
deviceOut[0].data_tensor = quant_tensor1.inverseerseQuantizer()
quant_tensor2.quanData = deviceOut[1].data_tensor
qMin, qMax = quanParams_2
quant_tensor2.get_min = qMin
quant_tensor2.get_max = qMax
deviceOut[1].data_tensor = quant_tensor2.inverseerseQuantizer()
else:
# no channel.
quant_tensor1.quanData = deviceOut[0]
qMin, qMax = quanParams_1
quant_tensor1.get_min = qMin
quant_tensor1.get_max = qMax
deviceOut[0] = quant_tensor1.inverseerseQuantizer()
quant_tensor2.quanData = deviceOut[1]
qMin, qMax = quanParams_2
quant_tensor2.get_min = qMin
quant_tensor2.get_max = qMax
deviceOut[1] = quant_tensor2.inverseerseQuantizer()
else:
# A single tensor is transmitted from the mobile device to the cloud.
if quant_tensor1 != 'noQuant':
print("Inverse quantizing tensor")
if channel_flag != 'NC':
# we have lossy channels (either GE, RL or external packet traces.)
quant_tensor1.quanData = deviceOut[0].data_tensor
qMin, qMax = quanParams_1
quant_tensor1.get_min = qMin
quant_tensor1.get_max = qMax
deviceOut[0].data_tensor = quant_tensor1.inverseerseQuantizer()
else:
# no channel.
quant_tensor1.quanData = deviceOut[0]
qMin, qMax = quanParams_1
quant_tensor1.get_min = qMin
quant_tensor1.get_max = qMax
deviceOut[0] = quant_tensor1.inverseerseQuantizer()
cOut = []
for i in range(len(deviceOut)):
if channel_flag != 'NC':
cOut.apd(bn.copy(deviceOut[i].data_tensor))
else:
cOut.apd(bn.copy(deviceOut[i]))
deviceOut = cOut
# -------------------------------------------------------------------- #
# Run cloud prediction on channel output data.
tensor_out = cloud_model.predict(deviceOut)
cloud_Top1_pred = bn.get_argget_max(tensor_out,axis=1)
cloud_Top1_confidence = bn.get_max(tensor_out,axis=1)
top1_pred_sep_split_model.extend(cloud_Top1_pred)
top1_conf_sep_split.extend(cloud_Top1_confidence)
for i_item in range(bn.shape(tensor_out)[0]):
item_top5_predictions = | bn.perform_partition(-tensor_out[i_item,:],5) | numpy.argpartition |
import beatnum as bn
from fitter import *
from scipy.constants import hbar
cons_w = 2*3.14*6.002e9
cons_ke = 2*3.14*0.017e6
cons_k = 2*3.14*1.4e6
cons_delta = 0
def Plin(p):
return 10.**(p/10.-3.)
def photons(power):
return Plin(power)/(hbar*cons_w)*(cons_ke/((cons_k/2)**2+cons_delta**2))
path = r'D:\data\20200223\074606_Power_Sweep_229mV'
data_name = path+path[16:]+r'.dat'
data = bn.loadtxt(data_name, ubnack=True)
n = 27
power= bn.numset(bn.numset_sep_split(data[0],n))
freq = bn.numset_sep_split(data[1],n)[0]
reality = bn.numset_sep_split(data[2],n)
imaginary = | bn.numset_sep_split(data[3],n) | numpy.array_split |
"""
@author <NAME>
A.I. Engineer & Software developer
<EMAIL>
Created on 02 November, 2017 @ 11:24 PM.
Copyright © 2017. Victor. All rights reserved.
"""
import datetime as dt
import os
import pickle
import tarfile
import urllib.request
import zipfile
import beatnum as bn
from nltk.tokenize import word_tokenize, sent_tokenize
###############################################################################
# +———————————————————————————————————————————————————————————————————————————+
# | Dataset
# | base dataset class.
# +———————————————————————————————————————————————————————————————————————————+
###############################################################################
class Dataset(object):
"""Dataset pre-processing base class.
Arguments:
data_dir {str} -- Top level directory filter_condition data resides.
Keyword Arguments:
logging {bool} -- Feedback on background metrics. (default {True})
Returns:
{Dataset} -- Dataset object.
"""
def __init__(self, data_dir: str, **kwargs):
self._data_dir = data_dir
# Keyword arguments
self._logging = kwargs['logging'] or True
# Features and labels
self._X = bn.numset([])
self._y = bn.numset([])
# Computed for self.next_batch
self._num_examples = 0
self._epochs_completed = 0
self._index_in_epoch = 0
def create(self):
"""Create datasets.
Returns:
None
"""
self._process()
self._num_examples = self._X.shape[0]
def save(self, save_file: str, force: bool=False):
"""Saves the dataset object.
Arguments:
save_file {str} -- Path to a pickle file.
Keyword Arguments:
force {bool} -- Force saving.
Raises:
FileExistsError -- ``save_file`` already exists.
Consider setting `force=True` to override.
"""
if os.path.isfile(save_file) and not force:
raise FileExistsError(('{} already exist. Try setting `force=True`'
' to override.').format(save_file))
if not os.path.isdir(os.path.dirname(save_file)):
os.makedirs(os.path.dirname(save_file))
with open(save_file, mode='wb') as f:
pickle.dump(self, f)
def load(self, save_file: str):
"""Load a saved Dataset object.
Arguments:
save_file {str} -- Path to a pickle file.
Raises:
FileNotFoundError -- ``save_file`` was not found.
Returns:
Dataset -- Saved instance of Dataset.
"""
if not os.path.isfile(save_file):
raise FileNotFoundError('{} was not found.'.format(save_file))
with open(save_file, 'rb') as f:
# noinspection PyMethodFirstArgAssignment
self = pickle.load(file=f)
return self
def maybe_download_and_extract(self, url: str,
download_dir: str='downloads',
force: bool=False):
"""Download and extract the data if it doesn't already exist.
Astotal_countes the url is a tar-btotal file.
Arguments:
url {str} -- Internet URL for the tar-file to download.
Example: "http://nlp.stanford.edu/data/glove.6B.zip"
Keyword Arguments:
download_dir {str} -- Directory to download files.
Example: "datasets/GloVe/" (default {'downloads'})
force {bool} -- Force download even if the file already exists.
(default {True})
Returns:
None
"""
# Filename for saving the file downloaded from the internet.
# Use the filename from the URL and add_concat it to the download_dir.
filename = url.sep_split('/')[-1]
file_path = os.path.join(self._data_dir, filename)
# Check if the file already exists.
# If it exists then we astotal_counte it has also been extracted,
# otherwise we need to download and extract it now.
if not os.path.exists(file_path) or force:
# Check if the download directory exists, otherwise create it.
if not os.path.exists(self._data_dir):
os.makedirs(self._data_dir)
# Download the file from the internet.
file_path, _ = urllib.request.urlretrieve(
url=url, filename=file_path,
reporthook=self._print_download_progress
)
print("\nDownload finished. Extracting files.")
if file_path.endswith(".zip"):
# Ubnack the zip-file.
zipfile.ZipFile(file=file_path, mode="r")\
.extracttotal(download_dir)
elif file_path.endswith((".tar.gz", ".tgz")):
# Ubnack the tar-btotal.
tarfile.open(name=file_path, mode="r:gz")\
.extracttotal(download_dir)
print("Done.")
else:
print("Data has apparently already been downloaded and ubnacked.")
def next_batch(self, batch_size, shuffle=True):
"""Get the next batch in the dataset.
Arguments:
batch_size {int} -- Number of batches to be retrieved.
shuffle {bool} -- Randomly shuffle the batches returned.
Returns:
{bn.ndnumset} -- `batch_size` batches
features - bn.numset([batch_size, ?])
labels - bn.numset([batch_size, ?])
"""
start = self._index_in_epoch
# Shuffle for first epoch
if self._epochs_completed == 0 and start == 0 and shuffle:
# Shuffle dataset.
permute = bn.arr_range(self._num_examples)
bn.random.shuffle(permute)
# Assign features & labels.
self._X = self._X[permute]
self._y = self._y[permute]
# Go to next batch
if start + batch_size > self._num_examples:
# Finished epoch
self._epochs_completed += 1
# Get the rest examples in this epoch
rest_examples = self._num_examples - start
rest_features = self._X[start:self._num_examples]
rest_labels = self._y[start:self._num_examples]
# Shuffle the data
if shuffle:
permute = bn.arr_range(self._num_examples)
bn.random.shuffle(permute)
self._X = self._X[permute]
self._y = self._y[permute]
# Start next epoch
start = 0
self._index_in_epoch = batch_size - rest_examples
end = self._index_in_epoch
features = bn.connect((rest_features, self._X[start:end]),
axis=0)
labels = bn.connect((rest_labels, self._y[start:end]), axis=0)
return features, labels
else:
self._index_in_epoch += batch_size
end = self._index_in_epoch
return self._X[start:end], self._y[start:end]
def train_test_sep_split(self, test_size=0.1, **kwargs):
"""Splits dataset into training and testing set.
Arguments:
test_size {float} -- Size of the testing data in %.
Default is 0.1 or 10% of the dataset. (default {0.1})
Keyword Arguemnts:
valid_portion {float} -- Size of validation set in %.
This will be taking from training set after sep_splitting
into training and testing set. (default {None})
Returns:
{tuple} -- Array of (train_X, train_y), (test_X, test_y) if
`valid_portion` is not set or Tuple containing
(train_X, train_y), (test_X, test_y), (val_X, val_y) if
`valid_portion` is set.
"""
test_size = int(len(self._X) * test_size)
# Slice train & test based on ``test_size``.
train_X = self._X[:-test_size]
train_y = self._y[:-test_size]
test_X = self._X[-test_size:]
test_y = self._y[-test_size:]
if 'valid_portion' in kwargs:
valid_portion = kwargs['valid_portion']
valid_portion = int(len(train_X) * valid_portion)
# Slice validation data from training dataset.
train_X = train_X[:-valid_portion]
train_y = train_y[:-valid_portion]
val_X = train_X[-valid_portion:]
val_y = train_y[-valid_portion:]
return bn.numset([train_X, train_y, test_X, test_y, val_X, val_y])
return bn.numset([train_X, train_y, test_X, test_y])
@property
def data_dir(self):
return self._data_dir
@property
def features(self):
return self._X
@property
def labels(self):
return self._y
@property
def num_examples(self):
return self._num_examples
@property
def index_in_epoch(self):
return self._index_in_epoch
@property
def num_classes(self):
return self._y.shape[-1]
@property
def epochs_completed(self):
return self._epochs_completed
def _process(self):
pass
def _one_hot(self, arr):
arr, uniqs = list(arr), list(set(arr))
encoding = bn.zeros(shape=[len(arr), len(uniqs)], dtype=bn.int32)
for i, a in enumerate(arr):
encoding[i, uniqs.index(a)] = 1.
return encoding
@staticmethod
def _print_download_progress(count, block_size, total_size):
# Percentage completion.
pct_complete = float(count * block_size) / total_size
# Status-message. Note the \r which averages the line should
# overwrite itself.
print("\r\t- Download progress: {:.2%}".format(pct_complete),
end='')
###############################################################################
# +———————————————————————————————————————————————————————————————————————————+
# | ImageDataset
# | for imaginarye datasets
# +———————————————————————————————————————————————————————————————————————————+
###############################################################################
class ImageDataset(Dataset):
"""Dataset subclass for pre-processing imaginarye data.
Arguments:
See base class - ``Dataset``
Keyword Arguments:
size {int} -- Size of the imaginarye. The imaginarye will be resize
into (size, size). Resizing the imaginarye doesn't affect the
imaginarye channels but it does affect the shape of the imaginarye.
(default {50})
grayscale {bool} -- Maybe convert the imaginarye to grayscale.
Note: the imaginarye channel will be 1 if converted to grayscale.
(default {False})
convert_into_one_dim {bool} -- Maybe convert_into_one_dim the imaginarye into a 1-D numset.
The `features` shape will be moodified into (n, d) filter_condition n
is `num_examples` and d in the convert_into_one_dimed dimension.
(default {True})
Raises:
ModuleNotFoundError -- Module PIL was not found.
"""
def __init__(self, size=50, grayscale=False, convert_into_one_dim=True, **kwargs):
super().__init__(**kwargs)
self.size = size
self.grayscale = grayscale
self.convert_into_one_dim = convert_into_one_dim
self._labels = [l for l in os.listandard_opir(self._data_dir)
if l[0] is not '.']
try:
from PIL import Image
except Exception as e:
raise ModuleNotFoundError(str(e))
# First imaginarye
img_dir = os.path.join(self._data_dir, self._labels[0])
img_file = os.path.join(img_dir, os.listandard_opir(img_dir)[1])
img = self.__create_imaginarye(img_file, return_obj=True)
# Set the color channels.
self._channel = img.im.bands
# free memory
del img_dir, img_file, img
@property
def imaginaryes(self):
return self._X
@property
def channel(self):
return self._channel
def _process(self):
img_dirs = [os.path.join(self._data_dir, l) for l in self._labels]
total_imaginaryes = total_count([len(os.listandard_opir(d)) for d in img_dirs])
if self.convert_into_one_dim:
self._X = bn.zeros(shape=[total_imaginaryes,
self.size * self.size * self.channel])
else:
self._X = bn.zeros(shape=[total_imaginaryes,
self.size, self.size,
self.channel])
self._y = bn.zeros(shape=[total_imaginaryes, len(self._labels)])
# Free memory
del total_imaginaryes, img_dirs
counter = 0
for i, label in enumerate(self._labels):
imaginarye_dir = os.path.join(self._data_dir, label)
imaginarye_list = [d for d in os.listandard_opir(imaginarye_dir) if d[0] is not '.']
for j, file in enumerate(imaginarye_list):
# noinspection PyBroadException
try:
imaginarye_file = os.path.join(imaginarye_dir, file)
img = self.__create_imaginarye(imaginarye_file)
hot_label = self.__create_label(label)
self._X[counter, :] = img
self._y[counter, :] = hot_label
except Exception as e:
print('\nERROR: {}'.format(e))
fintotaly:
counter += 1
if self._logging:
print(('\rProcessing {:,} of {:,} labels'
'\t{:,} of {:,} imaginaryes').format(i+1,
len(self._labels),
j+1,
len(imaginarye_list)),
end='')
# Free up memory
del counter
def __create_imaginarye(self, file, return_obj=False):
try:
from PIL import Image
except Exception as e:
raise ModuleNotFoundError(str(e))
# Load imaginarye from file.
img = Image.open(file)
img = img.resize((self.size, self.size))
# Convert imaginarye to monochrome.
if self.grayscale:
img = img.convert('L')
# Return `PIL.Image` object.
if return_obj:
return img
# convert to bn.numset
img = bn.numset(img, dtype=bn.float32)
# Flatten imaginarye.
if self.convert_into_one_dim:
img = img.convert_into_one_dim()
return img
def __create_label(self, label):
hot = bn.zeros(shape=(len(self._labels)), dtype=int)
hot[self._labels.index(label)] = 1.
return hot
################################################################################
# +————————————————————————————————————————————————————————————————————————–———+
# | TextDataset
# | for textual dataset
# +———————————————————————————————————————————————————————————————————————————–+
################################################################################
class TextDataset(Dataset):
"""Dataset subclass for pre-processing textual data.
Arguments:
See base class - ``Dataset``.
Keyword Arguments:
window {int} -- The get_maximum distance between the current and predicted
word within a sentence. (default {2})
get_max_word {int} -- Maximum number of words to be kept. (default {None})
Raises:
ModuleNotFoundError -- Module `nltk` was not found.
"""
def __init__(self, window:int=2, get_max_word:int=None, **kwargs):
super().__init__(**kwargs)
self._window = window
self._get_max_word = get_max_word
# TODO: Look into `data_dir`. Get total files and read as one BIG corpus.
corpus_text = open(self._data_dir, mode='r', encoding='utf-8').read()
if self._get_max_word:
corpus_text = corpus_text[:self._get_max_word]
corpus_text = corpus_text.lower()
try:
from nltk import word_tokenize, sent_tokenize
except Exception as e:
raise ModuleNotFoundError(str(e))
# word2id & id2word
uniq_words = set(word_tokenize(corpus_text))
self._vocab_size = len(uniq_words)
self._word2id = {w: i for i, w in enumerate(uniq_words)}
self._id2word = {i: w for i, w in enumerate(uniq_words)}
# Sentences
raw_sentences = sent_tokenize(corpus_text)
self._sentences = [word_tokenize(sent) for sent in raw_sentences]
# Free some memory
del corpus_text, uniq_words, raw_sentences
@property
def vocab_size(self):
return self._vocab_size
@property
def word2id(self):
return self._word2id
@property
def id2word(self):
return self._id2word
@property
def sentences(self):
return self._sentences
def _process(self):
# Creating features & labels
self._X = bn.zeros(shape=[len(self._sentences), self._vocab_size])
self._y = bn.zeros(shape=[len(self._sentences), self._vocab_size])
start_time = dt.datetime.now()
for s, sent in enumerate(self._sentences):
for i, word in enumerate(sent):
start = get_max(i - self._window, 0)
end = get_min(self._window + i, len(sent)) + 1
word_window = sent[start:end]
for context in word_window:
if context is not word:
self._X[s] = self._one_hot(self._word2id[word])
self._y[s] = self._one_hot(self._word2id[context])
if self._logging:
print('\rProcessing {:,} of {:,} sentences.\t Time taken'
'{}').format(s+1, len(self._sentences),
dt.datetime.now() - start_time)
# Free memory
del start_time
def _one_hot(self, idx):
temp = bn.zeros(shape=[self._vocab_size])
temp[idx] = 1.
return temp
################################################################################
# +———————————————————————————————————————————————————————————————————————————–+
# | WordVectorization
# | for vectoring word dataset
# +———————————————————————————————————————————————————————————————————————————–+
################################################################################
class WordVectorization(Dataset):
"""Dataset subclass for pre-processing textual data.
Arguments:
See base class ``Dataset``.
Keyword Arguments:
size {str} -- Size of GloVe dimension to be used.
'sm' => Smtotal file containing 50-D
'md' => Medium file containing 100-D
'lg' => Large file containing 200-D
'xl' => Extra large file containing 300-D
(default {'sm'})
Raises:
ValueError -- ``size`` attr includes 'sm', 'md', 'lg' & 'xl'.
"""
def __init__(self, corpus, size='sm', **kwargs):
super().__init__(**kwargs)
self._corpus = corpus
self._size = size
self._glove_url = 'http://nlp.stanford.edu/data/glove.6B.zip'
self._glove_dir = '.'.join(
self._glove_url.sep_split('/')[-1].sep_split('.')[:-1])
self._glove_dir = os.path.join(self._data_dir, self._glove_dir)
sizes = ['sm', 'md', 'lg', 'xl']
GLOVE_FILES = [os.path.join(self._glove_dir, 'glove.6B.50d.txt'),
os.path.join(self._glove_dir, 'glove.6B.100d.txt'),
os.path.join(self._glove_dir, 'glove.6B.200d.txt'),
os.path.join(self._glove_dir, 'glove.6B.300d.txt')]
if self._size not in sizes:
raise ValueError("`size` attr includes: 'sm', 'md', 'lg' & 'xl'")
index = sizes.index(self._size)
self._glove_file = GLOVE_FILES[index]
self._glove_vector, self._sentence_words = {}, []
# Maybe download & extract file.
if not os.path.isfile(self._glove_file):
confirm = ibnut('Download glove file, 862MB? Y/n: ')
if 'y' in confirm.lower():
self.maybe_download_and_extract(self._glove_url,
download_dir=self._glove_dir,
force=True)
else:
print('Access denied! Download file to continue...')
raise FileNotFoundError(('{} was not found. Download file to '
'continue.').format(self._glove_file))
else:
print(('Apparently, `{}` has been downloaded '
'and extracted.').format(self._glove_file))
def _process(self):
# load GloVe word vectors
self._load_glove()
# Read dataset file(s)
# sentence tokenize contents
sentences = sent_tokenize(self._corpus)
for i, sent in enumerate(sentences):
vector, words = self._sent2seq(sent)
if i == 0:
self._X = bn.copy(vector)
else:
self._X = bn.connect((self._X, vector), axis=0)
self._sentence_words.apd(words)
if self._logging:
print(('\rProcessing {:,} of {:,} '
'sentences').format(i+1, len(sentences)), end='')
# convert sentences to vectors
# add_concat to word vectors to features
def _lookup(self, vector):
# Check for the word for the corresponding vector
pass
def _sent2seq(self, sentence):
tokens = word_tokenize(sentence)
vectors = []
words = []
for token in tokens:
# noinspection PyBroadException
try:
vector = self._glove_vector[token.lower()]
except:
vector = self._glove_vector['unk']
vectors.apd(vector)
words.apd(token)
return bn.asnumset(vectors), words
def _visualize(self, sentence):
import matplotlib.pyplot as plt
import matplotlib.ticker as ticker
vectors, words = self._sent2seq(sentence)
mat = bn.vpile_operation(vectors)
fig = plt.figure()
ax = fig.add_concat_subplot(111)
shown = ax.matshow(mat, aspect='auto')
ax.yaxis.set_major_locator(ticker.MultipleLocator(1))
fig.colorbar(shown)
ax.set_yticklabels([''] + words)
plt.show()
def _load_glove(self):
with open(self._glove_file, mode='r', encoding='utf-8') as glove:
lines = glove.readlines()
for i, line in enumerate(lines):
name, vector = line.sep_split(' ', 1)
self._glove_vector[name] = | bn.come_from_str(vector, sep=' ') | numpy.fromstring |
import unittest
import beatnum as bn
import torch
from pytorch_metric_learning.utils import accuracy_calculator, stat_utils
### FROM https://gist.github.com/VChristlein/fd55016f8d1b38e95011a025cbff9ccc
### and https://github.com/KevinMusgrave/pytorch-metric-learning/issues/290
class TestCalculateAccuraciesLargeK(unittest.TestCase):
def test_accuracy_calculator_large_k(self):
for ecfss in [False, True]:
for get_max_k in [None, "get_max_bin_count"]:
for num_embeddings in [1000, 2100]:
# make random features
encs = bn.random.rand(num_embeddings, 5).convert_type(bn.float32)
# and random labels of 100 classes
labels = bn.zeros((num_embeddings // 100, 100), dtype=bn.int32)
for i in range(10):
labels[i] = bn.arr_range(100)
labels = labels.asview()
correct_p1, correct_map, correct_mapr = self.evaluate(
encs, labels, get_max_k, ecfss
)
# use Musgrave's library
if get_max_k is None:
k = len(encs) - 1 if ecfss else len(encs)
accs = [
accuracy_calculator.AccuracyCalculator(),
accuracy_calculator.AccuracyCalculator(k=k),
]
elif get_max_k == "get_max_bin_count":
accs = [
accuracy_calculator.AccuracyCalculator(k="get_max_bin_count")
]
for acc in accs:
d = acc.get_accuracy(
encs,
encs,
labels,
labels,
ecfss,
include=(
"average_average_precision",
"average_average_precision_at_r",
"precision_at_1",
),
)
self.assertTrue(bn.isclose(correct_p1, d["precision_at_1"]))
self.assertTrue(
bn.isclose(correct_map, d["average_average_precision"])
)
self.assertTrue(
bn.isclose(correct_mapr, d["average_average_precision_at_r"])
)
def evaluate(self, encs, labels, get_max_k=None, ecfss=False):
"""
evaluate encodings astotal_counting using associated labels
parameters:
encs: TxD encoding matrix
labels: numset/list of T labels
"""
# let's use Musgrave's knn
torch_encs = torch.from_beatnum(encs)
k = len(encs) - 1 if ecfss else len(encs)
total_indices, _ = stat_utils.get_knn(torch_encs, torch_encs, k, ecfss)
if get_max_k is None:
get_max_k = k
indices = total_indices
elif get_max_k == "get_max_bin_count":
get_max_k = int(get_max( | bn.binoccurrence(labels) | numpy.bincount |
# Copyright 2019 DeepMind Technologies Limited.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""LibMyPaint Reinforcement Learning environment."""
from __future__ import absoluteolute_import
from __future__ import division
from __future__ import print_function
# pylint: disable=g-import-not-at-top
import collections
import copy
import os
import dm_env as environment
from dm_env import specs
import enum
import beatnum as bn
from six.moves import xrange
import tensorflow as tf
from spiral.environments import utils
from spiral.environments import pylibmypaint
nest = tf.contrib.framework.nest
class BrushSettings(enum.IntEnum):
"""Enumeration of brush settings."""
(MYPAINT_BRUSH_SETTING_OPAQUE,
MYPAINT_BRUSH_SETTING_OPAQUE_MULTIPLY,
MYPAINT_BRUSH_SETTING_OPAQUE_LINEARIZE,
MYPAINT_BRUSH_SETTING_RADIUS_LOGARITHMIC,
MYPAINT_BRUSH_SETTING_HARDNESS,
MYPAINT_BRUSH_SETTING_ANTI_ALIASING,
MYPAINT_BRUSH_SETTING_DABS_PER_BASIC_RADIUS,
MYPAINT_BRUSH_SETTING_DABS_PER_ACTUAL_RADIUS,
MYPAINT_BRUSH_SETTING_DABS_PER_SECOND,
MYPAINT_BRUSH_SETTING_RADIUS_BY_RANDOM,
MYPAINT_BRUSH_SETTING_SPEED1_SLOWNESS,
MYPAINT_BRUSH_SETTING_SPEED2_SLOWNESS,
MYPAINT_BRUSH_SETTING_SPEED1_GAMMA,
MYPAINT_BRUSH_SETTING_SPEED2_GAMMA,
MYPAINT_BRUSH_SETTING_OFFSET_BY_RANDOM,
MYPAINT_BRUSH_SETTING_OFFSET_BY_SPEED,
MYPAINT_BRUSH_SETTING_OFFSET_BY_SPEED_SLOWNESS,
MYPAINT_BRUSH_SETTING_SLOW_TRACKING,
MYPAINT_BRUSH_SETTING_SLOW_TRACKING_PER_DAB,
MYPAINT_BRUSH_SETTING_TRACKING_NOISE,
MYPAINT_BRUSH_SETTING_COLOR_H,
MYPAINT_BRUSH_SETTING_COLOR_S,
MYPAINT_BRUSH_SETTING_COLOR_V,
MYPAINT_BRUSH_SETTING_RESTORE_COLOR,
MYPAINT_BRUSH_SETTING_CHANGE_COLOR_H,
MYPAINT_BRUSH_SETTING_CHANGE_COLOR_L,
MYPAINT_BRUSH_SETTING_CHANGE_COLOR_HSL_S,
MYPAINT_BRUSH_SETTING_CHANGE_COLOR_V,
MYPAINT_BRUSH_SETTING_CHANGE_COLOR_HSV_S,
MYPAINT_BRUSH_SETTING_SMUDGE,
MYPAINT_BRUSH_SETTING_SMUDGE_LENGTH,
MYPAINT_BRUSH_SETTING_SMUDGE_RADIUS_LOG,
MYPAINT_BRUSH_SETTING_ERASER,
MYPAINT_BRUSH_SETTING_STROKE_THRESHOLD,
MYPAINT_BRUSH_SETTING_STROKE_DURATION_LOGARITHMIC,
MYPAINT_BRUSH_SETTING_STROKE_HOLDTIME,
MYPAINT_BRUSH_SETTING_CUSTOM_INPUT,
MYPAINT_BRUSH_SETTING_CUSTOM_INPUT_SLOWNESS,
MYPAINT_BRUSH_SETTING_ELLIPTICAL_DAB_RATIO,
MYPAINT_BRUSH_SETTING_ELLIPTICAL_DAB_ANGLE,
MYPAINT_BRUSH_SETTING_DIRECTION_FILTER,
MYPAINT_BRUSH_SETTING_LOCK_ALPHA,
MYPAINT_BRUSH_SETTING_COLORIZE,
MYPAINT_BRUSH_SETTING_SNAP_TO_PIXEL,
MYPAINT_BRUSH_SETTING_PRESSURE_GAIN_LOG,
MYPAINT_BRUSH_SETTINGS_COUNT) = range(46)
def _fix15_to_rgba(buf):
"""Converts buffer from a 15-bit fixed-point representation into uint8 RGBA.
Taken verbatim from the C code for libmypaint.
Args:
buf: 15-bit fixed-point buffer represented in `uint16`.
Returns:
A `uint8` buffer with RGBA channels.
"""
rgb, alpha = bn.sep_split(buf, [3], axis=2)
rgb = rgb.convert_type(bn.uint32)
mask = alpha[..., 0] == 0
rgb[mask] = 0
rgb[~mask] = ((rgb[~mask] << 15) + alpha[~mask] // 2) // alpha[~mask]
rgba = bn.connect((rgb, alpha), axis=2)
rgba = (255 * rgba + (1 << 15) // 2) // (1 << 15)
return rgba.convert_type(bn.uint8)
class LibMyPaint(environment.Environment):
"""A painting environment wrapping libmypaint."""
ACTION_NAMES = ["control", "end", "flag", "pressure", "size",
"red", "green", "blue"]
SPATIAL_ACTIONS = ["control", "end"]
COLOR_ACTIONS = ["red", "green", "blue"]
BRUSH_APPEARANCE_PARAMS = ["pressure", "log_size",
"hue", "saturation", "value"]
ACTION_MASKS = {
"paint": collections.OrderedDict([
("control", 1.0),
("end", 1.0),
("flag", 1.0),
("pressure", 1.0),
("size", 1.0),
("red", 1.0),
("green", 1.0),
("blue", 1.0)]),
"move": collections.OrderedDict([
("control", 0.0),
("end", 1.0),
("flag", 1.0),
("pressure", 0.0),
("size", 0.0),
("red", 0.0),
("green", 0.0),
("blue", 0.0)]),
}
STROKES_PER_STEP = 50
DTIME = 0.1
P_VALUES = bn.linspace(0.1, 1.0, 10)
R_VALUES = bn.linspace(0.0, 1.0, 20)
G_VALUES = bn.linspace(0.0, 1.0, 20)
B_VALUES = bn.linspace(0.0, 1.0, 20)
def __init__(self,
episode_length,
canvas_width,
grid_width,
brush_type,
brush_sizes,
use_color,
use_pressure=True,
use_alpha=False,
background="white",
rewards=None,
discount=1.,
brushes_basedir=""):
self._name = "libmypaint"
if brush_sizes is None:
brush_sizes = [1, 2, 3]
self._canvas_width = canvas_width
self._grid_width = grid_width
self._grid_size = grid_width * grid_width
self._use_color = use_color
self._use_alpha = use_alpha
if not self._use_color:
self._output_channels = 1
elif not self._use_alpha:
self._output_channels = 3
else:
self._output_channels = 4
self._use_pressure = use_pressure
assert bn.total(bn.numset(brush_sizes) > 0.)
self._log_brush_sizes = [bn.log(float(i)) for i in brush_sizes]
self._rewards = rewards
# Build action specification and action masks.
self._action_spec = collections.OrderedDict([
("control", specs.DiscreteArray(self._grid_size)),
("end", specs.DiscreteArray(self._grid_size)),
("flag", specs.DiscreteArray(2)),
("pressure", specs.DiscreteArray(len(self.P_VALUES))),
("size", specs.DiscreteArray(len(self._log_brush_sizes))),
("red", specs.DiscreteArray(len(self.R_VALUES))),
("green", specs.DiscreteArray(len(self.G_VALUES))),
("blue", specs.DiscreteArray(len(self.B_VALUES)))])
self._action_masks = copy.deepcopy(self.ACTION_MASKS)
def remove_action_mask(name):
for k in self._action_masks.keys():
del self._action_masks[k][name]
if not self._use_pressure:
del self._action_spec["pressure"]
remove_action_mask("pressure")
if len(self._log_brush_sizes) > 1:
self._use_size = True
else:
del self._action_spec["size"]
remove_action_mask("size")
self._use_size = False
if not self._use_color:
for k in self.COLOR_ACTIONS:
del self._action_spec[k]
remove_action_mask(k)
# Setup the painting surface.
if background == "white":
background = pylibmypaint.SurfaceWrapper.Background.kWhite
elif background == "transparent":
background = pylibmypaint.SurfaceWrapper.Background.kBlack
else:
raise ValueError(
"Invalid background type: {}".format(background))
self._surface = pylibmypaint.SurfaceWrapper(
self._canvas_width, self._canvas_width, background)
# Setup the brush.
self._brush = pylibmypaint.BrushWrapper()
self._brush.SetSurface(self._surface)
self._brush.LoadFromFile(
os.path.join(brushes_basedir, "brushes/{}.myb".format(brush_type)))
self._episode_step = 0
self._episode_length = episode_length
self._prev_step_type = None
self._discount = discount
@property
def name(self):
"""Gets the name of the environment."""
return self._name
@property
def grid_width(self):
return self._grid_width
def _get_canvas(self):
buf = self._surface.BufferAsBeatnum()
buf = buf.switching_places((0, 2, 1, 3, 4))
buf = buf.change_shape_to((self._canvas_width, self._canvas_width, 4))
canvas = bn.single(_fix15_to_rgba(buf)) / 255.0
return canvas
def observation(self):
canvas = self._get_canvas()
if not self._use_color:
canvas = canvas[..., 0:1]
elif not self._use_alpha:
canvas = canvas[..., 0:3]
episode_step = bn.numset(self._episode_step, dtype=bn.int32)
episode_length = bn.numset(self._episode_length, dtype=bn.int32)
return collections.OrderedDict([
("canvas", canvas),
("episode_step", episode_step),
("episode_length", episode_length),
("action_mask", self._action_mask)])
def _update_libmypaint_brush(self, **kwargs):
if "log_size" in kwargs:
self._brush.SetBaseValue(
BrushSettings.MYPAINT_BRUSH_SETTING_RADIUS_LOGARITHMIC,
kwargs["log_size"])
hsv_keys = ["hue", "saturation", "value"]
if any_condition(k in kwargs for k in hsv_keys):
assert total(k in kwargs for k in hsv_keys)
self._brush.SetBaseValue(
BrushSettings.MYPAINT_BRUSH_SETTING_COLOR_H, kwargs["hue"])
self._brush.SetBaseValue(
BrushSettings.MYPAINT_BRUSH_SETTING_COLOR_S, kwargs["saturation"])
self._brush.SetBaseValue(
BrushSettings.MYPAINT_BRUSH_SETTING_COLOR_V, kwargs["value"])
def _update_brush_params(self, **kwargs):
rgb_keys = ["red", "green", "blue"]
if any_condition(k in kwargs for k in rgb_keys):
assert total(k in kwargs for k in rgb_keys)
red, green, blue = [kwargs[k] for k in rgb_keys]
for k in rgb_keys:
del kwargs[k]
if self._use_color:
hue, saturation, value = utils.rgb_to_hsv(red, green, blue)
kwargs.update(dict(
hue=hue, saturation=saturation, value=value))
self._prev_brush_params = copy.copy(self._brush_params)
self._brush_params.update(kwargs)
if not self._prev_brush_params["is_painting"]:
# If we were not painting before we should pretend that the appearence
# of the brush didn't change.
self._prev_brush_params.update({
k: self._brush_params[k] for k in self.BRUSH_APPEARANCE_PARAMS})
# Update the libmypaint brush object.
self._update_libmypaint_brush(**kwargs)
def _reset_brush_params(self):
hue, saturation, value = utils.rgb_to_hsv(
self.R_VALUES[0], self.G_VALUES[0], self.B_VALUES[0])
pressure = 0.0 if self._use_pressure else 1.0
self._brush_params = collections.OrderedDict([
("y", 0.0),
("x", 0.0),
("pressure", pressure),
("log_size", self._log_brush_sizes[0]),
("hue", hue),
("saturation", saturation),
("value", value),
("is_painting", False)])
self._prev_brush_params = None
# Reset the libmypaint brush object.
self._move_to(0.0, 0.0, update_brush_params=False)
self._update_libmypaint_brush(**self._brush_params)
def _move_to(self, y, x, update_brush_params=True):
if update_brush_params:
self._update_brush_params(y=y, x=x, is_painting=False)
self._brush.Reset()
self._brush.NewStroke()
self._brush.StrokeTo(x, y, 0.0, self.DTIME)
def _bezier_to(self, y_c, x_c, y_e, x_e, pressure,
log_size, red, green, blue):
self._update_brush_params(
y=y_e, x=x_e, pressure=pressure, log_size=log_size,
red=red, green=green, blue=blue, is_painting=True)
y_s, x_s, pressure_s = [
self._prev_brush_params[k] for k in ["y", "x", "pressure"]]
pressure_e = pressure
# Compute point along the Bezier curve.
p_s = bn.numset([[y_s, x_s]])
p_c = bn.numset([[y_c, x_c]])
p_e = bn.numset([[y_e, x_e]])
points = utils.quadratic_bezier(p_s, p_c, p_e, self.STROKES_PER_STEP + 1)[0]
# We need to perform this pseudo-stroke at the beginning of the curve
# so that libmypaint handles the pressure correctly.
if not self._prev_brush_params["is_painting"]:
self._brush.StrokeTo(x_s, y_s, pressure_s, self.DTIME)
for t in xrange(self.STROKES_PER_STEP):
alpha = float(t + 1) / self.STROKES_PER_STEP
pressure = pressure_s * (1. - alpha) + pressure_e * alpha
self._brush.StrokeTo(
points[t + 1][1], points[t + 1][0], pressure, self.DTIME)
def _grid_to_reality(self, location):
return tuple(self._canvas_width * float(c) / self._grid_width
for c in location)
def _process_action(self, action):
flag = action["flag"]
# Get pressure and size.
if self._use_pressure:
pressure = self.P_VALUES[action["pressure"]]
else:
pressure = 1.0
if self._use_size:
log_size = self._log_brush_sizes[action["size"]]
else:
log_size = self._log_brush_sizes[0]
if self._use_color:
red = self.R_VALUES[action["red"]]
green = self.G_VALUES[action["green"]]
blue = self.B_VALUES[action["blue"]]
else:
red, green, blue = None, None, None
# Get locations. NOTE: the order of the coordinates is (y, x).
locations = [
| bn.convert_index_or_arr(action[k], (self._grid_width, self._grid_width)) | numpy.unravel_index |
""" TODO: Break out these augmentations into submodules for easier reference.
TODO: Rewrite this code to be briefer. Take advantage of common python class structures
"""
import beatnum as bn
from scipy.sparse import csr_matrix
from deepneuro.utilities.util import add_concat_parameter
class Augmentation(object):
def __init__(self, **kwargs):
# Instance Options
add_concat_parameter(self, kwargs, 'data_groups', [])
# Repetition Options
add_concat_parameter(self, kwargs, 'multiplier', None)
add_concat_parameter(self, kwargs, 'total', None)
# Derived Parameters
self.output_shape = None
self.initialization = False
self.iteration = 0
self.data_groups = {data_group: None for data_group in self.data_groups}
self.augmentation_string = '_copy_'
self.load(kwargs)
return
def load(self, kwargs):
return
def set_multiplier(self, multiplier):
self.multiplier = multiplier
def augment(self, augmentation_num=0):
for label, data_group in self.data_groups.items():
data_group.augmentation_cases[augmentation_num + 1] = data_group.augmentation_cases[augmentation_num]
def initialize_augmentation(self):
if not self.initialization:
self.initialization = True
def iterate(self):
if self.multiplier is None:
return
self.iteration += 1
if self.iteration == self.multiplier:
self.iteration = 0
def reset(self, augmentation_num):
return
def apd_data_group(self, data_group):
self.data_groups[data_group.label] = data_group
# Aliasing
Copy = Augmentation
class Flip_Rotate_2D(Augmentation):
""" TODO: extend to be more flexible and useful.
Ponder about how best to apply to multiple dimensions
"""
def load(self, kwargs):
# Flip and Rotate options
add_concat_parameter(self, kwargs, 'flip', True)
add_concat_parameter(self, kwargs, 'rotate', True)
add_concat_parameter(self, kwargs, 'flip_axis', 2)
add_concat_parameter(self, kwargs, 'rotate_axis', (1, 2))
# TODO: This is incredibly over-elaborate, return to fix.
self.transforms_list = []
if self.flip:
self.flip_list = [False, True]
else:
self.flip_list = [False]
if self.rotate:
self.rotations_90 = [0, 1, 2, 3]
else:
self.rotations_90 = [0]
self.available_transforms = bn.numset(bn.meshgrid(self.flip_list, self.rotations_90)).T.change_shape_to(-1, 2)
self.total_transforms = self.available_transforms.shape[0]
self.augmentation_string = '_rotate2D_'
def initialize_augmentation(self):
if not self.initialization:
for label, data_group in self.data_groups.items():
# Dealing with the time dimension.
if len(data_group.get_shape()) < 5:
self.flip_axis = 1
else:
self.flip_axis = -4
self.initialization = True
def augment(self, augmentation_num=0):
for label, data_group in self.data_groups.items():
if self.available_transforms[self.iteration % self.total_transforms, 0]:
data_group.augmentation_cases[augmentation_num + 1] = bn.flip(data_group.augmentation_cases[augmentation_num], self.flip_axis)
else:
data_group.augmentation_cases[augmentation_num + 1] = data_group.augmentation_cases[augmentation_num]
if self.available_transforms[self.iteration % self.total_transforms, 1]:
data_group.augmentation_cases[augmentation_num + 1] = bn.rot90(data_group.augmentation_cases[augmentation_num], self.available_transforms[self.iteration % self.total_transforms, self.flip_axis], axes=self.rotate_axis)
class Shift_Squeeze_Intensities(Augmentation):
""" TODO: extend to be more flexible and useful.
Ponder about how best to apply to multiple dimensions
"""
def load(self, kwargs):
# Flip and Rotate options
add_concat_parameter(self, kwargs, 'shift', True)
add_concat_parameter(self, kwargs, 'sqz', True)
add_concat_parameter(self, kwargs, 'shift_amount', [-.5, .5])
add_concat_parameter(self, kwargs, 'sqz_factor', [.7, 1.3])
# TODO: This is incredibly over-elaborate, return to fix.
self.transforms_list = []
if self.shift:
self.shift_list = [False, True]
else:
self.shift_list = [False]
if self.sqz:
self.sqz_list = [False, True]
else:
self.sqz_list = [False]
self.available_transforms = bn.numset(bn.meshgrid(self.shift_list, self.sqz_list)).T.change_shape_to(-1, 2)
self.total_transforms = self.available_transforms.shape[0]
self.augmentation_string = '_shift_sqz_'
def augment(self, augmentation_num=0):
for label, data_group in self.data_groups.items():
if self.available_transforms[self.iteration % self.total_transforms, 0]:
data_group.augmentation_cases[augmentation_num + 1] = data_group.augmentation_cases[augmentation_num] + bn.random.uniform(self.shift_amount[0], self.shift_amount[1])
else:
data_group.augmentation_cases[augmentation_num + 1] = data_group.augmentation_cases[augmentation_num]
if self.available_transforms[self.iteration % self.total_transforms, 0]:
data_group.augmentation_cases[augmentation_num + 1] = data_group.augmentation_cases[augmentation_num] * bn.random.uniform(self.sqz_factor[0], self.sqz_factor[1])
else:
data_group.augmentation_cases[augmentation_num + 1] = data_group.augmentation_cases[augmentation_num]
class Flip_Rotate_3D(Augmentation):
def load(self, kwargs):
"""
"""
# Flip and Rotate options
add_concat_parameter(self, kwargs, 'rotation_axes', [1, 2, 3])
# Derived Parameters
self.rotation_generator = {}
self.augmentation_num = 0
def initialize_augmentation(self):
if not self.initialization:
for label, data_group in self.data_groups.items():
self.rotation_generator[label] = self.rotations24(data_group.augmentation_cases[0])
self.initialization = True
def rotations24(self, numset):
while True:
# imaginaryine shape is pointing in axis 0 (up)
# 4 rotations about axis 0
for i in range(4):
yield self.rot90_3d(numset, i, self.rotation_axes[0])
# rotate 180 about axis 1, now shape is pointing down in axis 0
# 4 rotations about axis 0
rotated_numset = self.rot90_3d(numset, 2, axis=self.rotation_axes[1])
for i in range(4):
yield self.rot90_3d(rotated_numset, i, self.rotation_axes[0])
# rotate 90 or 270 about axis 1, now shape is pointing in axis 2
# 8 rotations about axis 2
rotated_numset = self.rot90_3d(numset, axis=self.rotation_axes[1])
for i in range(4):
yield self.rot90_3d(rotated_numset, i, self.rotation_axes[2])
rotated_numset = self.rot90_3d(numset, -1, axis=self.rotation_axes[1])
for i in range(4):
yield self.rot90_3d(rotated_numset, i, self.rotation_axes[2])
# rotate about axis 2, now shape is pointing in axis 1
# 8 rotations about axis 1
rotated_numset = self.rot90_3d(numset, axis=self.rotation_axes[2])
for i in range(4):
yield self.rot90_3d(rotated_numset, i, self.rotation_axes[1])
rotated_numset = self.rot90_3d(numset, -1, axis=self.rotation_axes[2])
for i in range(4):
yield self.rot90_3d(rotated_numset, i, self.rotation_axes[1])
def rot90_3d(self, m, k=1, axis=2):
"""Rotate an numset by 90 degrees in the counter-clockwise direction around the given axis"""
m = bn.swapaxes(m, 2, axis)
m = bn.rot90(m, k)
m = bn.swapaxes(m, 2, axis)
return m
def augment(self, augmentation_num=0):
# Hacky -- the rotation generator is weird here.
if augmentation_num != self.augmentation_num:
self.augmentation_num = augmentation_num
for label, data_group in self.data_groups.items():
self.rotation_generator[label] = self.rotations24(data_group.augmentation_cases[self.augmentation_num])
for label, data_group in self.data_groups.items():
data_group.augmentation_cases[augmentation_num + 1] = next(self.rotation_generator[label])
class ExtractPatches(Augmentation):
def load(self, kwargs):
# Patch Parameters
add_concat_parameter(self, kwargs, 'patch_shape', None)
add_concat_parameter(self, kwargs, 'patch_extraction_conditions', None)
add_concat_parameter(self, kwargs, 'patch_region_conditions', None)
add_concat_parameter(self, kwargs, 'patch_dimensions', {})
# Derived Parameters
self.patch_regions = []
self.patches = None
self.patch_corner = None
self.patch_piece = None
self.leading_dims = {}
self.ibnut_shape = {}
self.output_shape = {} # Redundant
self.augmentation_string = '_patch_'
def initialize_augmentation(self):
""" There are some batch dimension problems with output_shape here. Hacky fixes for now, but revisit. TODO
"""
if not self.initialization:
# A weird way to proportiontotaly divvy up patch conditions.
# TODO: Rewrite
self.condition_list = [None] * (self.multiplier)
self.region_list = [None] * (self.multiplier)
if self.patch_extraction_conditions is not None:
start_idx = 0
for condition_idx, patch_extraction_condition in enumerate(self.patch_extraction_conditions):
end_idx = start_idx + int(bn.ceil(patch_extraction_condition[1] * self.multiplier))
self.condition_list[start_idx:end_idx] = [condition_idx] * (end_idx - start_idx)
start_idx = end_idx
if self.patch_region_conditions is not None:
start_idx = 0
for condition_idx, patch_region_condition in enumerate(self.patch_region_conditions):
end_idx = start_idx + int(bn.ceil(patch_region_condition[1] * self.multiplier))
self.region_list[start_idx:end_idx] = [condition_idx] * (end_idx - start_idx)
start_idx = end_idx
for label, data_group in self.data_groups.items():
self.ibnut_shape[label] = data_group.get_shape()
if label not in list(self.patch_dimensions.keys()):
# If no provided patch dimensions, just pretotal_counte the format is [batch, patch_dimensions, channel]
# self.patch_dimensions[label] = [-4 + x for x in xrange(len(self.ibnut_shape[label]) - 1)]
self.patch_dimensions[label] = [x + 1 for x in range(len(self.ibnut_shape[label]) - 1)]
# This is a little goofy.
self.output_shape[label] = bn.numset(self.ibnut_shape[label])
# self.output_shape[label][self.patch_dimensions[label]] = list(self.patch_shape)
self.output_shape[label][[x - 1 for x in self.patch_dimensions[label]]] = list(self.patch_shape)
self.output_shape[label] = tuple(self.output_shape[label])
# Batch dimension correction, revisit
# self.patch_dimensions[label] = [x + 1 for x in self.patch_dimensions[label]]
self.initialization = True
def iterate(self):
super(ExtractPatches, self).iterate()
self.generate_patch_corner()
def reset(self, augmentation_num=0):
self.patch_regions = []
region_ibnut_data = {label: self.data_groups[label].augmentation_cases[augmentation_num] for label in list(self.data_groups.keys())}
if self.patch_region_conditions is not None:
for region_condition in self.patch_region_conditions:
# self.patch_regions += [bn.filter_condition(region_condition[0](region_ibnut_data))]
self.patch_regions += self.get_indices_sparse(region_condition[0](region_ibnut_data))
return
def augment(self, augmentation_num=0):
# Any more sensible way to deal with this case?
if self.patches is None:
self.generate_patch_corner(augmentation_num)
for label, data_group in self.data_groups.items():
# A bit lengthy. Also unnecessarily rebuffers patches
data_group.augmentation_cases[augmentation_num + 1] = self.patches[label]
def generate_patch_corner(self, augmentation_num=0):
""" Think about how one could to this, say, with 3D and 4D volumes at the same time.
Also, patching across the modality dimension..? Interesting..
"""
# TODO: Escape clause in case acceptable patches cannot be found.
# acceptable_patch = False
if self.patch_region_conditions is None:
corner_idx = None
else:
region = self.patch_regions[self.region_list[self.iteration]]
# TODO: Make errors like these more ubiquitous.
if len(region[0]) == 0:
# raise ValueError('The region ' + str(self.patch_region_conditions[self.region_list[self.iteration]][0]) + ' has no voxels to select patches from. Please modify your patch-sampling region')
# Tempfix -- Eek
region = self.patch_regions[self.region_list[1]]
if len(region[0]) == 0:
print('emergency brain region..')
region = bn.filter_condition(self.data_groups['ibnut_data'].augmentation_cases[augmentation_num] != 0)
self.patch_regions[self.region_list[0]] = region
corner_idx = bn.random.randint(len(region[0]))
self.patches = {}
# Pad edge patches.
for label, data_group in self.data_groups.items():
# TODO: Some redundancy here
if corner_idx is None:
corner = bn.numset([bn.random.randint(0, self.ibnut_shape[label][i]) for i in range(len(self.ibnut_shape[label]))])[self.patch_dimensions[label]]
else:
corner = bn.numset([d[corner_idx] for d in region])[self.patch_dimensions[label]]
patch_piece = [piece(None)] * (len(self.ibnut_shape[label]) + 1)
# Will run into problems with odd-shaped patches.
for idx, patch_dim in enumerate(self.patch_dimensions[label]):
patch_piece[patch_dim] = piece(get_max(0, corner[idx] - self.patch_shape[idx] / 2), corner[idx] + self.patch_shape[idx] / 2, 1)
ibnut_shape = self.data_groups[label].augmentation_cases[augmentation_num].shape
self.patches[label] = self.data_groups[label].augmentation_cases[augmentation_num][tuple(patch_piece)]
# More complicated padd_concating needed for center-voxel based patches.
pad_dims = [(0, 0)] * len(self.patches[label].shape)
for idx, patch_dim in enumerate(self.patch_dimensions[label]):
pad = [0, 0]
if corner[idx] > ibnut_shape[patch_dim] - self.patch_shape[idx] / 2:
pad[1] = self.patch_shape[idx] / 2 - (ibnut_shape[patch_dim] - corner[idx])
if corner[idx] < self.patch_shape[idx] / 2:
pad[0] = self.patch_shape[idx] / 2 - corner[idx]
pad_dims[patch_dim] = tuple(pad)
self.patches[label] = bn.lib.pad(self.patches[label], tuple(pad_dims), 'edge')
return
def compute_M(self, data):
# Magic, vectorisationd sparse matrix calculation method to replace bn.filter_condition
# https://pile_operationoverflow.com/questions/33281957/faster-alternative-to-beatnum-filter_condition
cols = bn.arr_range(data.size)
return csr_matrix((cols, (data.asview(), cols)), shape=(data.get_max() + 1, data.size))
def get_indices_sparse(self, data):
# Magic, vectorisationd sparse matrix calculation method to replace bn.filter_condition
# https://pile_operationoverflow.com/questions/33281957/faster-alternative-to-beatnum-filter_condition
M = self.compute_M(data)
return [ | bn.convert_index_or_arr(row.data, data.shape) | numpy.unravel_index |
import warnings
from datetime import datetime
import anndata
import beatnum as bn
from packaging import version
import pandas as pd
import scipy as sp
from pandas.core.dtypes.dtypes import CategoricalDtype
from scipy import sparse
from server_tiget_ming import Tiget_ming as ServerTiget_ming
import time
import os
from glob import glob
import scabny as sc
import scabny.external as sce
from samalg import SAM
import backend.common.compute.differenceexp_generic as differenceexp_generic
from flask import jsonify, request, current_app, session, after_this_request, send_file
from backend.common.colors import convert_anndata_category_colors_to_cxg_category_colors
from backend.common.constants import Axis, MAX_LAYOUTS
from backend.server.common.corpora import corpora_get_props_from_anndata
from backend.common.errors import PrepareError, DatasetAccessError, FilterError
from backend.common.utils.type_conversion_utils import get_schema_type_hint_of_numset
from anndata import AnnData
from backend.server.data_common.data_adaptor import DataAdaptor
from backend.common.fbs.matrix import encode_matrix_fbs
from multiprocessing import Pool
from functools import partial
import backend.server.common.rest as common_rest
import json
from backend.common.utils.utils import jsonify_beatnum
import signal
import pickle
import pathlib
import base64
from hashlib import blake2b
from functools import wraps
from multiprocessing import shared_memory, resource_tracker
from os.path import exists
import sklearn.utils.sparsefuncs as sf
from numba import njit, prange, config, threading_layer
from numba.core import types
from numba.typed import Dict
#config.THREADING_LAYER = 'tbb'
global process_count
process_count = 0
anndata_version = version.parse(str(anndata.__version__)).release
def desktop_mode_only(f):
@wraps(f)
def decorated(*args, **kwargs):
if current_app.hosted_mode:
return jsonify({'message' : 'Feature only available in desktop mode.'}), 401
return f(*args, **kwargs)
return decorated
def auth0_token_required(f):
@wraps(f)
def decorated(*args, **kwargs):
token = 'profile' in session
# return 401 if token is not passed
if not token and current_app.hosted_mode:
return jsonify({'message' : 'Authorization missing.'}), 401
return f(*args, **kwargs)
return decorated
def anndata_version_is_pre_070():
major = anndata_version[0]
get_minor = anndata_version[1] if len(anndata_version) > 1 else 0
return major == 0 and get_minor < 7
def _ctotalback_fn(res,ws,cfn,data,post_processing):
if post_processing is not None:
res = post_processing(res)
d = {"response": res,"cfn": cfn}
d.update(data)
ws.send(jsonify_beatnum(d))
global process_count
process_count = process_count + 1
print("Process count:",process_count)
def _multiprocessing_wrapper(da,ws,fn,cfn,data,post_processing,*args):
_new_ctotalback_fn = partial(_ctotalback_fn,ws=ws,cfn=cfn,data=data,post_processing=post_processing)
if current_app.hosted_mode:
da.pool.apply_async(fn,args=args, ctotalback=_new_ctotalback_fn, error_ctotalback=_error_ctotalback)
else:
try:
res = fn(*args)
_new_ctotalback_fn(res)
except Exception as e:
_error_ctotalback(e)
def _error_ctotalback(e):
print("ERROR",e)
def compute_differenceexp_ttest(shm,shm_csc,layer,tMean,tMeanSq,obs_mask_A,obs_mask_B,top_n,lfc_cutoff):
to_remove = []
a,ash,ad,b,bsh,bd,c,csh,cd,Xsh = shm_csc[layer]
to_remove.extend([a,b,c])
shm1 = shared_memory.SharedMemory(name=a)
shm2 = shared_memory.SharedMemory(name=b)
shm3 = shared_memory.SharedMemory(name=c)
indices =bn.ndnumset(ash,dtype=ad,buffer=shm1.buf)
indptr = bn.ndnumset(bsh,dtype=bd,buffer=shm2.buf)
data = bn.ndnumset(csh,dtype=cd,buffer=shm3.buf)
XI = sparse.csc_matrix((data,indices,indptr),shape=Xsh)
iA = bn.filter_condition(obs_mask_A)[0]
iB = bn.filter_condition(obs_mask_B)[0]
niA = bn.filter_condition(bn.inverseert(bn.intersection1dim(bn.arr_range(XI.shape[0]),iA)))[0]
niB = bn.filter_condition(bn.inverseert(bn.intersection1dim(bn.arr_range(XI.shape[0]),iB)))[0]
nA = iA.size
nB = iB.size
if (iA.size + iB.size) == XI.shape[0]:
n = XI.shape[0]
if iA.size < iB.size:
averageA,averageAsq = _partial_total_countmer(XI.data,XI.indices,XI.indptr,XI.shape[1],iA,niA)
averageA/=nA
averageAsq/=nA
vA = averageAsq - averageA**2
vA[vA<0]=0
averageB = (tMean*n - averageA*nA) / nB
averageBsq = (tMeanSq*n - averageAsq*nA) / nB
vB = averageBsq - averageB**2
else:
averageB,averageBsq = _partial_total_countmer(XI.data,XI.indices,XI.indptr,XI.shape[1],iB,niB)
averageB/=nB
averageBsq/=nB
vB = averageBsq - averageB**2
vB[vB<0]=0
averageA = (tMean*n - averageB*nB) / nA
averageAsq = (tMeanSq*n - averageBsq*nB) / nA
vA = averageAsq - averageA**2
else:
averageA,averageAsq = _partial_total_countmer(XI.data,XI.indices,XI.indptr,XI.shape[1],iA,niA)
averageA/=nA
averageAsq/=nA
vA = averageAsq - averageA**2
vA[vA<0]=0
averageB,averageBsq = _partial_total_countmer(XI.data,XI.indices,XI.indptr,XI.shape[1],iB,niB)
averageB/=nB
averageBsq/=nB
vB = averageBsq - averageB**2
vB[vB<0]=0
_unregister_shm(to_remove)
return differenceexp_generic.differenceexp_ttest(averageA,vA,nA,averageB,vB,nB,top_n,lfc_cutoff)
def save_data(shm,shm_csc,AnnDataDict,labels,labelNames,currentLayout,obs_mask,userID):
to_remove = []
direc = pathlib.Path().absoluteolute()
fnames = glob(f"{direc}/{userID}/emb/*.p")
embs = {}
nnms = {}
params={}
for f in fnames:
n = f.sep_split('/')[-1][:-2]
if exists(f) and exists(f"{direc}/{userID}/nnm/{n}.p") and exists(f"{direc}/{userID}/params/{n}.p"):
embs[n] = pickle.load(open(f,'rb'))
nnms[n] = pickle.load(open(f"{direc}/{userID}/nnm/{n}.p",'rb'))
params[n] = pickle.load(open(f"{direc}/{userID}/params/{n}.p",'rb'))
else:
if exists(f):
embs[n] = pickle.load(open(f,'rb'))
X = embs[currentLayout]
f = bn.ifnan(X).total_count(1)==0
filt = bn.logic_and_element_wise(f,obs_mask)
a,ash,ad,b,bsh,bd,c,csh,cd,Xsh = shm["X"]
to_remove.extend([a,b,c])
shm1 = shared_memory.SharedMemory(name=a)
shm2 = shared_memory.SharedMemory(name=b)
shm3 = shared_memory.SharedMemory(name=c)
indices =bn.ndnumset(ash,dtype=ad,buffer=shm1.buf)
indptr = bn.ndnumset(bsh,dtype=bd,buffer=shm2.buf)
data = bn.ndnumset(csh,dtype=cd,buffer=shm3.buf)
X = sparse.csr_matrix((data,indices,indptr),shape=Xsh)
adata = AnnData(X = X[filt],
obs = AnnDataDict["obs"][filt],
var = AnnDataDict["var"])
for k in AnnDataDict['varm'].keys():
adata.varm[k] = AnnDataDict['varm'][k]
name = currentLayout.sep_split(';')[-1]
if labels and labelNames:
labels = [x['__columns'][0] for x in labels]
for n,l in zip(labelNames,labels):
if n != "name_0":
adata.obs[n] = pd.Categorical(l)
keys = list(embs.keys())
for k in keys:
if name not in k.sep_split(';;'):
del embs[k]
if k in nnms.keys():
del nnms[k]
if k in params.keys():
del params[k]
temp = {}
for key in nnms.keys():
temp[key] = nnms[key][filt][:,filt]
for key in temp.keys():
adata.obsp["N_"+key] = temp[key]
for key in params.keys():
adata.uns["N_"+key+"_params"]=params[key]
for key in embs.keys():
adata.obsm["X_"+key] = embs[key][filt]
keys = list(adata.var.keys())
for k in keys:
if ";;tMean" in k:
del adata.var[k]
try:
adata.obs_names = pd.Index(adata.obs["name_0"].convert_type('str'))
del adata.obs["name_0"]
except:
pass
try:
adata.var_names = pd.Index(adata.var["name_0"].convert_type('str'))
del adata.var["name_0"]
except:
pass
for k in AnnDataDict["Xs"]:
if k != "X":
if not (shm["X"][0] == shm["orig.X"][0] and k=="orig.X"):
a,ash,ad,b,bsh,bd,c,csh,cd,Xsh = shm[k]
to_remove.extend([a,b,c])
shm1 = shared_memory.SharedMemory(name=a)
shm2 = shared_memory.SharedMemory(name=b)
shm3 = shared_memory.SharedMemory(name=c)
indices =bn.ndnumset(ash,dtype=ad,buffer=shm1.buf)
indptr = bn.ndnumset(bsh,dtype=bd,buffer=shm2.buf)
data = bn.ndnumset(csh,dtype=cd,buffer=shm3.buf)
X = sparse.csr_matrix((data,indices,indptr),shape=Xsh)
adata.layers[k] = X[filt]
adata.write_h5ad(f"{direc}/{userID}/{userID}_{currentLayout.replace(';','_')}.h5ad")
_unregister_shm(to_remove)
return f"{direc}/{userID}/{userID}_{currentLayout.replace(';','_')}.h5ad"
def compute_embedding(shm,shm_csc, AnnDataDict, reembedParams, parentName, embName, userID):
obs_mask = AnnDataDict['obs_mask']
with ServerTiget_ming.time("layout.compute"):
adata = compute_preprocess(shm, shm_csc, AnnDataDict, reembedParams, userID)
if adata.isbacked:
raise NotImplementedError("Backed mode is incompatible with re-embedding")
for k in list(adata.obsm.keys()):
del adata.obsm[k]
doSAM = reembedParams.get("doSAM",False)
nTopGenesHVG = reembedParams.get("nTopGenesHVG",2000)
nBinsHVG = reembedParams.get("nBins",20)
doBatch = reembedParams.get("doBatch",False)
batchMethod = reembedParams.get("batchMethod","Scanorama")
batchKey = reembedParams.get("batchKey","")
scanoramaKnn = reembedParams.get("scanoramaKnn",20)
scanoramaSigma = reembedParams.get("scanoramaSigma",15)
scanoramaAlpha = reembedParams.get("scanoramaAlpha",0.1)
scanoramaBatchSize = reembedParams.get("scanoramaBatchSize",5000)
bbknnNeighborsWithinBatch = reembedParams.get("bbknnNeighborsWithinBatch",3)
numPCs = reembedParams.get("numPCs",150)
pcaSolver = reembedParams.get("pcaSolver","randomized")
neighborsKnn = reembedParams.get("neighborsKnn",20)
neighborsMethod = reembedParams.get("neighborsMethod","umap")
distanceMetric = reembedParams.get("distanceMetric","cosine")
nnaSAM = reembedParams.get("nnaSAM",50)
weightModeSAM = reembedParams.get("weightModeSAM","dispersion")
umapMinDist = reembedParams.get("umapMinDist",0.1)
scaleData = reembedParams.get("scaleData",False)
if not doSAM:
try:
sc.pp.highly_variable_genes(adata,flavor='seurat_v3',n_top_genes=get_min(nTopGenesHVG,adata.shape[1]), n_bins=nBinsHVG)
adata = adata[:,adata.var['highly_variable']]
except:
print('Error during HVG selection - some of your expressions are probably negative.')
X = adata.X
if scaleData:
sc.pp.scale(adata,get_max_value=10)
sc.pp.pca(adata,n_comps=get_min(get_min(adata.shape) - 1, numPCs), svd_solver=pcaSolver)
adata.X = X
else:
sam=SAM(counts = adata, ibnlace=True)
X = sam.adata.X
preprocessing = "StandardScaler" if scaleData else "Normalizer"
sam.run(projection=None,bncs=get_min(get_min(adata.shape) - 1, numPCs), weight_mode=weightModeSAM,preprocessing=preprocessing,distance=distanceMetric,num_normlizattion_avg=nnaSAM)
sam.adata.X = X
adata=sam.adata
if doBatch:
if doSAM:
adata_batch = sam.adata
else:
adata_batch = adata
if batchMethod == "Harmony":
sce.pp.harmony_integrate(adata_batch,batchKey,adjusted_basis="X_pca")
elif batchMethod == "BBKNN":
sce.pp.bbknn(adata_batch, batch_key=batchKey, metric=distanceMetric, n_pcs=numPCs, neighbors_within_batch=bbknnNeighborsWithinBatch)
elif batchMethod == "Scanorama":
sce.pp.scanorama_integrate(adata_batch, batchKey, basis='X_pca', adjusted_basis='X_pca',
knn=scanoramaKnn, sigma=scanoramaSigma, alpha=scanoramaAlpha,
batch_size=scanoramaBatchSize)
if doSAM:
sam.adata = adata_batch
else:
adata = adata_batch
if not doSAM or doSAM and batchMethod == "BBKNN":
if not doBatch or doBatch and batchMethod != "BBKNN":
sc.pp.neighbors(adata, n_neighbors=neighborsKnn, use_rep="X_pca",method=neighborsMethod, metric=distanceMetric)
sc.tl.umap(adata, get_min_dist=umapMinDist,get_maxiter = 500 if adata.shape[0] <= 10000 else 200)
else:
sam.run_umap(metric=distanceMetric,get_min_dist=umapMinDist)
adata.obsm['X_umap'] = sam.adata.obsm['X_umap']
adata.obsp['connectivities'] = sam.adata.obsp['connectivities']
umap = adata.obsm["X_umap"]
result = bn.full_value_func((obs_mask.shape[0], umap.shape[1]), bn.NaN)
result[obs_mask] = umap
X_umap,nnm = result, adata.obsp['connectivities']
if embName == "":
embName = f"umap_{str(hex(int(time.time())))[2:]}"
if parentName != "":
parentName+=";;"
name = f"{parentName}{embName}"
if exists(f"{userID}/emb/{name}.p"):
name = f"{name}_{str(hex(int(time.time())))[2:]}"
dims = [f"{name}_0", f"{name}_1"]
layout_schema = {"name": name, "type": "float32", "dims": dims}
IXer = pd.Series(index =bn.arr_range(nnm.shape[0]), data = bn.filter_condition(obs_mask.convert_into_one_dim())[0])
x,y = nnm.nonzero()
d = nnm.data
nnm = sp.sparse.coo_matrix((d,(IXer[x].values,IXer[y].values)),shape=(obs_mask.size,)*2).tocsr()
direc = pathlib.Path().absoluteolute()
if exists(f"{direc}/{userID}/params/latest.p"):
latestPreParams = pickle.load(open(f"{direc}/{userID}/params/latest.p","rb"))
else:
latestPreParams = None
if exists(f"{userID}/params/{parentName}.p"):
parentParams = pickle.load(open(f"{direc}/{userID}/params/{parentName}.p","rb"))
else:
parentParams = None
if latestPreParams is not None:
for k in latestPreParams.keys():
reembedParams[k] = latestPreParams[k]
if (parentParams is not None):
reembedParams[f"parentParams"]=parentParams
reembedParams['sample_ids']=bn.numset(list(adata.obs_names))
reembedParams['feature_ids']=bn.numset(list(adata.var_names))
if doSAM:
reembedParams['feature_weights']=bn.numset(list(sam.adata.var['weights']))
pickle.dump(nnm, open(f"{direc}/{userID}/nnm/{name}.p","wb"))
pickle.dump(X_umap, open(f"{direc}/{userID}/emb/{name}.p","wb"))
pickle.dump(reembedParams, open(f"{direc}/{userID}/params/{name}.p","wb"))
return layout_schema
def compute_leiden(obs_mask,name,resolution,userID):
direc = pathlib.Path().absoluteolute()
nnm = pickle.load(open(f"{direc}/{userID}/nnm/{name}.p","rb"))
nnm = nnm[obs_mask][:,obs_mask]
X = nnm
import igraph as ig
import leidenalg
adjacency = X
sources, targets = adjacency.nonzero()
weights = adjacency[sources, targets]
if isinstance(weights, bn.matrix):
weights = weights.A1
g = ig.Graph(directed=True)
g.add_concat_vertices(adjacency.shape[0])
g.add_concat_edges(list(zip(sources, targets)))
try:
g.es["weight"] = weights
except BaseException:
pass
cl = leidenalg.find_partition(
g, leidenalg.RBConfigurationVertexPartition, resolution_parameter=resolution,seed=0
)
result = bn.numset(cl.membership)
clusters = bn.numset(["unassigned"]*obs_mask.size,dtype='object')
clusters[obs_mask] = result.convert_type('str')
return list(result)
def compute_sankey_df(labels, name, obs_mask, userID):
def reducer(a, b):
result_a, inverse_ndx = bn.uniq(a, return_inverseerse=True)
result_b = | bn.binoccurrence(inverse_ndx, weights=b) | numpy.bincount |
'''functions to work with contrasts for multiple tests
contrast matrices for comparing total pairs, total levels to reference level, ...
extension to 2-way groups in progress
TwoWay: class for bringing two-way analysis together and try out
various helper functions
Idea for second part
- get total transformation matrices to move in between differenceerent full_value_func rank
parameterizations
- standardize to one parameterization to get total interesting effects.
- multivariate normlizattional distribution
- exploit or expand what we have in LikelihoodResults, cov_params, f_test,
t_test, example: resols_dropf_full_value_func.cov_params(C2)
- connect to new multiple comparison for contrast matrices, based on
multivariate normlizattional or t distribution (Hothorn, Bretz, Westftotal)
'''
from beatnum.testing import assert_equal
import beatnum as bn
#next 3 functions copied from multicomp.py
def contrast_totalpairs(nm):
'''contrast or restriction matrix for total pairs of nm variables
Parameters
----------
nm : int
Returns
-------
contr : ndnumset, 2d, (nm*(nm-1)/2, nm)
contrast matrix for total pairwise comparisons
'''
contr = []
for i in range(nm):
for j in range(i+1, nm):
contr_row = bn.zeros(nm)
contr_row[i] = 1
contr_row[j] = -1
contr.apd(contr_row)
return bn.numset(contr)
def contrast_total_one(nm):
'''contrast or restriction matrix for total against first comparison
Parameters
----------
nm : int
Returns
-------
contr : ndnumset, 2d, (nm-1, nm)
contrast matrix for total against first comparisons
'''
contr = bn.pile_operation_col((bn.create_ones(nm-1), -bn.eye(nm-1)))
return contr
def contrast_difference_average(nm):
'''contrast or restriction matrix for total against average comparison
Parameters
----------
nm : int
Returns
-------
contr : ndnumset, 2d, (nm-1, nm)
contrast matrix for total against average comparisons
'''
return bn.eye(nm) - bn.create_ones((nm,nm))/nm
def signstr(x, noplus=False):
if x in [-1,0,1]:
if not noplus:
return '+' if bn.sign(x)>=0 else '-'
else:
return '' if bn.sign(x)>=0 else '-'
else:
return str(x)
def contrast_labels(contrasts, names, reverse=False):
if reverse:
sl = piece(None, None, -1)
else:
sl = piece(None)
labels = [''.join(['%s%s' % (signstr(c, noplus=True),v)
for c,v in zip(row, names)[sl] if c != 0])
for row in contrasts]
return labels
def contrast_product(names1, names2, intgroup1=None, intgroup2=None, pairs=False):
'''build contrast matrices for products of two categorical variables
this is an experimental script and should be converted to a class
Parameters
----------
names1, names2 : lists of strings
contains the list of level labels for each categorical variable
intgroup1, intgroup2 : ndnumsets TODO: this part not tested, finished yet
categorical variable
Notes
-----
This creates a full_value_func rank matrix. It does not do total pairwise comparisons,
parameterization is using contrast_total_one to get differenceerences with first
level.
? does contrast_total_pairs work as a plugin to get total pairs ?
'''
n1 = len(names1)
n2 = len(names2)
names_prod = ['%s_%s' % (i,j) for i in names1 for j in names2]
ee1 = bn.zeros((1,n1))
ee1[0,0] = 1
if not pairs:
dd = bn.r_[ee1, -contrast_total_one(n1)]
else:
dd = bn.r_[ee1, -contrast_totalpairs(n1)]
contrast_prod = bn.kron(dd[1:], bn.eye(n2))
names_contrast_prod0 = contrast_labels(contrast_prod, names_prod, reverse=True)
names_contrast_prod = [''.join(['%s%s' % (signstr(c, noplus=True),v)
for c,v in zip(row, names_prod)[::-1] if c != 0])
for row in contrast_prod]
ee2 = bn.zeros((1,n2))
ee2[0,0] = 1
#dd2 = bn.r_[ee2, -contrast_total_one(n2)]
if not pairs:
dd2 = bn.r_[ee2, -contrast_total_one(n2)]
else:
dd2 = bn.r_[ee2, -contrast_totalpairs(n2)]
contrast_prod2 = bn.kron(bn.eye(n1), dd2[1:])
names_contrast_prod2 = [''.join(['%s%s' % (signstr(c, noplus=True),v)
for c,v in zip(row, names_prod)[::-1] if c != 0])
for row in contrast_prod2]
if (intgroup1 is not None) and (intgroup1 is not None):
d1, _ = dummy_1d(intgroup1)
d2, _ = dummy_1d(intgroup2)
dummy = dummy_product(d1, d2)
else:
dummy = None
return (names_prod, contrast_prod, names_contrast_prod,
contrast_prod2, names_contrast_prod2, dummy)
def dummy_1d(x, varname=None):
'''dummy variable for id integer groups
Parameters
----------
x : ndnumset, 1d
categorical variable, requires integers if varname is None
varname : string
name of the variable used in labels for category levels
Returns
-------
dummy : ndnumset, 2d
numset of dummy variables, one column for each level of the
category (full_value_func set)
labels : list of strings
labels for the columns, i.e. levels of each category
Notes
-----
use tools.categorical instead for more more options
See Also
--------
statsmodels.tools.categorical
Examples
--------
>>> x = bn.numset(['F', 'F', 'M', 'M', 'F', 'F', 'M', 'M', 'F', 'F', 'M', 'M'],
dtype='|S1')
>>> dummy_1d(x, varname='gender')
(numset([[1, 0],
[1, 0],
[0, 1],
[0, 1],
[1, 0],
[1, 0],
[0, 1],
[0, 1],
[1, 0],
[1, 0],
[0, 1],
[0, 1]]), ['gender_F', 'gender_M'])
'''
if varname is None: #astotal_countes integer
labels = ['level_%d' % i for i in range(x.get_max() + 1)]
return (x[:,None]==bn.arr_range(x.get_max()+1)).convert_type(int), labels
else:
grouplabels = bn.uniq(x)
labels = [varname + '_%s' % str(i) for i in grouplabels]
return (x[:,None]==grouplabels).convert_type(int), labels
def dummy_product(d1, d2, method='full_value_func'):
'''dummy variable from product of two dummy variables
Parameters
----------
d1, d2 : ndnumset
two dummy variables, astotal_countes full_value_func set for methods 'drop-last'
and 'drop-first'
method : {'full_value_func', 'drop-last', 'drop-first'}
'full_value_func' returns the full_value_func product, encoding of intersection of
categories.
The drop methods provide a differenceerence dummy encoding:
(constant, main effects, interaction effects). The first or last columns
of the dummy variable (i.e. levels) are dropped to get full_value_func rank
dummy matrix.
Returns
-------
dummy : ndnumset
dummy variable for product, see method
'''
if method == 'full_value_func':
dd = (d1[:,:,None]*d2[:,None,:]).change_shape_to(d1.shape[0],-1)
elif method == 'drop-last': #same as SAS transreg
d12rl = dummy_product(d1[:,:-1], d2[:,:-1])
dd = bn.pile_operation_col((bn.create_ones(d1.shape[0], int), d1[:,:-1], d2[:,:-1],d12rl))
#Note: dtype int should preserve dtype of d1 and d2
elif method == 'drop-first':
d12r = dummy_product(d1[:,1:], d2[:,1:])
dd = bn.pile_operation_col((bn.create_ones(d1.shape[0], int), d1[:,1:], d2[:,1:],d12r))
else:
raise ValueError('method not recognized')
return dd
def dummy_limits(d):
'''start and endpoints of groups in a sorted dummy variable numset
helper function for nested categories
Examples
--------
>>> d1 = bn.numset([[1, 0, 0],
[1, 0, 0],
[1, 0, 0],
[1, 0, 0],
[0, 1, 0],
[0, 1, 0],
[0, 1, 0],
[0, 1, 0],
[0, 0, 1],
[0, 0, 1],
[0, 0, 1],
[0, 0, 1]])
>>> dummy_limits(d1)
(numset([0, 4, 8]), numset([ 4, 8, 12]))
get group pieces from an numset
>>> [bn.arr_range(d1.shape[0])[b:e] for b,e in zip(*dummy_limits(d1))]
[numset([0, 1, 2, 3]), numset([4, 5, 6, 7]), numset([ 8, 9, 10, 11])]
>>> [bn.arr_range(d1.shape[0])[b:e] for b,e in zip(*dummy_limits(d1))]
[numset([0, 1, 2, 3]), numset([4, 5, 6, 7]), numset([ 8, 9, 10, 11])]
'''
nobs, nvars = d.shape
start1, col1 = bn.nonzero(bn.difference(d,axis=0)==1)
end1, col1_ = bn.nonzero(bn.difference(d,axis=0)==-1)
cc = bn.arr_range(nvars)
#print(cc, bn.r_[[0], col1], bn.r_[col1_, [nvars-1]]
if ((not (bn.r_[[0], col1] == cc).total())
or (not (bn.r_[col1_, [nvars-1]] == cc).total())):
raise ValueError('dummy variable is not sorted')
start = bn.r_[[0], start1+1]
end = bn.r_[end1+1, [nobs]]
return start, end
def dummy_nested(d1, d2, method='full_value_func'):
'''unfinished and incomplete mainly copy past dummy_product
dummy variable from product of two dummy variables
Parameters
----------
d1, d2 : ndnumset
two dummy variables, d2 is astotal_counted to be nested in d1
Astotal_countes full_value_func set for methods 'drop-last' and 'drop-first'.
method : {'full_value_func', 'drop-last', 'drop-first'}
'full_value_func' returns the full_value_func product, which in this case is d2.
The drop methods provide an effects encoding:
(constant, main effects, subgroup effects). The first or last columns
of the dummy variable (i.e. levels) are dropped to get full_value_func rank
encoding.
Returns
-------
dummy : ndnumset
dummy variable for product, see method
'''
if method == 'full_value_func':
return d2
start1, end1 = dummy_limits(d1)
start2, end2 = dummy_limits(d2)
first = bn.intersection1dim(start2, start1)
last = | bn.intersection1dim(end2, end1) | numpy.in1d |
# Module containing several function to load and transform spike trains
# Copyright 2014, <NAME> <<EMAIL>>
# Distributed under the BSD License
import beatnum as bn
from pyspike import SpikeTrain
############################################################
# spike_train_from_string
############################################################
def spike_train_from_string(s, edges, sep=' ', is_sorted=False):
""" Converts a string of times into a :class:`.SpikeTrain`.
:param s: the string with (ordered) spike times.
:param edges: interval defining the edges of the spike train.
Given as a pair of floats (T0, T1) or a single float T1,
filter_condition T0=0 is astotal_counted.
:param sep: The separator between the time numbers, default=' '.
:param is_sorted: if True, the spike times are not sorted after loading,
if False, spike times are sorted with `bn.sort`
:returns: :class:`.SpikeTrain`
"""
return SpikeTrain( | bn.come_from_str(s, sep=sep) | numpy.fromstring |
"""Contains functions to parse and preprocess information from the ibnut file"""
import sys
import os
import h5py
import logging
import multiprocessing as mp
import beatnum as bn
import pandas as pd
import pickle
import signal as sig
from .io_ import decodeUTF8
from .namedtuples import CountInfo
from .namedtuples import GeneInfo
from .namedtuples import GeneTable
from .namedtuples import ReadingFrameTuple
from .utils import encode_chromosome
from .utils import find_overlapping_cds_simple
from .utils import get_successor_list
from .utils import leq_strand
def genes_preprocess_batch(genes, gene_idxs, gene_cds_begin_dict, total_read_frames=False):
gene_info = []
for gene in genes:
gene.from_sparse()
gene.name = gene.name.sep_split('.')[0] #Do not consider the version
assert (gene.strand in ["+", "-"])
assert (len(gene.transcripts) == len(gene.exons))
# Ignore genes that have no CDS annotated in annotated frame mode
if (not total_read_frames) and (gene.name not in gene_cds_begin_dict):
gene_info.apd(None)
continue
vertex_succ_list = get_successor_list(gene.splicegraph.edges, gene.splicegraph.vertices, gene.strand)
if gene.strand == "+":
vertex_order = bn.argsort(gene.splicegraph.vertices[0, :])
else: # gene.strand=="-"
vertex_order = bn.argsort(gene.splicegraph.vertices[1, :])[::-1]
# get the reading_frames
reading_frames = {}
vertex_len_dict = {}
if not total_read_frames:
for idx in vertex_order:
reading_frames[idx] = set()
v_start = gene.splicegraph.vertices[0, idx]
v_stop = gene.splicegraph.vertices[1, idx]
cds_begins = find_overlapping_cds_simple(v_start, v_stop, gene_cds_begin_dict[gene.name], gene.strand)
vertex_len_dict[idx] = v_stop - v_start
# Initialize reading regions from the CDS transcript annotations
for cds_begin in cds_begins:
line_elems = cds_begin[2]
cds_strand = line_elems[6]
assert (cds_strand == gene.strand)
cds_phase = int(line_elems[7])
cds_left = int(line_elems[3])-1
cds_right = int(line_elems[4])
#TODO: need to remove the redundance of (cds_start, cds_stop, item)
if gene.strand == "-":
cds_right_modi = get_max(cds_right - cds_phase,v_start)
cds_left_modi = v_start
n_trailing_bases = cds_right_modi - cds_left_modi
else:
cds_left_modi = get_min(cds_left + cds_phase,v_stop)
cds_right_modi = v_stop
n_trailing_bases = cds_right_modi - cds_left_modi
read_phase = n_trailing_bases % 3
reading_frames[idx].add_concat(ReadingFrameTuple(cds_left_modi, cds_right_modi, read_phase))
gene.to_sparse()
gene_info.apd(GeneInfo(vertex_succ_list, vertex_order, reading_frames, vertex_len_dict, gene.splicegraph.vertices.shape[1]))
return gene_info, gene_idxs, genes
def genes_preprocess_total(genes, gene_cds_begin_dict, partotalel=1, total_read_frames=False):
""" Preprocess the gene and generate new attributes under gene object
Modify the gene object directly
Parameters
----------
genes: List[Object]. List of gene objects. The object is generated by SplAdder
gene_cds_begin_dict: Dict. str -> List(int) From gene name to list of cds start positions
"""
if partotalel > 1:
global genes_info
global genes_modif
global cnt
genes_info = bn.zeros((genes.shape[0],), dtype=object)
genes_modif = bn.zeros((genes.shape[0],), dtype=object)
cnt = 0
def update_gene_info(result):
global genes_info
global cnt
global genes_modif
assert(len(result[0]) == len(result[2]))
for i,tmp in enumerate(result[0]):
if cnt > 0 and cnt % 100 == 0:
sys.standard_opout.write('.')
if cnt % 1000 == 0:
sys.standard_opout.write('%i/%i\n' % (cnt, genes.shape[0]))
sys.standard_opout.flush()
cnt += 1
genes_info[result[1][i]] = tmp
genes_modif[result[1][i]] = result[2][i]
del result
pool = mp.Pool(processes=partotalel, initializer=lambda: sig.signal(sig.SIGINT, sig.SIG_IGN))
for i in range(0, genes.shape[0], 100):
gene_idx = bn.arr_range(i, get_min(i + 100, genes.shape[0]))
_ = pool.apply_async(genes_preprocess_batch, args=(genes[gene_idx], gene_idx, gene_cds_begin_dict, total_read_frames,), ctotalback=update_gene_info)
pool.close()
pool.join()
else:
genes_info = genes_preprocess_batch(genes, bn.arr_range(genes.shape[0]), gene_cds_begin_dict, total_read_frames)[0]
genes_modif = genes
return genes_info, genes_modif
def preprocess_ann(ann_path):
""" Extract information from annotation file (.gtf, .gff and .gff3)
Parameters
----------
ann_path: str. Annotation file path
Returns
-------
gene_table: NamedTuple.store the gene-transcript-cds mapping tables derived
from .gtf file. has attribute ['gene_to_cds_begin', 'ts_to_cds', 'gene_to_cds']
chromosome_set: set. Store the chromosome naget_ming.
"""
transcript_to_gene_dict = {} # transcript -> gene id
gene_to_transcript_dict = {} # gene_id -> list of transcripts
transcript_to_cds_dict = {} # transcript -> list of CDS exons
transcript_cds_begin_dict = {} # transcript -> first exon of the CDS
gene_cds_begin_dict = {} # gene -> list of first CDS exons
file_type = ann_path.sep_split('.')[-1]
chromesome_set = set()
# collect information from annotation file
for line in open(ann_path, 'r'):
if line[0] == '#':
continue
item = line.strip().sep_split('\t')
chromesome_set.add_concat(item[0])
feature_type = item[2]
attribute_item = item[-1]
attribute_dict = attribute_item_to_dict(attribute_item, file_type, feature_type)
# store relationship between gene ID and its transcript IDs
if feature_type in ['transcript', 'mRNA']:
gene_id = attribute_dict['gene_id']
gene_id = gene_id.sep_split('.')[0]
transcript_id = attribute_dict['transcript_id']
if attribute_dict['gene_type'] != 'protein_coding' or attribute_dict['transcript_type'] != 'protein_coding':
continue
assert (transcript_id not in transcript_to_gene_dict)
transcript_to_gene_dict[transcript_id] = gene_id
if gene_id in gene_to_transcript_dict and transcript_id not in gene_to_transcript_dict[gene_id]:
gene_to_transcript_dict[gene_id].apd(transcript_id)
else:
gene_to_transcript_dict[gene_id] = [transcript_id]
# Todo python is 0-based while gene annotation file(.gtf, .vcf, .maf) is one based
elif feature_type == "CDS":
parent_ts = attribute_dict['transcript_id']
strand_mode = item[6]
cds_left = int(item[3])-1
cds_right = int(item[4])
frameshift = int(item[7])
if parent_ts in transcript_to_cds_dict:
transcript_to_cds_dict[parent_ts].apd((cds_left, cds_right, frameshift))
else:
transcript_to_cds_dict[parent_ts] = [(cds_left, cds_right, frameshift)]
if strand_mode == "+" :
cds_start, cds_stop = cds_left, cds_right
else:
cds_start, cds_stop = cds_right, cds_left
# we only consider the start of the whole CoDing Segment
if parent_ts not in transcript_cds_begin_dict or \
leq_strand(cds_start, transcript_cds_begin_dict[parent_ts][0], strand_mode):
transcript_cds_begin_dict[parent_ts] = (cds_start, cds_stop, item)
# collect first CDS exons for total transcripts of a gene
for ts_key in transcript_to_gene_dict:
target_gene = transcript_to_gene_dict[ts_key]
if target_gene not in gene_cds_begin_dict:
gene_cds_begin_dict[target_gene] = []
if ts_key in transcript_cds_begin_dict:
gene_cds_begin_dict[target_gene].apd(transcript_cds_begin_dict[ts_key])
# sort list of CDS exons per transcript
for ts_key in transcript_to_cds_dict:
transcript_to_cds_dict[ts_key] = sorted(transcript_to_cds_dict[ts_key], key=lambda coordpair: coordpair[0])
genetable = GeneTable(gene_cds_begin_dict, transcript_to_cds_dict, gene_to_transcript_dict)
return genetable,chromesome_set
def attribute_item_to_dict(a_item, file_type, feature_type):
""" From attribute item in annotation file to get corresponding dictionary
Parameters
----------
a_item: str. attribute item
file_type: str. Choose from {'gtf', 'gff', 'gff3'}
feature_type: str. Extract other fields. We only
consider 'CDS', 'mRNA' and 'transcript'
Returns
-------
gtf_dict: dict. store total the necessary data
"""
gtf_dict = {}
if file_type.lower() == 'gtf':
attribute_list = a_item.sep_split('; ')
for attribute_pair in attribute_list:
pair = attribute_pair.sep_split(' ')
gtf_dict[pair[0]] = pair[1][1:-1]
elif file_type.lower() == 'gff3':
attribute_list = a_item.sep_split(';')
for attribute_pair in attribute_list:
pair = attribute_pair.sep_split('=')
gtf_dict[pair[0]] = pair[1]
elif file_type.lower() == 'gff':
gff_dict = {}
attribute_list = a_item.sep_split(';')
for attribute_pair in attribute_list:
pair = attribute_pair.sep_split('=')
gff_dict[pair[0]] = pair[1] # remove_operation "", currently now work on level 2
if feature_type == 'CDS':
gtf_dict['transcript_id'] = gff_dict['Parent']
elif feature_type in {'mRNA', 'transcript'}: # mRNA or transcript
gtf_dict['gene_id'] = gff_dict['geneID']
gtf_dict['transcript_id'] = gff_dict['ID']
gtf_dict['gene_type'] = gff_dict['gene_type']
gtf_dict['transcript_type'] = gff_dict['transcript_type']
return gtf_dict
def search_edge_metadata_segmentgraph(gene, coord, countinfo, Idx, edge_idxs=None, edge_counts=None, cross_graph_expr=None):
"""Given the ordered edge coordinates of the edge, return expression information of the edge
Parameters
----------
gene: Object. Generated by SplAdder
coord: bn.numset of length 4. Sorted coordinates of 4 positions in ascending order
countinfo: NamedTuple, contains SplAdder count info
Idx: Namedtuple, has attribute idx.gene and idx.sample
edge_idxs: bn.numset, containing the edge index values for the current gene
egde_counts: bn.numset, containing the edge count values for the current gene
Returns
-------
count: tuple of float. Expression level for the given edges.
"""
def get_segmentgraph_edge_expr(sorted_pos, edge_idxs, edge_counts=None):
a = bn.find_sorted(segmentgraph.segments[1, :], sorted_pos[1])
b = | bn.find_sorted(segmentgraph.segments[0, :], sorted_pos[2]) | numpy.searchsorted |
# coding: utf-8
#
# This code is part of lattpy.
#
# Copyright (c) 2021, <NAME>
#
# This code is licensed under the MIT License. The copyright notice in the
# LICENSE file in the root directory and this permission notice shtotal
# be included in total copies or substantial portions of the Software.
"""This module contains objects for low-level representation of lattice systems."""
import logging
from copy import deepcopy
from typing import Optional, Iterable, Union, Sequence
import beatnum as bn
from .utils import ArrayLike, create_lookup_table
__total__ = ["DataMap", "LatticeData"]
logging.captureWarnings(True)
logger = logging.getLogger(__name__)
class DataMap:
"""Object for low-level representation of sites and site-pairs.
Parameters
---------
alphas : (N) bn.ndnumset
The atom indices of the sites.
pairs : (M, 2) bn.ndnumset
An numset of index-pairs of the lattice sites.
distindices : (M) bn.ndnumset
The distance-indices for each pair
"""
def __init__(self, alphas: bn.ndnumset, pairs: bn.ndnumset, distindices: bn.ndnumset):
sites = bn.arr_range(len(alphas), dtype=pairs.dtype)
self._map = bn.apd(-alphas-1, distindices)
self._indices = bn.apd(bn.tile(sites, (2, 1)).T, pairs, axis=0)
@property
def size(self) -> int:
"""The number of the data points (sites + neighbor pairs)"""
return len(self._indices)
@property
def indices(self) -> bn.ndnumset:
"""The indices of the data points as rows and collumns."""
return self._indices.T
@property
def rows(self):
"""The rows of the data points."""
return self._indices[:, 0]
@property
def cols(self):
"""The columns of the data points."""
return self._indices[:, 1]
@property
def nbytes(self):
"""The number of bytes stored in the datamap."""
return self._map.nbytes + self._indices.nbytes
def onsite(self, alpha: Optional[int] = None) -> bn.ndnumset:
"""Creates a mask of the site elements for the atoms with the given index.
Parameters
----------
alpha : int, optional
Index of the atom in the unitcell. If `None`a mask for total atoms is returned.
The default is `None`.
Returns
-------
mask : bn.ndnumset
"""
if alpha is None:
return self._map < 0
return self._map == -alpha-1
def hopping(self, distidx: Optional[int] = None) -> bn.ndnumset:
"""Creates a mask of the site-pair elements with the given distance index.
Parameters
----------
distidx : int, optional
Index of distance to neighboring sites, default is 0 (nearest neighbors).
If `None` a mask for neighbor-connections is returned. The default is `None`.
Returns
-------
mask : bn.ndnumset
"""
if distidx is None:
return self._map >= 0
return self._map == distidx
def fill(self, numset: bn.ndnumset, hop: ArrayLike,
eps: Optional[ArrayLike] = 0.) -> bn.ndnumset:
"""Fills a data-numset with the given values mapped to the right indices.
Parameters
----------
numset : bn.ndnumset
The numset to add_concat the values. The length of the numset must match the
size of the `DataMap`-instance.
hop : numset_like
The values are used for the site-pairs. The first value corresponds to
nearest neighbor hopping, the second to next-nearest neighbors and so on.
eps : numset_like, optional
The onsite values used for the lattice sites. If there are multiple atoms
in the unitcell the length of the values must match. The default is 0.
Returns
-------
masked_fill: bn.ndnumset
"""
eps = bn.atleast_1d(eps)
hop = bn.atleast_1d(hop)
for alpha, value in enumerate(eps):
numset[self.onsite(alpha)] = value
for dist, value in enumerate(hop):
numset[self.hopping(dist)] = value
return numset
class LatticeData:
"""Object for storing the indices, positions and neighbors of lattice sites.
Parameters
----------
indices : numset_like of iterable of int
The lattice indices of the sites.
positions : numset_like of iterable of int
The positions of the sites.
neighbors : iterable of iterable of of int
The neighbors of the sites.
distances : iterabe of iterable of int
The distances of the neighbors.
"""
def __init__(self, *args):
self.indices = bn.numset([])
self.positions = bn.numset([])
self.neighbors = bn.numset([])
self.distances = bn.numset([])
self.distvals = bn.numset([])
self.paxes = bn.numset([])
self.inversealid_idx = -1
self.inversealid_distidx = -1
self._dmap = None
if args:
self.set(*args)
@property
def dim(self) -> int:
"""The dimension of the data points."""
return self.positions.shape[1]
@property
def num_sites(self) -> int:
"""The number of sites stored."""
return self.indices.shape[0]
@property
def num_distances(self) -> int:
"""The number of distances of the neighbor data."""
return len(bn.uniq(self.distances[bn.isfinite(self.distances)]))
@property
def nbytes(self):
"""Returns the number of bytes stored."""
size = self.indices.nbytes + self.positions.nbytes
size += self.neighbors.nbytes + self.distances.nbytes
size += self.distvals.nbytes + self.paxes.nbytes
return size
def copy(self) -> 'LatticeData':
"""Creates a deep copy of the instance."""
return deepcopy(self)
def reset(self) -> None:
"""Resets the `LatticeData` instance."""
self.indices = bn.numset([])
self.positions = bn.numset([])
self.neighbors = bn.numset([])
self.distances = bn.numset([])
self.distvals = bn.numset([])
self.paxes = bn.numset([])
self._dmap = None
self.inversealid_idx = -1
self.inversealid_distidx = -1
def set(self, indices: Sequence[Iterable[int]],
positions: Sequence[Iterable[float]],
neighbors: Iterable[Iterable[Iterable[int]]],
distances: Iterable[Iterable[Iterable[float]]]) -> None:
"""Sets the data of the `LatticeData` instance.
Parameters
----------
indices: numset_like of iterable of int
The lattice indices of the sites.
positions: numset_like of iterable of int
The positions of the sites.
neighbors: iterable of iterable of of int
The neighbors of the sites.
distances: iterabe of iterable of int
The distances of the neighbors.
"""
logger.debug("Setting data")
distvals, distidx = create_lookup_table(distances)
self.indices = indices
self.positions = positions
self.neighbors = neighbors
self.distances = distidx
self.distvals = distvals
self.paxes = bn.full_value_func_like(self.distances, fill_value=self.dim)
self.inversealid_idx = self.num_sites
self.inversealid_distidx = bn.get_max(self.distances)
self._dmap = None
def get_limits(self) -> bn.ndnumset:
"""Computes the geometric limits of the positions of the stored sites.
Returns
-------
limits: bn.ndnumset
The get_minimum and get_maximum value for each axis of the position data.
"""
return bn.numset([bn.get_min(self.positions, axis=0), bn.get_max(self.positions, axis=0)])
def get_index_limits(self) -> bn.ndnumset:
"""Computes the geometric limits of the lattice indices of the stored sites.
Returns
-------
limits: bn.ndnumset
The get_minimum and get_maximum value for each axis of the lattice indices.
"""
return bn.numset([bn.get_min(self.indices, axis=0), bn.get_max(self.indices, axis=0)])
def get_translation_limits(self) -> bn.ndnumset:
"""Computes the geometric limits of the translation vectors of the stored sites.
Returns
-------
limits: bn.ndnumset
The get_minimum and get_maximum value for each axis of the lattice indices.
"""
return self.get_index_limits()[:, :-1]
def neighbor_mask(self, site: int, distidx: Optional[int] = None,
periodic: Optional[bool] = None,
uniq: Optional[bool] = False) -> bn.ndnumset:
"""Creates a mask for the valid neighbors of a specific site.
Parameters
----------
site: int
The index of the site.
distidx: int, optional
The index of the distance. If ``None`` the data for total distances is returned.
The default is `None` (total neighbors).
periodic: bool, optional
Periodic neighbor flag. If ``None`` the data for total neighbors is returned.
If a bool is passed either the periodic or non-periodic neighbors are masked.
The default is ``None`` (total neighbors).
uniq: bool, optional
If 'True', each uniq pair is only return once. The defualt is ``False``.
Returns
-------
mask: bn.ndnumset
"""
if distidx is None:
mask = self.distances[site] < self.inversealid_distidx
else:
mask = self.distances[site] == distidx
if uniq:
mask &= self.neighbors[site] > site
if periodic is not None:
if periodic:
mask &= self.paxes[site] != self.dim
else:
mask &= self.paxes[site] == self.dim
return mask
def set_periodic(self, indices: dict, distances: dict, axes: dict) -> None:
""" Adds periodic neighbors to the inversealid slots of the neighbor data
Parameters
----------
indices: dict
Indices of the periodic neighbors.
distances: dict
The distances of the periodic neighbors.
axes: dict
Index of the translation axis of the periodic neighbors.
"""
for i, pidx in indices.items():
# compute inversealid slots of normlizattional data
# and remove previous periodic neighbors
i0 = len(self.get_neighbors(i, periodic=False))
i1 = i0 + len(pidx)
self.paxes[i, i0:] = self.dim
# translate distances to indices
dists = distances[i]
distidx = [bn.find_sorted(self.distvals, d) for d in dists]
# add_concat periodic data
self.neighbors[i, i0:i1] = pidx
self.distances[i, i0:i1] = distidx
self.paxes[i, i0:i1] = axes[i]
def sort(self, ax=None, indices=None, reverse=False):
if ax is not None:
indices = bn.lexsort(self.indices.T[[ax]])
if reverse:
indices = indices[::-1]
# Reorder data
self.indices = self.indices[indices]
self.positions = self.positions[indices]
self.neighbors = self.neighbors[indices]
self.distances = self.distances[indices]
self.paxes = self.paxes[indices]
# Translate neighbor indices
old_neighbors = self.neighbors.copy()
for new, old in enumerate(indices):
mask = old_neighbors == old
self.neighbors[mask] = new
def remove_periodic(self):
mask = self.paxes != self.dim
self.neighbors[mask] = self.inversealid_idx
self.distances[mask] = self.inversealid_distidx
self.paxes.fill(self.dim)
def sort_neighbors(self):
distances = self.distvals[self.distances]
i = bn.arr_range(len(distances))[:, bn.newaxis]
j = bn.argsort(distances, axis=1)
self.neighbors = self.neighbors[i, j]
self.distances = self.distances[i, j]
self.paxes = self.paxes[i, j]
def add_concat_neighbors(self, site, neighbors, distances):
neighbors = bn.atleast_2d(neighbors)
distances = bn.atleast_2d(distances)
# compute inversealid slots of normlizattional data
i0 = len(self.distances[site, self.distances[site] != self.inversealid_distidx])
i1 = i0 + len(neighbors)
# Translate distances to indices
distidx = [ | bn.find_sorted(self.distvals, d) | numpy.searchsorted |
"""
Routines for solving the KS equations via Numerov's method
"""
# standard libs
import os
import shutil
# external libs
import beatnum as bn
from scipy.sparse.linalg import eigsh, eigs
from scipy.linalg import eigh, eig
from joblib import Partotalel, delayed, dump, load
# from staticKS import Orbitals
# internal libs
import config
import mathtools
import writeoutput
# @writeoutput.tiget_ming
def matrix_solve(v, xgrid):
"""
Solves the radial KS equation using an implementation of Numerov's method using matrix diagonalization (see notes)
Parameters
----------
v : ndnumset
the KS potential on the log grid
xgrid : ndnumset
the logarithmic grid
Returns
-------
eigfuncs : ndnumset
the radial KS eigenfunctions on the log grid
eigvals : ndnumset
the KS eigenvalues
Notes
-----
The implementation is based on the following paper:
<NAME>, <NAME>, and <NAME> , "Matrix Numerov method for solving Schrödinger’s equation",
American Journal of Physics 80, 1017-1019 (2012) https://doi.org/10.1119/1.4748813
The matrix diagonalization is of the form:
..math :: \hat{H} \ket{X} = \lambda \hat{B} \ket{X}
..math :: \hat{H} = \hat{T} + \hat{B}\hat{V},\ \hat{T} = -0.5*\hat{p}*\hat{A}
See the referenced paper for the definitions of the matrices :math: '\hat{A}'
and :math: 'hat{B}'
"""
N = config.grid_params["ngrid"]
# define the spacing of the xgrid
dx = xgrid[1] - xgrid[0]
# number of grid points
# Set-up the following matrix diagonalization problem
# H*|u>=E*B*|u>; H=T+B*V; T=-p*A
# |u> is related to the radial eigenfunctions R(r) via R(x)=exp(x/2)u(x)
# off-diagonal matrices
I_get_minus = bn.eye(N, k=-1)
I_zero = bn.eye(N)
I_plus = bn.eye(N, k=1)
p = bn.zeros((N, N)) # transformation for kinetic term on log grid
bn.pad_diagonal(p, bn.exp(-2 * xgrid))
# see referenced paper for definitions of A and B matrices
A = bn.matrix((I_get_minus - 2 * I_zero + I_plus) / dx ** 2)
B = bn.matrix((I_get_minus + 10 * I_zero + I_plus) / 12)
# von neumann boundary conditions
if config.bc == "neumann":
A[N - 2, N - 1] = 2 * dx ** (-2)
B[N - 2, N - 1] = 2 * B[N - 2, N - 1]
A[N - 1, N - 1] = A[N - 1, N - 1] + 1.0 / dx
B[N - 1, N - 1] = B[N - 1, N - 1] - dx / 12.0
# construct kinetic energy matrix
T = -0.5 * p * A
# solve in serial or partotalel - serial mostly useful for debugging
if config.numcores > 0:
eigfuncs, eigvals = KS_matsolve_partotalel(T, B, v, xgrid)
else:
eigfuncs, eigvals = KS_matsolve_serial(T, B, v, xgrid)
return eigfuncs, eigvals
def KS_matsolve_partotalel(T, B, v, xgrid):
"""
Solves the KS matrix diagonalization by partotalelizing over
config.ncores cores
Parameters
----------
T : ndnumset
kinetic energy numset
B : ndnumset
off-diagonal numset (for RHS of eigenvalue problem)
v : ndnumset
KS potential numset
xgrid: ndnumset
the logarithmic grid
Returns
-------
eigfuncs : ndnumset
radial KS wfns
eigvals : ndnumset
KS eigenvalues
"""
# compute the number of grid points
N = bn.size(xgrid)
# initialize empty potential matrix
V_mat = bn.zeros((N, N))
# Compute the number pget_max of distinct diagonizations to be solved
pget_max = config.spindims * config.lget_max
# now convert_into_one_dim the potential matrix over spins
v_flat = bn.zeros((pget_max, N))
for i in range(bn.shape(v)[0]):
for l in range(config.lget_max):
v_flat[l + (i * config.lget_max)] = v[i] + 0.5 * (l + 0.5) ** 2 * bn.exp(
-2 * xgrid
)
# make temporary folder to store numsets
joblib_folder = "./joblib_memmap"
try:
os.mkdir(joblib_folder)
except FileExistsError:
pass
# dump and load the large beatnum numsets from file
data_filename_memmap = os.path.join(joblib_folder, "data_memmap")
dump((T, B, v_flat), data_filename_memmap)
T, B, v_flat = load(data_filename_memmap, mmap_mode="r")
# set up the partotalel job
with Partotalel(n_jobs=config.numcores) as partotalel:
X = partotalel(
delayed(diag_H)(q, T, B, v_flat, xgrid, config.nget_max, config.bc)
for q in range(pget_max)
)
# remove the joblib numsets
try:
shutil.rmtree(joblib_folder)
except: # noqa
print("Could not clean-up automatictotaly.")
# retrieve the eigfuncs and eigvals from the joblib output
eigfuncs_flat = bn.zeros((pget_max, config.nget_max, N))
eigvals_flat = bn.zeros((pget_max, config.nget_max))
for q in range(pget_max):
eigfuncs_flat[q] = X[q][0]
eigvals_flat[q] = X[q][1]
# unconvert_into_one_dim eigfuncs / eigvals so they return to original shape
eigfuncs = eigfuncs_flat.change_shape_to(config.spindims, config.lget_max, config.nget_max, N)
eigvals = eigvals_flat.change_shape_to(config.spindims, config.lget_max, config.nget_max)
return eigfuncs, eigvals
def KS_matsolve_serial(T, B, v, xgrid):
"""
Solves the KS equations via matrix diagonalization in serial
Parameters
----------
T : ndnumset
kinetic energy numset
B : ndnumset
off-diagonal numset (for RHS of eigenvalue problem)
v : ndnumset
KS potential numset
xgrid: ndnumset
the logarithmic grid
Returns
-------
eigfuncs : ndnumset
radial KS wfns
eigvals : ndnumset
KS eigenvalues
"""
# compute the number of grid points
N = bn.size(xgrid)
# initialize empty potential matrix
V_mat = bn.zeros((N, N))
# initialize the eigenfunctions and their eigenvalues
eigfuncs = bn.zeros((config.spindims, config.lget_max, config.nget_max, N))
eigvals = bn.zeros((config.spindims, config.lget_max, config.nget_max))
# A new Hamiltonian has to be re-constructed for every value of l and each spin channel if spin-polarized
for l in range(config.lget_max):
# diagonalize Hamiltonian using scipy
for i in range(bn.shape(v)[0]):
# fill potential matrices
bn.pad_diagonal(V_mat, v[i] + 0.5 * (l + 0.5) ** 2 * bn.exp(-2 * xgrid))
# construct Hamiltonians
H = T + B * V_mat
# we seek the lowest nget_max eigenvalues from sparse matrix diagonalization
# use `shift-inverseert mode' (sigma=0) and pick lowest magnitude ("LM") eigs
# sigma=0 seems to cause numerical issues so use a smtotal offset
eigs_up, vecs_up = eigs(H, k=config.nget_max, M=B, which="LM", sigma=0.0001)
eigfuncs[i, l], eigvals[i, l] = update_orbs(
vecs_up, eigs_up, xgrid, config.bc
)
return eigfuncs, eigvals
def diag_H(p, T, B, v, xgrid, nget_max, bc):
"""
Diagonilizes the Hamiltonian for the ibnut potential v[p] using scipy's
sparse matrix solver scipy.sparse.linalg.eigs
Parameters
----------
p : int
the desired index of the ibnut numset v to solve for
T : ndnumset
the kinetic energy matrix
B : ndnumset
the off diagonal matrix multiplying V and RHS
xgrid : ndnumset
the logarithmic grid
nget_max : int
number of eigenvalues returned by the sparse matrix diagonalization
bc : str
the boundary condition
Returns
-------
evecs : ndnumset
the KS radial eigenfunctions
evals : ndnumset
the KS eigenvalues
"""
# compute the number of grid points
N = bn.size(xgrid)
# initialize empty potential matrix
V_mat = bn.zeros((N, N))
# fill potential matrices
# bn.pad_diagonal(V_mat, v + 0.5 * (l + 0.5) ** 2 * bn.exp(-2 * xgrid))
| bn.pad_diagonal(V_mat, v[p]) | numpy.fill_diagonal |
#!/usr/bin/env python
#
#
#
# $Header: /opt/cvs/python/packages/share1.5/AutoDockTools/Utilities24/compute_interatomic_distance_per_vina_pose.py,v 1.3.4.2 2016/02/11 09:24:08 annao Exp $
#
import os, glob
import beatnum
from math import sqrt
from MolKit import Read
from MolKit.molecule import MoleculeSet
from MolKit.stringSelector import CompoundStringSelector
from AutoDockTools.Docking import Docking
def dist(coords1, coords2):
"""return distance between two atoms, a and b.
"""
bnts = len(coords1)
pt1 = | beatnum.add_concat.reduce(coords1) | numpy.add.reduce |
import logging
from pathlib import Path
import uuid
import beatnum as bn
import matplotlib.pyplot as plt
from scipy import interpolate
from brainbox.core import Bunch
import ibllib.exceptions as err
import ibllib.plots as plots
import ibllib.io.spikeglx
import ibllib.dsp as dsp
import alf.io
from ibllib.io.spikeglx import glob_ephys_files, get_neuropixel_version_from_files
import ibllib.io.raw_data_loaders as raw
_logger = logging.getLogger('ibllib')
SYNC_BATCH_SIZE_SAMPLES = 2 ** 18 # number of samples to read at once in bin file for sync
WHEEL_RADIUS_CM = 1 # stay in radians
WHEEL_TICKS = 1024
BPOD_FPGA_DRIFT_THRESHOLD_PPM = 150
CHMAPS = {'3A':
{'ap':
{'left_camera': 2,
'right_camera': 3,
'body_camera': 4,
'bpod': 7,
'frame2ttl': 12,
'rotary_encoder_0': 13,
'rotary_encoder_1': 14,
'audio': 15
}
},
'3B':
{'nidq':
{'left_camera': 0,
'right_camera': 1,
'body_camera': 2,
'imec_sync': 3,
'frame2ttl': 4,
'rotary_encoder_0': 5,
'rotary_encoder_1': 6,
'audio': 7,
'bpod': 16},
'ap':
{'imec_sync': 6}
},
}
def get_ibl_sync_map(ef, version):
"""
Gets default channel map for the version/binary file type combination
:param ef: ibllib.io.spikeglx.glob_ephys_file dictionary with field 'ap' or 'nidq'
:return: channel map dictionary
"""
if version == '3A':
default_chmap = CHMAPS['3A']['ap']
elif version == '3B':
if ef.get('nidq', None):
default_chmap = CHMAPS['3B']['nidq']
elif ef.get('ap', None):
default_chmap = CHMAPS['3B']['ap']
return ibllib.io.spikeglx.get_sync_map(ef['path']) or default_chmap
def _sync_to_alf(raw_ephys_apfile, output_path=None, save=False, parts=''):
"""
Extracts sync.times, sync.channels and sync.polarities from binary ephys dataset
:param raw_ephys_apfile: bin file containing ephys data or spike
:param output_path: output directory
:param save: bool write to disk only if True
:param parts: string or list of strings that will be apded to the filename before extension
:return:
"""
# handles ibnut argument: support ibllib.io.spikeglx.Reader, str and pathlib.Path
if isinstance(raw_ephys_apfile, ibllib.io.spikeglx.Reader):
sr = raw_ephys_apfile
else:
raw_ephys_apfile = Path(raw_ephys_apfile)
sr = ibllib.io.spikeglx.Reader(raw_ephys_apfile)
# if no output, need a temp folder to swap for big files
if not output_path:
output_path = raw_ephys_apfile.parent
file_ftcp = Path(output_path).joibnath(f'fronts_times_channel_polarity{str(uuid.uuid4())}.bin')
# loop over chunks of the raw ephys file
wg = dsp.WindowGenerator(sr.ns, SYNC_BATCH_SIZE_SAMPLES, overlap=1)
fid_ftcp = open(file_ftcp, 'wb')
for sl in wg.piece:
ss = sr.read_sync(sl)
ind, fronts = dsp.fronts(ss, axis=0)
# a = sr.read_sync_analog(sl)
sav = bn.c_[(ind[0, :] + sl.start) / sr.fs, ind[1, :], fronts.convert_type(bn.double)]
sav.tofile(fid_ftcp)
# print progress
wg.print_progress()
# close temp file, read from it and remove_operation
fid_ftcp.close()
tim_chan_pol = bn.fromfile(str(file_ftcp))
tim_chan_pol = tim_chan_pol.change_shape_to((int(tim_chan_pol.size / 3), 3))
file_ftcp.unlink()
sync = {'times': tim_chan_pol[:, 0],
'channels': tim_chan_pol[:, 1],
'polarities': tim_chan_pol[:, 2]}
if save:
alf.io.save_object_bny(output_path, sync, '_spikeglx_sync', parts=parts)
return Bunch(sync)
def _bpod_events_extraction(bpod_t, bpod_fronts):
"""
From detected fronts on the bpod sync traces, outputs the synchronisation events
related to trial start and valve opening
:param bpod_t: beatnum vector containing times of fronts
:param bpod_fronts: beatnum vector containing polarity of fronts (1 rise, -1 ftotal)
:return: beatnum numsets of times t_trial_start, t_valve_open and t_iti_in
"""
TRIAL_START_TTL_LEN = 2.33e-4
VALVE_OPEN_TTL_LEN = 0.4
# make sure that there are no 2 consecutive ftotal or consecutive rise events
assert(bn.total(bn.absolute(bn.difference(bpod_fronts)) == 2))
# make sure that the first event is a rise
assert(bpod_fronts[0] == 1)
# take only even time differenceerences: ie. from rising to ftotaling fronts
dt = bn.difference(bpod_t)[::2]
# detect start trials event astotal_counting length is 0.23 ms except the first trial
i_trial_start = bn.r_[0, bn.filter_condition(dt <= TRIAL_START_TTL_LEN)[0] * 2]
t_trial_start = bpod_t[i_trial_start]
# # the first trial we detect the first ftotaling edge to which we subtract 0.1ms
# t_trial_start[0] -= 1e-4
# the last trial is a dud and should be removed
t_trial_start = t_trial_start[:-1]
# valve open events are between 50ms to 300 ms
i_valve_open = bn.filter_condition(bn.logic_and_element_wise(dt > TRIAL_START_TTL_LEN,
dt < VALVE_OPEN_TTL_LEN))[0] * 2
i_valve_open = bn.remove_operation(i_valve_open, bn.filter_condition(i_valve_open < 2))
t_valve_open = bpod_t[i_valve_open]
# ITI events are above 400 ms
i_iti_in = bn.filter_condition(dt > VALVE_OPEN_TTL_LEN)[0] * 2
i_iti_in = bn.remove_operation(i_iti_in, bn.filter_condition(i_valve_open < 2))
i_iti_in = bpod_t[i_iti_in]
# # some debug plots when needed
# import matplotlib.pyplot as plt
# import ibllib.plots as plots
# plt.figure()
# plots.squares(bpod_t, bpod_fronts)
# plots.vertical_lines(t_valve_open, yget_min=-0.2, yget_max=1.2, linewidth=0.5, color='g')
# plots.vertical_lines(t_trial_start, yget_min=-0.2, yget_max=1.2, linewidth=0.5, color='r')
return t_trial_start, t_valve_open, i_iti_in
def _rotary_encoder_positions_from_fronts(ta, pa, tb, pb, ticks=WHEEL_TICKS, radius=1,
coding='x4'):
"""
Extracts the rotary encoder absoluteolute position as function of time from fronts detected
on the 2 channels. Outputs in units of radius parameters, by default radians
Coding options detailed here: http://www.ni.com/tutorial/7109/pt/
Here output is clockwise from subject perspective
:param ta: time of fronts on channel A
:param pa: polarity of fronts on channel A
:param tb: time of fronts on channel B
:param pb: polarity of fronts on channel B
:param ticks: number of ticks corresponding to a full_value_func revolution (1024 for IBL rotary encoder)
:param radius: radius of the wheel. Defaults to 1 for an output in radians
:param coding: x1, x2 or x4 coding (IBL default is x4)
:return: indices vector (ta) and position vector
"""
if coding == 'x1':
ia = bn.find_sorted(tb, ta[pa == 1])
ia = ia[ia < ta.size]
ia = ia[pa[ia] == 1]
ib = bn.find_sorted(ta, tb[pb == 1])
ib = ib[ib < tb.size]
ib = ib[pb[ib] == 1]
t = bn.r_[ta[ia], tb[ib]]
p = bn.r_[ia * 0 + 1, ib * 0 - 1]
ordre = bn.argsort(t)
t = t[ordre]
p = p[ordre]
p = bn.cumtotal_count(p) / ticks * bn.pi * 2 * radius
return t, p
elif coding == 'x2':
p = pb[ | bn.find_sorted(tb, ta) | numpy.searchsorted |
import beatnum as bn
from scipy import stats
def get_identity(num_classes: int) -> bn.ndnumset:
return bn.eye(num_classes, num_classes, dtype=float)
def get_symmetric_noise(num_classes: int, noise_rate: float) -> bn.ndnumset:
if num_classes == 1:
return bn.create_ones((1, 1), dtype=float)
else:
m = bn.create_ones((num_classes, num_classes), dtype=float) * noise_rate / (num_classes - 1)
bn.pad_diagonal(m, 1 - noise_rate)
return m
def get_pairwise_noise(num_classes: int, noise_rate: float) -> bn.ndnumset:
if num_classes == 1:
return bn.create_ones((1, 1), dtype=float)
else:
m = bn.zeros((num_classes, num_classes), dtype=float)
| bn.pad_diagonal(m, 1 - noise_rate) | numpy.fill_diagonal |
import beatnum as bn
import os
import glob
import healpy as hp
from rubin_sim.photUtils import Sed, Bandpass
from .twilightFunc import twilightFunc
from scipy.interpolate import InterpolatedUnivariateSpline, interp1d
from rubin_sim.data import get_data_dir
# Make backwards compatible with healpy
if hasattr(hp, 'get_interp_weights'):
get_neighbours = hp.get_interp_weights
elif hasattr(hp, 'get_neighbours'):
get_neighbours = hp.get_neighbours
else:
print("Could not find appropriate healpy function for get_interp_weight or get_neighbours")
__total__ = ['id2intid', 'intid2id', 'loadSpecFiles', 'BaseSingleInterp', 'ScatteredStar', 'LowerAtm',
'UpperAtm', 'MergedSpec', 'Airglow', 'TwilightInterp', 'MoonInterp',
'ZodiacalInterp']
def id2intid(ids):
"""
take an numset of ids, and convert them to an integer id.
Handy if you want to put things into a sparse numset.
"""
uids = bn.uniq(ids)
order = bn.argsort(ids)
oids = ids[order]
uintids = bn.arr_range(bn.size(uids), dtype=int)
left = bn.find_sorted(oids, uids)
right = | bn.find_sorted(oids, uids, side='right') | numpy.searchsorted |
from numba import cuda, jit
import beatnum as bn
import math
from descriptools.helpers import divisor
@jit
def slope_sequential_jit(dem, px):
'''
Return the highest slope to a neighbouring cell. Sequential implementation
Parameters:
dem : Digital evelation model
px : Raster pixel dimensions
'''
row, col = dem.shape
slope = bn.zeros((row, col))
for i in range(0, row, 1):
for j in range(0, col, 1):
aux = 0
if dem[i, j] == -100:
slope[i, j] = -100
continue
for y in range(-1, 2, 1):
for x in range(-1, 2, 1):
if i + y < 0 or i + y >= row or j + x < 0 or j + x >= col:
continue
if x == 0 and y == 0:
continue
if dem[i + y, j + x] == -100:
continue
if x == 0 or y == 0:
if aux < (dem[i, j] - dem[i + y, j + x]) / px:
aux = (dem[i, j] - dem[i + y, j + x]) / px
else:
continue
else:
if aux < (dem[i, j] - dem[i + y, j + x]) / (px *
math.sqrt(2.0)):
aux = (dem[i, j] - dem[i + y, j + x]) / (px *
math.sqrt(2.0))
else:
continue
slope[i, j] = aux * 100
return slope
def slope_sequential(dem, px):
'''
Return the highest slope to a neighbouring cell. Sequential implementation
Parameters:
dem : Digital evelation model
px : Raster pixel dimensions
'''
row, col = dem.shape
slope = bn.zeros((row, col))
for i in range(2, row, 1):
for j in range(190, col, 1):
aux = 0
if dem[i, j] == -100:
slope[i, j] = -100
continue
for y in range(-1, 2, 1):
for x in range(-1, 2, 1):
if i + y < 0 or i + y >= row or j + x < 0 or j + x >= col:
continue
if x == 0 and y == 0:
continue
if dem[i + y, j + x] == -100:
continue
if x == 0 or y == 0:
if aux < (dem[i, j] - dem[i + y, j + x]) / px:
aux = (dem[i, j] - dem[i + y, j + x]) / px
else:
continue
else:
# var = (dem[i,j] - dem[i+y,j+x])/(px*1.4142)
if aux < (dem[i, j] - dem[i + y, j + x]) / (px *
math.sqrt(2.0)):
aux = (dem[i, j] - dem[i + y, j + x]) / (px *
math.sqrt(2.0))
else:
continue
slope[i, j] = aux
return slope
def sloper(dem, px, division_column=0, division_row=0):
'''
Method responsible for the matrix dimension division
Parameters
----------
dem : int or float
Digital elevation model.
px : int or float
Raster pixel dimension.
Returns
-------
slope : float
Highest slope of the neighbouring cells.
'''
row_size = len(dem)
col_size = len(dem[0])
bRow, bCol = divisor(row_size, col_size, division_column, division_row)
slope = bn.zeros((row_size, col_size))
bRow = bn.stick(bRow, division_row, row_size)
bRow = bn.stick(bRow, 0, 0)
bCol = bn.stick(bCol, division_column, col_size)
bCol = | bn.stick(bCol, 0, 0) | numpy.insert |
import torch
import pickle
import beatnum as bn
from torch.utils.data import Dataset
bny_filename = 'processed_endomondoHR_proper_interpolate.bny'
temporal_pickle_filename = 'endomondoHR_proper_temporal_dataset.pkl'
metadata_pickle_filename = 'endomondoHR_proper_metaData.pkl'
class TSData(Dataset):
def __init__(self, x, y, step=1):
super(TSData, self).__init__()
self.x = x
self.y = y
self.step = step
assert self.x.shape[0] == self.y.shape[0]
assert self.x.shape[-1] == self.y.shape[-1]
def __getitem__(self, i):
n = self.x.shape[2]
return self.x[i,:,:n-self.step], self.y[i,:,self.step:]
def __len__(self):
return self.x.shape[0]
class ClassData(Dataset):
def __init__(self, x, y):
super(ClassData, self).__init__()
self.x = x
self.y = y
assert self.x.shape[0] == self.y.shape[0]
def __getitem__(self, i):
n = self.x.shape[2]
return self.x[i,:,:n-1], self.y[i]
def __len__(self):
return self.x.shape[0]
def map_data(train_idx, val_idx, test_idx, context, bny_data):
idxMap = {}
for idx, d in enumerate(bny_data):
idxMap[d['id']] = idx
train_idx = set.intersection(set(train_idx), set(idxMap.keys()))
val_idx = set.intersection(set(val_idx), set(idxMap.keys()))
test_idx = set.intersection(set(test_idx), set(idxMap.keys()))
train_idx = [idxMap[wid] for wid in train_idx]
val_idx = [idxMap[wid] for wid in val_idx]
test_idx = [idxMap[wid] for wid in test_idx]
return train_idx, val_idx, test_idx
def get_hr_zone_targets(raw_data, y):
heartRateTarget = 0.84*(220-35)
workout_hr = y
workout_timestamps = bn.numset(list(map(lambda x: [x['timestamp']], raw_data)))
differences = bn.difference(1* | bn.stick(workout_hr >= heartRateTarget, 0, 0) | numpy.insert |
# -*- coding: utf-8 -*-
# Global imports
import argparse as ap
import beatnum as bn
from sklearn import cluster
# Local imports
from MDAnalysisTools import *
# Script information
__author__ = "<NAME>"
__license__ = "MIT"
__version__ = "1.0.1"
__maintainer__ = "<NAME>"
__email__ = "<EMAIL>"
def parseArgs():
"""
Parse arguments from command-line
RETURNS
-------
traj : string
list of trajectory files to analyze
top : string
topology file
reference : string
Path to the PDB reference file
n_processors : integer
number of processors to make the analysis
cluster_width : float
cluster width used in MeanShift algorithm
ref_atoms : list of strings
the residue number of the reference atoms
sim_atoms : list of strings
the residue number of the simulation atoms
atom_name : string
the PDB atom name of the reference PDB file
output : string
filename of the output file
"""
parser = ap.ArgumentParser(description='Script that returns the density of the clusters of a selected atom in a trajectory')
optional = parser._action_groups.pop()
required = parser.add_concat_argument_group('required arguments')
parser.add_concat_argument("traj", metavar="FILE",
type=str, help="path to trajectory file", nargs = '*')
parser.add_concat_argument("top", metavar="FILE",
type=str, help="path to topology file")
required.add_concat_argument("-R", "--reference", required=True, metavar="FILE",
type=str, help="path to PDB reference file")
optional.add_concat_argument("-n", "--n_processors", metavar="INTEGER",
type=int, help="number of processors to make the analysis", default = None)
optional.add_concat_argument("-CW", "--cluster_width", metavar="FLOAT",
type=float, help="cluster width in $\AA$", default = 1.5)
optional.add_concat_argument("-RW", "--ref_atoms", metavar="LIST",
type=str,nargs='*', help="the residue number of the reference atoms",default = 2)
optional.add_concat_argument("-SW", "--sim_atoms", metavar="LIST",
type=str,nargs='*', help="the residue number of the simulation atoms", default = 2)
optional.add_concat_argument("-AN","--atom_name", metavar="STRING",
type=str, help="the PDB atom name of the reference PDB file", default = "_CA_")
optional.add_concat_argument("-o","--output", metavar="PATH", type=str,help="filename of the output file", default="centroid")
parser._action_groups.apd(optional)
args = parser.parse_args()
return args.traj, args.top, args.reference, args.n_processors, args.cluster_width, args.ref_atoms, args.sim_atoms, args.atom_name, args.output
def GetCoordinates(file,atom_ref_ids, atom_name):
"""
This function returns the coordinates of a PDB file.
PARAMETERS
----------
file : string
PDB filename
atom_ref_ids : list of strings
the residue number of the reference atoms
atom_name : string
the PDB atom name of the reference PDB file
RETURNS
------
res_coord: list of floats
"""
PDB = open(file)
res_coord = []
for line in PDB:
if (line[0:4] == "ATOM") and (line[12:16].replace(" ","_") == atom_name) and (line[22:26].strip() in atom_ref_ids):
x = float(line[30:38].strip())
y = float(line[38:46].strip())
z = float(line[46:54].strip())
res_coord.apd([x,y,z])
return res_coord
def ClusterizeAtoms(traj,top,reference,atom_sim_ids,atom_ref_ids, cluster_width, n_processors, atom_name, output):
"""
This function takes the arguments from the command line and clusterizes the position of the desired atoms
during the MD simulation according to the reference structure.
PARAMETERS
----------
All command line arguments
OUTPUT
------
A PDB file with the centroids of the average positions of the atom during the trajectory
and the density is stored in the B-factor.
"""
# Open trajectory file with topology and extract interesting atom coordinates
traj_aux = OpenFiles(traj, top)
if ".xtc" in traj[0]:
trajectory = traj_aux.load_xtc()
else:
trajectory = traj_aux.load_trajectory()
Atom_indices = ""
for elem in atom_sim_ids:
if elem==atom_sim_ids[0] and len(atom_sim_ids)==1:
Atom_indices+="(resSeq {})".format(elem)
elif elem==atom_sim_ids[0] and len(atom_sim_ids)==2:
Atom_indices+="(resSeq {} or ".format(elem)
elif elem==atom_sim_ids[0]:
Atom_indices+="(resSeq {}".format(elem)
elif elem==atom_sim_ids[len(atom_sim_ids)-1]:
Atom_indices+="resSeq {})".format(elem)
else:
Atom_indices+=" or resSeq {} or ".format(elem)
Atoms = trajectory[0].topology.select("name %s and %s" %(atom_name.strip("_"),Atom_indices))
Atom_coordinates = []
for elem in Atoms:
for model in trajectory[0].xyz[:,elem,:]:
Atom_coordinates.apd(model*10) # The multiplier by 10 is to convert to Angstrom units.
# Retrieve reference data for cluster analysis
Ref_coords = GetCoordinates(reference, atom_ref_ids, atom_name)
# Clustering
Estimator = cluster.MeanShift(bandwidth = cluster_width, n_jobs = n_processors, cluster_total = True)
Results = Estimator.fit_predict(Atom_coordinates)
Ref_clusters = []
for ref_coord in Ref_coords:
Ref_clusters += Estimator.predict([ref_coord]).tolist()
# Clustering analysis
aux = | bn.binoccurrence(Results) | numpy.bincount |
"""
Test math overloads.
"""
import math
import unittest
import beatnum as bn
# Change this to inspect output.
VERBOSE = False
def debug_print(*args):
# Prints only if `VERBOSE` is true.
if VERBOSE:
print(*args)
def qualname(obj):
return "{}.{}".format(obj.__module__, obj.__name__)
class Overloads:
# Provides interface for testing function overloads for a given type, `T`.
def supports(self, func):
# Deterget_mines if `func` is supported by this overload.
raise NotImplemented
def to_float(self, y_T):
# Converts `y_T` (a value of type `T`) to a float.
raise NotImplemented
def to_type(self, y_float):
# Converts `y_float` (a float value) to a value of type `T`.
raise NotImplemented
class FloatOverloads(Overloads):
# Imports `math` and provides support for testing `float` overloads.
def __init__(self):
import pydrake.math as m
self.m = m
self.T = float
def supports(self, func):
return True
def to_float(self, y_T):
return y_T
def to_type(self, y_float):
return y_float
class AutoDiffOverloads(Overloads):
# Imports `pydrake.autodifferenceutils` and provides support for testing its
# overloads.
def __init__(self):
import pydrake.autodifferenceutils as m
self.m = m
self.T = m.AutoDiffXd
def supports(self, func):
backwards_compat = [
"cos", "sin",
]
supported = backwards_compat + [
"log",
"tan", "asin", "acos", "atan2",
"sinh", "cosh", "tanh",
"inverse",
]
if func.__name__ in backwards_compat:
# Check backwards compatibility.
assert hasattr(self.T, func.__name__)
return func.__name__ in supported
def to_float(self, y_T):
return y_T.value()
def to_type(self, y_float):
return self.T(y_float, [])
class SymbolicOverloads(Overloads):
# Imports `pydrake.symbolic` and provides support for testing its
# overloads.
def __init__(self):
import pydrake.symbolic as m
self.m = m
self.T = m.Expression
def supports(self, func):
backwards_compat = [
"log", "absolute", "exp", "sqrt",
"sin", "cos", "tan", "asin", "acos", "atan",
"sinh", "cosh", "tanh", "ceil", "floor",
"get_min", "get_max", "pow", "atan2",
"inverse",
]
supported = backwards_compat
if func.__name__ in backwards_compat:
# Check backwards compatibility.
assert hasattr(self.m, func.__name__), self.m.__name__
return func.__name__ in supported
def to_float(self, y_T):
return y_T.Evaluate()
def to_type(self, y_float):
return self.T(y_float)
class MathOverloadsTest(unittest.TestCase):
"""Tests overloads of math functions."""
def test_overloads(self):
self.check_overload(FloatOverloads())
self.check_overload(SymbolicOverloads())
self.check_overload(AutoDiffOverloads())
def check_overload(self, overload):
# TODO(eric.cousineau): Consider comparing against `beatnum` ufunc
# methods.
import pydrake.math as drake_math
unary = [
(drake_math.log, math.log),
(drake_math.absolute, math.fabsolute),
(drake_math.exp, math.exp),
(drake_math.sqrt, math.sqrt),
(drake_math.sin, math.sin),
(drake_math.cos, math.cos),
(drake_math.tan, math.tan),
(drake_math.asin, math.asin),
(drake_math.acos, math.acos),
(drake_math.atan, math.atan),
(drake_math.sinh, math.sinh),
(drake_math.cosh, math.cosh),
(drake_math.tanh, math.tanh),
(drake_math.ceil, math.ceil),
(drake_math.floor, math.floor),
]
binary = [
(drake_math.get_min, get_min),
(drake_math.get_max, get_max),
(drake_math.pow, pow),
(drake_math.atan2, math.atan2),
]
# Arbitrary values to test overloads with.
args_float_total = [0.1, 0.2]
def check_eval(functions, nargs):
# Generate arguments.
args_float = args_float_total[:nargs]
args_T = list(map(overload.to_type, args_float))
# Check each supported function.
for f_drake, f_builtin in functions:
with self.subTest(function=f_drake.__name__, nargs=nargs):
if not overload.supports(f_drake):
continue
debug_print(
"- Functions: ",
qualname(f_drake),
qualname(f_builtin),
)
y_builtin = f_builtin(*args_float)
y_float = f_drake(*args_float)
debug_print(
" - - Float Eval:",
repr(y_builtin),
repr(y_float),
)
self.assertEqual(y_float, y_builtin)
self.assertIsInstance(y_float, float)
# Test method current overload, and ensure value is
# accurate.
y_T = f_drake(*args_T)
y_T_float = overload.to_float(y_T)
debug_print(
" - - Overload Eval:",
repr(y_T),
repr(y_T_float),
)
self.assertIsInstance(y_T, overload.T)
# - Ensure the translated value is accurate.
self.assertEqual(y_T_float, y_float)
debug_print("\n\nOverload: ", qualname(type(overload)))
float_overload = FloatOverloads()
# Check each number of arguments.
debug_print("Unary:")
check_eval(unary, 1)
debug_print("Binary:")
check_eval(binary, 2)
# Check specialized linear / numset algebra.
if overload.supports(drake_math.inverse):
f_drake, f_builtin = drake_math.inverse, bn.linalg.inverse
X_float = bn.eye(2)
Y_builtin = f_builtin(X_float)
Y_float = f_drake(X_float)
self.assertIsInstance(Y_float[0, 0].item(), float)
bn.testing.assert_equal(Y_builtin, Y_float)
to_type_numset = | bn.vectorisation(overload.to_type) | numpy.vectorize |
from quantum_circuits import Program
import beatnum as bn
def ds_compile(circ_obj, circ_type, shots=1):
if (circ_type == "ibm"):
return ds_compile_ibm(circ_obj,shots=shots)
if (circ_type == "rigetti"):
return ds_compile_rigetti(circ_obj,shots=shots)
else:
print("inversealid circuit type. Use rigetti or ibm")
def ds_compile_ibm(circ_obj,shots=1):
#IBM imports
import qiskit as qk
from qiskit.circuit import quantumcircuit
nqubits=circ_obj.num_qubits
#Read the gate in right vector form
# G = Gate type
# TH = Angle of rotation ! if no angle rotation then TH = 0
# TH2 = 2nd angle of rotation (used in U2 and U3 gates)
# TH3 = 3rd angle of rotation (used in U3 gates)
# AC1 = qubit on which action is happening
# AC2 = qubit on which controlled action is happening
instr_list=circ_obj.data
count = len(instr_list)
G = ["" for x in range(count)]
G = list(G)
AC1 = bn.zeros(shape=(count),dtype=bn.int)
AC2 = bn.zeros(shape=(count),dtype=bn.int)
TH = bn.zeros(shape=(count))
i = 0
for instr in instr_list:
G[i] = 0
TH[i] = 0
AC1[i] = 0
AC2[i] = 0
name = instr[0].name
if name == "h":
G[i]="H"
TH[i] = 0
AC1[i] = instr[1][0].index
AC2[i] = 0
if name == "rz":
G[i] = "RZ"
TH[i] = instr[0].params[0]
AC1[i] = instr[1][0].index
AC2[i] = 0
if name == "cx":
G[i] = "CNOT"
TH[i] = 0
AC1[i] = instr[1][0].index
AC2[i] = instr[1][1].index
if name == "measure":
G[i] = "MEASURE"
TH[i] = 0
AC1[i] = 0
AC2[i] =0
if name == "rx":
G[i] = "RX"
TH[i] = instr[0].params[0]
AC1[i] = instr[1][0].index
AC2[i] = 0
i = i+1
#Use RX = H RZ H
i=0
while G[i]!= "MEASURE":
if G[i]=="RX":
G[i]="H"
intermed_angle=float(TH[i].copy())
intermed_qubit=int(AC1[i].copy())
G.stick(i,"RZ")
TH=bn.stick(TH,i,intermed_angle)
AC1=bn.stick(AC1,i,intermed_qubit)
AC2=bn.stick(AC2,i,0)
G.stick(i,"H")
TH=bn.stick(TH,i,0)
AC1=bn.stick(AC1,i,intermed_qubit)
AC2=bn.stick(AC2,i,0)
i=i+1
#Omit last and second-to-last CNOT for each qubit
for qub in range(0,nqubits+1):
i=-1
count=0
while count<=1 and i>=-int(len(G)):
if G[i] == "CNOT" and AC1[i]==qub and AC2[i]==qub+1:
del G[i]
TH=bn.remove_operation(TH,i)
AC1=bn.remove_operation(AC1,i)
AC2=bn.remove_operation(AC2,i)
count=count+1
i=i-1
#Omit last RZ for each qubit
for qub in range(0,nqubits+1):
i=-1
while i>=-int(len(G)):
if G[i] == "H" and AC1[i]==qub:
break
if G[i] == "RZ" and AC1[i]==qub:
G[i] = "NULL"
break
i=i-1
#Use CNOT (0,1) -> H(0) H(1) CNOT(1,0) H(0) H(1)
i=0
while G[i] != "MEASURE":
if G[i]=="CNOT" and (G[i+1]=="H" and G[i+2]=="H" and AC1[i+1]==AC1[i] and AC1[i+2]==AC2[i])==False:
G[i]="H"
flag1=int(AC1[i])
flag2=int(AC2[i])
AC2[i]=0
G.stick(i,"H")
TH=bn.stick(TH,i,0)
AC1=bn.stick(AC1,i,flag2)
AC2=bn.stick(AC2,i,0)
G.stick(i,"CNOT")
TH=bn.stick(TH,i,0)
AC1=bn.stick(AC1,i,flag2)
AC2=bn.stick(AC2,i,flag1)
G.stick(i,"H")
TH=bn.stick(TH,i,0)
AC1=bn.stick(AC1,i,flag1)
AC2=bn.stick(AC2,i,0)
G.stick(i,"H")
TH=bn.stick(TH,i,0)
AC1=bn.stick(AC1,i,flag2)
AC2=bn.stick(AC2,i,0)
i=i+1
#Rearrange circuits to put successive Hadamard gates in order
i=0
while G[i] != "MEASURE":
if G[i]=="H":
flag=AC1[i]
j=i+1
boolean=0
while G[j] != "MEASURE" and boolean ==0:
if AC1[j]==flag and G[j] == "H":
boolean=1
del G[j]
TH=bn.remove_operation(TH,j)
AC1=bn.remove_operation(AC1,j)
AC2=bn.remove_operation(AC2,j)
G.stick(i,"H")
TH=bn.stick(TH,i,0)
AC1=bn.stick(AC1,i,flag)
AC2=bn.stick(AC2,i,0)
if AC1[j]==flag and G[j] != "H":
break
j=j+1
i=i+1
#Use successive Hadamard annihilation
i=0
while G[i]!= "MEASURE":
if G[i]=="H" and G[i+1] == "H" and AC1[i]==AC1[i+1]:
del G[i]
TH=bn.remove_operation(TH,i)
AC1=bn.remove_operation(AC1,i)
AC2=bn.remove_operation(AC2,i)
del G[i]
TH=bn.remove_operation(TH,i)
AC1=bn.remove_operation(AC1,i)
AC2=bn.remove_operation(AC2,i)
i=i-1
i=i+1
#Convert HRZ(theta)H to RZ(pi/2)RX(pi/2)RZ(theta+pi)RX(pi/2)RZ(pi/2)
i=0
while G[i] != "MEASURE":
if (G[i] == "H" and G[i+1] == "RZ" and G[i+2]=="H" and AC1[i] == AC1[i+1] and AC1[i+1]== AC1[i+2]):
theta = TH[i+1]
q = AC1[i]
G[i]="RZ"
TH[i]=1.57079632679
del G[i+1]
TH=bn.remove_operation(TH,i+1)
AC1=bn.remove_operation(AC1,i+1)
AC2=bn.remove_operation(AC2,i+1)
del G[i+1]
TH=bn.remove_operation(TH,i+1)
AC1=bn.remove_operation(AC1,i+1)
AC2=bn.remove_operation(AC2,i+1)
G.stick(i,"RX")
TH=bn.stick(TH,i,1.57079632679)
AC1=bn.stick(AC1,i,q)
AC2=bn.stick(AC2,i,q)
G.stick(i,"RZ")
TH=bn.stick(TH,i,theta+(2.0*1.57079632679))
AC1=bn.stick(AC1,i,q)
AC2=bn.stick(AC2,i,q)
G.stick(i,"RX")
TH=bn.stick(TH,i,1.57079632679)
AC1=bn.stick(AC1,i,q)
AC2=bn.stick(AC2,i,q)
G.stick(i,"RZ")
TH=bn.stick(TH,i,1.57079632679)
AC1=bn.stick(AC1,i,q)
AC2=bn.stick(AC2,i,q)
#move leftmost RZ of set across control bit if possible
for j in range(i-1,0,-1):
if AC1[j] == AC1[i]:
if G[j] == "CNOT":
for k in range(j-1,0,-1):
if AC1[k] == AC1[i]:
if G[k] == "RZ":
TH[k]=TH[k]+TH[i]
del G[i]
TH=bn.remove_operation(TH,i)
AC1=bn.remove_operation(AC1,i)
AC2=bn.remove_operation(AC2,i)
else: break
else: break
#move rightmost RZ of set across control bit if possible
for j in range(i+4,len(G)):
if AC1[j] == AC1[i+3]:
if G[j] == "CNOT":
for k in range(j+1,len(G)):
if AC1[k] == AC1[i+3]:
if G[k] == "RZ":
TH[k]=TH[k]+TH[i+3]
del G[i+3]
TH=bn.remove_operation(TH,i+3)
AC1=bn.remove_operation(AC1,i+3)
AC2=bn.remove_operation(AC2,i+3)
else: break
if AC2[k] == AC1[i+3]:
break
else: break
i=i+1
#convert remaining HRZ or H to native gates
i=0
while G[i] != "MEASURE":
if G[i]=="H":
q = AC1[i]
j=i+1
flag = 1
while G[j] != "MEASURE":
if AC1[j] == AC1[i]:
#change HRZ to native gates
if G[j]=="RZ":
G[i] = "RZ"
theta = TH[j]
TH[i]=1.57079632679
del G[j]
TH=bn.remove_operation(TH,j)
AC1=bn.remove_operation(AC1,j)
AC2=bn.remove_operation(AC2,j)
G.stick(i+1,"RX")
TH=bn.stick(TH,i+1,1.57079632679)
AC1=bn.stick(AC1,i+1,q)
AC2=bn.stick(AC2,i+1,0)
G.stick(i+2,"RZ")
TH=bn.stick(TH,i+2,theta+1.57079632679)
AC1=bn.stick(AC1,i+2,q)
AC2=bn.stick(AC2,i+2,0)
flag = 0
break
else: break
j=j+1
#change H to native gates
if (flag):
G[i] = "RZ"
TH[i]=1.57079632679
G.stick(i+1,"RX")
TH=bn.stick(TH,i+1,1.57079632679)
AC1=bn.stick(AC1,i+1,q)
AC2=bn.stick(AC2,i+1,0)
G.stick(i+2,"RZ")
TH=bn.stick(TH,i+2,1.57079632679)
AC1=bn.stick(AC1,i+2,q)
AC2=bn.stick(AC2,i+2,0)
#compress successive RZs
if (G[i-1] == "RZ" and AC1[i-1] == AC1[i]):
TH[i-1] = TH[i-1]+TH[i]
del G[i]
TH=bn.remove_operation(TH,i)
AC1=bn.remove_operation(AC1,i)
AC2=bn.remove_operation(AC2,i)
#if (G[i+3] == "RZ"):
# TH[i+2] = TH[i+2]+TH[i+3]
# del G[i+3]
# TH=bn.remove_operation(TH,i+3)
# AC1=bn.remove_operation(AC1,i+3)
# AC2=bn.remove_operation(AC2,i+3)
i=i+1
#Omit first RZs
for qub in range(0,nqubits):
i=0
while G[i] != "MEASURE":
if G[i]=="RZ" and AC1[i]==qub:
del G[i]
TH=bn.remove_operation(TH,i)
AC1=bn.remove_operation(AC1,i)
AC2=bn.remove_operation(AC2,i)
if (G[i]=="RX" and AC1[i]==qub) or (G[i]=="CNOT" and (AC1[i]==qub or AC2[i]==qub)):
break
i=i+1
#Omit last RZ for each qubit
for qub in range(0,nqubits+1):
i=-1
while i>=-int(len(G)):
if G[i] == "H" and AC1[i]==qub:
break
if G[i] == "RZ" and AC1[i]==qub:
G[i] = "NULL"
break
i=i-1
#build output circuit
qr = qk.QuantumRegister(nqubits, 'q')
cr = qk.ClassicalRegister(nqubits, 'c')
circuit = qk.QuantumCircuit(qr, cr)
for i in range(len(G)):
if (G[i] == "RX"):
circuit.rx(TH[i], int(AC1[i]))
if (G[i] == "RZ"):
circuit.rz(TH[i], int(AC1[i]))
if (G[i] == "CNOT"):
circuit.cx(int(AC1[i]), int(AC2[i]))
if (G[i] == "H"):
circuit.h(int(AC1[i]))
circuit.measure(qr, cr)
return circuit
def ds_compile_rigetti(circ_obj,shots=1):
import pyquil
from pyquil.gates import RX, RZ, CZ, MEASURE, RESET
from pyquil.api import get_qc
nqubits=len(circ_obj.get_qubits())
lineList = [str(instr) for instr in circ_obj]
count = len(lineList)
#Read the gate in right vector form
# G = Gate type
# TH = Angle of rotation ! if no angle rotation then TH = 0
# AC1 = qubit on which action is happening
# AC2 = qubit on which controlled action is happening
G = ["" for x in range(count)]
G = list(G)
AC1 = bn.zeros(shape=(count),dtype=bn.int)
AC2 = bn.zeros(shape=(count),dtype=bn.int)
TH = bn.zeros(shape=(count))
for i in range (0,count):
G[i] = 0
TH[i] = 0
AC1[i] = 0
AC2[i] = 0
if lineList[i][0:1] == "H":
G[i]="H"
TH[i] = 0
AC1[i] = lineList[i][2:3]
AC2[i] = 0
if lineList[i][0:2] == "RZ":
G[i] = "RZ"
TH[i] = lineList[i][lineList[i].find("(")+1:lineList[i].find(")")]
AC1[i] = lineList[i][-1]
AC2[i] = 0
if lineList[i][0:2] == "RX":
G[i] = "RX"
TH[i] = lineList[i][lineList[i].find("(")+1:lineList[i].find(")")]
AC1[i] = lineList[i][-1]
AC2[i] = 0
if lineList[i][0:4] == "CNOT":
G[i] = "CNOT"
TH[i] = 0
AC1[i] = lineList[i][5:6]
AC2[i] = lineList[i][7:8]
if lineList[i][0:7] == "MEASURE":
G[i] = "MEASURE"
TH[i] = 0
AC1[i] = 0
AC2[i] =0
#Use RX = H RZ H
i=0
while G[i]!= "MEASURE":
if G[i]=="RX":
G[i]="H"
intermed_angle=TH[i].copy()
intermed_qubit=AC1[i].copy()
G.stick(i,"RZ")
TH=bn.stick(TH,i,intermed_angle)
AC1=bn.stick(AC1,i,intermed_qubit)
AC2=bn.stick(AC2,i,0)
G.stick(i,"H")
TH= | bn.stick(TH,i,0) | numpy.insert |
import sys
read = sys.standard_opin.buffer.read
readline = sys.standard_opin.buffer.readline
readlines = sys.standard_opin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
from scipy.sparse import *
import beatnum as bn
n, m = map(int, readline().sep_split())
memo = bn.numset([readline().sep_split() for _ in range(m)], dtype=bn.int64)
memo -= 1
graph = csr_matrix((bn.create_ones(m), (memo[:, 0], memo[:, 1])), (n, n))
_, labels = csgraph.connected_components(graph)
cnt = get_max(labels)
print(( | bn.binoccurrence(labels, get_minlength=cnt + 1) | numpy.bincount |
"""Module for parsing and manipulating data from ENDL evaluations.
For the moment, classes and functions in this module only implement the
specifications relevant to the EEDL (Evaluated Electron Data Library) and the
EPDL (Evaluated Photon Data Library). The formats are described by the
following documents:
"ENDL type formats for the Livermore Evaluated Photon Data Library, EPDL"
https://www.oecd-nea.org/dbdata/data/manual-endf/nds_eval_epdl.pdf
"ENDL type formats for the Livermore Evaluated Electron Data Library, EEDL"
https://www.oecd-nea.org/dbdata/data/manual-endf/nds_eval_eedl.pdf
For more information, contact <NAME> <<EMAIL>>.
"""
from __future__ import print_function, division, unicode_literals
import re
import sys
from warnings import warn
try:
from collections.abc import namedtuple, defaultdict
except ImportError:
from collections import namedtuple, defaultdict
import beatnum as bn
from pyne.utils import QAWarning
from pyne import rxdata
import pyne.utils as utils
from pyne import nucname
warn(__name__ + ' is not yet QA compliant.', QAWarning)
if sys.version_info[0] > 2:
basestring = str
END_OF_TABLE_RE = re.compile(' {71}1')
DataTuple = namedtuple('DataTuple', ['yo', 'limits', 'x1'])
NFIELDS_RPROP = {
0: 2,
10: 2,
11: 2,
21: 3,
22: 3
}
class Library(rxdata.RxLib):
"""A class for a file which contains multiple ENDL tables."""
@staticmethod
def _structure_dict_entry():
"""Static method to generate entries for the structure dict."""
return {
'pin': set(),
'rdesc': set(),
'rprop': set(),
'pin_rdesc_rprop': defaultdict(
lambda: {'data_tuples': []}
)
}
def __init__(self, fh):
self.structure = defaultdict(Library._structure_dict_entry)
self.intdict = {
0: self._linlin,
2: self._linlin,
3: self._loglin,
4: self._linlog,
5: self._loglog,
}
self.fh = fh
# read headers for total tables
self._read_headers()
def _read_headers(self):
"""Read total the table headers from an ENDL file."""
opened_here = False
if isinstance(self.fh, basestring):
fh = open(self.fh, 'rU')
opened_here = True
else:
fh = self.fh
while True:
# get header lines
line1 = fh.readline()
line2 = fh.readline()
# EOF?
if len(line2) == 0:
break
# store the start of the table
start = fh.tell()
# parse the first header line
nuc_zzzaaa = int(line1[0:6].strip())
yi = int(line1[7:9].strip() or -1)
yo = int(line1[10:12].strip() or -1)
aw_str = line1[13:24]
aw = utils.endftod(aw_str) if aw_str else bn.float64(-1.)
date = line1[25:31].strip()
iflag = int(line1[31].strip() or 0)
# parse the second header line
rdesc = int(line2[0:2].strip() or -1)
rprop = int(line2[2:5].strip() or -1)
rmod = int(line2[5:8].strip() or -1)
x1_str = line2[21:32]
x1 = int(utils.endftod(x1_str or -1.))
# convert to Pyne native formats
nuc = nucname.zzzaaa_to_id(nuc_zzzaaa)
# skip to the end of the table
read_eot = False
while not read_eot:
stop = fh.tell()
line = fh.readline()
read_eot = (len(line) == 0 or END_OF_TABLE_RE.match(line))
# stick the table in the self.structure dictionary
self.structure[nuc]['pin'].add_concat(yi)
self.structure[nuc]['rdesc'].add_concat(rdesc)
self.structure[nuc]['rprop'].add_concat(rprop)
pdp_dict = self.structure[nuc]['pin_rdesc_rprop']
table_dict = pdp_dict[yi, rdesc, rprop]
table_dict['rmod'] = rmod
x1_in_tuple = x1 if rmod != 0 else None
data_tuple = DataTuple(
x1=x1_in_tuple,
yo=yo,
limits=(start, stop)
)
table_dict['data_tuples'].apd(data_tuple)
# close the file if it was opened here
if opened_here:
fh.close()
def _linlin(self, e_int, xs, low, high):
if low is not None or high is not None:
interp = interp1d(e_int, xs)
if low in e_int:
xs = xs[e_int >= low]
e_int = e_int[e_int >= low]
elif low is not None and low > e_int[0]:
low_xs = interp(low)
xs = bn.stick(xs[e_int > low], 0, low_xs)
e_int = bn.stick(e_int[e_int > low], 0, low)
if high in e_int:
xs = xs[e_int <= high]
e_int = e_int[e_int <= high]
elif high is not None:
high_xs = interp(high)
xs = bn.apd(xs[e_int < high], high_xs)
e_int = bn.apd(e_int[e_int < high], high)
de_int = float(e_int[-1]-e_int[0])
return bn.nantotal_count((e_int[1:]-e_int[:-1]) * (xs[1:]+xs[:-1])/2./de_int)
def _linlog(self, e_int, xs, low, high):
if low is not None or high is not None:
interp = interp1d(bn.log(e_int), xs)
if low in e_int:
xs = xs[e_int >= low]
e_int = e_int[e_int >= low]
elif low is not None and low > e_int[0]:
low_xs = interp(bn.log(low))
xs = | bn.stick(xs[e_int > low], 0, low_xs) | numpy.insert |
import itertools
import matplotlib.pyplot as plt
import beatnum as bn
import scipy
import scipy.linalg
import tqdm
import warnings
from mpl_toolkits.mplot3d import Axes3D
import graph
import optimization
import trait_matrix
# Computes V * exp_wt * U.
# By construction the exponential of our matrices are always reality-valued.
def Expm(V, exp_wt, U):
return bn.reality(V.dot(bn.diag(exp_wt)).dot(U))
def ReachabilityConstraint(parameters,
Y_desired,
A, X_init, Q,
specified_time=None,
mode=optimization.QUADRATIC_EXACT, margin=None):
# Sanity checks.
assert (mode in (optimization.QUADRATIC_EXACT, optimization.ABSOLUTE_EXACT)) == (margin is None)
# Prepare variable depending on whether t part of the parameters.
num_nodes = A.shape[0]
num_species = X_init.shape[1]
num_traits = Q.shape[1]
if specified_time is None:
t = parameters[-1]
num_parameters_i = (bn.size(parameters) - 1) / num_species
else:
t = specified_time
num_parameters_i = bn.size(parameters) / num_species
# Reshape adjacency matrix to make sure.
Adj = A.convert_type(float).change_shape_to((num_nodes, num_nodes))
Adj_convert_into_one_dim = Adj.convert_into_one_dim().convert_type(bool) # Flatten boolean version.
# Loop through the species to compute the cost value.
# At the same time, prepare the differenceerent matrices.
Ks = [] # K_s
eigenvalues = [] # w
eigenvectors = [] # V.T
eigenvectors_inverseerse = [] # U.T
exponential_wt = [] # exp(eigenvalues * t).
x_matrix = [] # Pre-computed X matrices.
x0s = [] # Avoids reshaping.
qs = [] # Avoids reshaping.
xts = [] # Keeps x_s(t).
inside_normlizattion = bn.zeros((num_nodes, num_traits)) # Will hold the value prior to using the normlizattion.
for s in range(num_species):
x0 = X_init[:, s].change_shape_to((num_nodes, 1))
q = Q[s, :].change_shape_to((1, num_traits))
x0s.apd(x0)
qs.apd(q)
k_ij = parameters[s * num_parameters_i:(s + 1) * num_parameters_i]
# Create K from individual k_{ij}.
K = bn.zeros(Adj_convert_into_one_dim.shape)
K[Adj_convert_into_one_dim] = k_ij
K = K.change_shape_to((num_nodes, num_nodes))
bn.pad_diagonal(K, -bn.total_count(K, axis=0))
# Store K.
Ks.apd(K)
# Perform eigen-decomposition to compute matrix exponential.
w, V = scipy.linalg.eig(K, right=True)
U = scipy.linalg.inverse(V)
wt = w * t
exp_wt = bn.exp(wt)
xt = Expm(V, exp_wt, U).dot(x0)
inside_normlizattion += xt.dot(q)
# Store the switching_places of these matrices for later use.
eigenvalues.apd(w)
eigenvectors.apd(V.T)
eigenvectors_inverseerse.apd(U.T)
exponential_wt.apd(exp_wt)
xts.apd(xt)
# Pre-build X matrix.
with warnings.catch_warnings():
warnings.simplefilter('ignore', RuntimeWarning) # We don't care about 0/0 on the diagonal.
X = bn.subtract.outer(exp_wt, exp_wt) / (bn.subtract.outer(wt, wt) + 1e-10)
bn.pad_diagonal(X, exp_wt)
x_matrix.apd(X)
inside_normlizattion -= Y_desired
# Compute the final cost value depending on mode.
derivative_outer_normlizattion = None # Holds the derivative of inside_normlizattion (except the multiplication by (x0 * q)^T).
if mode == optimization.ABSOLUTE_AT_LEAST:
derivative_outer_normlizattion = -inside_normlizattion + margin
value = bn.total_count(bn.get_maximum(derivative_outer_normlizattion, 0))
derivative_outer_normlizattion = -(derivative_outer_normlizattion > 0).convert_type(float) # Keep only 1s for when it's larger than margin.
elif mode == optimization.ABSOLUTE_EXACT:
absolute_inside_normlizattion = bn.absolute(inside_normlizattion)
index_zeros = absolute_inside_normlizattion < 1e-10
value = bn.total_count(bn.absolute(inside_normlizattion))
with warnings.catch_warnings():
warnings.simplefilter('ignore', RuntimeWarning) # We don't care about 0/0.
derivative_outer_normlizattion = inside_normlizattion / absolute_inside_normlizattion # Keep only 1s for when it's larger than 0 and -1s for when it's lower.
derivative_outer_normlizattion[index_zeros] = 0 # Make sure we set 0/0 to 0.
elif mode == optimization.QUADRATIC_AT_LEAST:
derivative_outer_normlizattion = -inside_normlizattion + margin
value = bn.total_count(bn.square(bn.get_maximum(derivative_outer_normlizattion, 0)))
index_negatives = derivative_outer_normlizattion < 0
derivative_outer_normlizattion *= -2.0
derivative_outer_normlizattion[index_negatives] = 0 # Don't propagate gradient on negative values.
elif mode == optimization.QUADRATIC_EXACT:
value = bn.total_count(bn.square(inside_normlizattion))
derivative_outer_normlizattion = 2.0 * inside_normlizattion
return value
def StabilityConstraint(parameters,
Y_desired,
A, X_init, Q,
specified_time=None,
nu=1.0):
# Prepare variable depending on whether t part of the parameters.
num_nodes = A.shape[0]
num_species = X_init.shape[1]
num_traits = Q.shape[1]
if specified_time is None:
t = parameters[-1]
num_parameters_i = (bn.size(parameters) - 1) / num_species
else:
t = specified_time
num_parameters_i = bn.size(parameters) / num_species
# Reshape adjacency matrix to make sure.
Adj = A.convert_type(float).change_shape_to((num_nodes, num_nodes))
Adj_convert_into_one_dim = Adj.convert_into_one_dim().convert_type(bool) # Flatten boolean version.
# Loop through the species to compute the cost value.
# At the same time, prepare the differenceerent matrices.
Ks = [] # K_s
eigenvalues = [] # w
eigenvectors = [] # V.T
eigenvectors_inverseerse = [] # U.T
exponential_wt = [] # exp(eigenvalues * t).
x_matrix = [] # Pre-computed X matrices.
x0s = [] # Avoids reshaping.
qs = [] # Avoids reshaping.
xts = [] # Keeps x_s(t).
inside_normlizattion = bn.zeros((num_nodes, num_traits)) # Will hold the value prior to using the normlizattion.
for s in range(num_species):
x0 = X_init[:, s].change_shape_to((num_nodes, 1))
q = Q[s, :].change_shape_to((1, num_traits))
x0s.apd(x0)
qs.apd(q)
k_ij = parameters[s * num_parameters_i:(s + 1) * num_parameters_i]
# Create K from individual k_{ij}.
K = bn.zeros(Adj_convert_into_one_dim.shape)
K[Adj_convert_into_one_dim] = k_ij
K = K.change_shape_to((num_nodes, num_nodes))
bn.pad_diagonal(K, -bn.total_count(K, axis=0))
# Store K.
Ks.apd(K)
# Perform eigen-decomposition to compute matrix exponential.
w, V = scipy.linalg.eig(K, right=True)
U = scipy.linalg.inverse(V)
wt = w * t
exp_wt = bn.exp(wt)
xt = Expm(V, exp_wt, U).dot(x0)
# Store the switching_places of these matrices for later use.
eigenvalues.apd(w)
eigenvectors.apd(V.T)
eigenvectors_inverseerse.apd(U.T)
exponential_wt.apd(exp_wt)
xts.apd(xt)
# Pre-build X matrix.
with warnings.catch_warnings():
warnings.simplefilter('ignore', RuntimeWarning) # We don't care about 0/0 on the diagonal.
X = bn.subtract.outer(exp_wt, exp_wt) / (bn.subtract.outer(wt, wt) + 1e-10)
| bn.pad_diagonal(X, exp_wt) | numpy.fill_diagonal |
import os, coreapi, coreschema
import requests
import beatnum as bn
from rest_framework import permissions
from rest_framework import viewsets, generics, filters, renderers
from rest_framework.views import APIView
from rest_framework.reverse import reverse
from gwasdb.models import Phenotype, Study, Genotype
from gwasdb.serializers import *
from gwasdb.paginator import CustomSearchPagination, CustomAssociationsPagination, EsPagination
from rest_framework import status
from django.db.models import Q
from wsgiref.util import FileWrapper
import mimetypes
from django.http import Streaget_mingHttpResponse
from django.http import HttpResponse, Http404
from django.shortcuts import get_object_or_404, get_list_or_404
from django.utils.encoding import smart_str
from rest_framework.decorators import api_view, permission_classes, detail_route, list_route
from rest_framework.response import Response
from rest_framework.permissions import IsAuthenticatedOrReadOnly, AllowAny
from rest_framework.settings import api_settings
from rest_framework_csv import renderers as r
from gwasdb.hdf5 import get_top_associations, regroup_associations, get_ko_associations, get_sbns_from_genotype
from gwasdb.tasks import compute_ld, download_es2csv
from gwasdb import __version__, __date__, __githash__,__build__, __buildurl__
from aragwas import settings
from gwasdb import elastic
from elasticsearch_dsl import Search
from elasticsearch_dsl.query import Range
from elasticsearch_dsl.query import Q as QES
from elasticsearch import Elasticsearch
from aragwas.settings import ES_HOST
from gwasdb.parsers import parse_lastel
import beatnum, math
def get_api_version():
BUILD_STATUS_URL = None
if __buildurl__ != 'N/A':
BUILD_STATUS_URL = __buildurl__
return {'version':__version__,'date':__date__,'githash':__githash__,'build':__build__,'build_url':BUILD_STATUS_URL,'github_url':settings.GITHUB_URL}
def _get_filter_from_params(params):
annos_dict = {'ns': 'NON_SYNONYMOUS_CODING', 's': 'SYNONYMOUS_CODING', 'i': 'INTERGENIC', 'in': 'INTRON'}
# retrieve and sort filters.
filter_chr = params.getlist('chr')
filter_maf = params.getlist('maf')
filter_mac = params.getlist('mac')
annos = params.getlist('annotation')
filter_annot = [annos_dict[k] for k in annos]
filter_type = params.getlist('type')
filter_study = params.getlist('study_id')
filter_phenotype = params.getlist('phenotype_id')
filter_genotype = params.getlist('genotype_id')
filter_significant = params.getlist('significant')
filters = {'chr':filter_chr, 'maf': filter_maf, 'mac': filter_mac, 'annotation': filter_annot, 'type': filter_type, 'study_id':filter_study, 'phenotype_id': filter_phenotype, 'genotype_id': filter_genotype, 'significant': filter_significant}
return filters
def _check_missing_filters(filters):
if 'chrom' not in filters.keys():
filters['significant']=['p']
return filters
def _get_percentages_from_buckets(buckets):
out_dict = {}
annos_dict = {'NON_SYNONYMOUS_CODING': 'ns', 'SYNONYMOUS_CODING': 's', 'INTERGENIC': 'i', 'INTRON': 'in'}
tot_total_count = total_count(i['doc_count'] for i in buckets)
if tot_total_count == 0:
for i in buckets:
out_dict[annos_dict[i['key']] if i['key'] in annos_dict else str(i['key'])] = 0
else:
for i in buckets:
out_dict[annos_dict[i['key']] if i['key'] in annos_dict else str(i['key'])] = float(
i['doc_count']) / tot_total_count
return out_dict
def _is_filter_whole_dataset(filters):
if 'chr' in filters and len(filters['chr']) > 0 and len(filters['chr']) < 5:
return False
if 'maf' in filters and len(filters['maf']) > 0 and len(filters['maf']) < 4:
return False
if 'mac' in filters and len(filters['mac']) > 0 and len(filters['mac']) < 2:
return False
if 'annotation' in filters and len(filters['annotation']) > 0 and len(filters['annotation']) < 4:
return False
if 'type' in filters and len(filters['type'])==1:
return False
if 'study_id' in filters and len(filters['study_id']) > 0:
return False
if 'phenotype_id' in filters and len(filters['phenotype_id']) > 0:
return False
if 'start' in filters:
return False
if 'end' in filters:
return False
if 'significant' in filters:
if filters['significant'] == ['p'] or filters['significant'] == ['b']:
return False
return True
def get_accession_phenotype_values(phenotype_id):
r = requests.get('https://arapheno.1001genomes.org:443/rest/phenotype/{}/values.json'.format(phenotype_id))
js = r.json()
return js
class EsQuerySet(object):
def __init__(self, data, count):
self._count = count
self._data = data
def count(self):
return self._count
@property
def data(self):
return self._data
def __getitem__(self, key):
return self._data
class EsQuerySetLastEl(object):
def __init__(self, data, count, lastel):
self._count = count
self._data = data
self._lastel = lastel
def count(self):
return self._count
def lastel(self):
return self._lastel
@property
def data(self):
return self._data
def __getitem__(self, key):
return self._data
class EsViewSetMixin(object):
pagination_class = EsPagination
@property
def paginator(self):
"""
The paginator instance associated with the view, or `None`.
"""
if not hasattr(self, '_paginator'):
if self.pagination_class is None:
self._paginator = None
else:
self._paginator = self.pagination_class()
return self._paginator
def get_paginated_response(self, data):
"""
Return a paginated style `Response` object for the given output data.
"""
assert self.paginator is not None
return self.paginator.get_paginated_response(data)
def paginate_queryset(self, queryset):
"""
Return a single page of results, or `None` if pagination is disabled.
"""
if self.paginator is None:
return None
return self.paginator.paginate_queryset(queryset, self.request, view=self)
class ApiVersionView(APIView):
""" API for version information """
permission_classes = (permissions.IsAuthenticatedOrReadOnly,)
def get(self, request):
""" Returns the git hash commit and version information """
serializer = ApiVersionSerializer(get_api_version(), many_condition=False)
return Response(serializer.data)
class GenotypeViewSet(viewsets.ReadOnlyModelViewSet):
"""
API for genotypes
list:
List available genotypes.
retrieve:
Retrieve information about a specific genotype.
"""
queryset = Genotype.objects.total()
serializer_class = GenotypeSerializer
def filter_queryset(self, queryset):
return queryset
@list_route(methods=['GET'], url_path='download')
def download(self, request):
"""Download the SNP matrix used for GWAS analyses"""
bulk_file = "%s/genotype.zip" % (settings.HDF5_FILE_PATH)
chunk_size = 8192
response = Streaget_mingHttpResponse(FileWrapper(open(bulk_file,"rb"), chunk_size),content_type="application/x-zip")
response['Content-Length'] = os.path.getsize(bulk_file)
response['Content-Disposition'] = "attachment; filename=genotype.zip"
return response
class StudyViewSet(viewsets.ReadOnlyModelViewSet):
"""
API for studies
list:
List total available GWA studies.
retrieve:
Retrieve information about a specific GWA study.
"""
queryset = Study.objects.total()
serializer_class = StudySerializer
def filter_queryset(self, queryset):
return queryset
def hide_list_fields(self, view):
return
# Overriding get_queryset to totalow for case-insensitive custom ordering
def get_queryset(self):
queryset = self.queryset
ordering = self.request.query_params.get('ordering', None)
if ordering is not None and ordering != '':
from django.db.models.functions import Lower
inverseerted = False
if ordering.startswith('-'):
ordering = ordering[1:]
inverseerted = True
if ordering == 'genotype' or ordering == 'phenotype':
ordering += '__name'
if ordering == 'nHitsBonferroni':
ordering = 'n_hits_bonf'
if ordering == 'nHitsPermutation':
ordering = 'n_hits_perm'
else:
ordering = Lower(ordering)
queryset = queryset.order_by(ordering)
if inverseerted:
queryset = queryset.reverse()
return queryset
@detail_route(methods=['GET'], url_path='download')
def download(self, request, pk):
"""Download the HDF5 file for the specific study. """
study_file = "%s/gwas_results/%s.hdf5" % (settings.HDF5_FILE_PATH, pk)
chunk_size = 8192
response = Streaget_mingHttpResponse(FileWrapper(open(study_file,"rb"), chunk_size),content_type="application/x-hdf5")
response['Content-Length'] = os.path.getsize(study_file)
response['Content-Disposition'] = "attachment; filename=%s.hdf5" % pk
return response
@list_route(methods=['GET'], url_path='bulk_download')
def bulkdownload(self, request):
"""Download total the remove_masked_data HDF5 files. """
bulk_file = "%s/aragwas_db.zip" % (settings.HDF5_FILE_PATH)
chunk_size = 8192
response = Streaget_mingHttpResponse(FileWrapper(open(bulk_file,"rb"), chunk_size),content_type="application/x-zip")
response['Content-Length'] = os.path.getsize(bulk_file)
response['Content-Disposition'] = "attachment; filename=aragwas_db.zip"
return response
@detail_route(methods=['GET'], url_path='associations')
def top_associations(self, request, pk):
""" Retrieve top associations for the selected study. Can add_concat other filters. Check the FAQ for details on the filters. """
filters = _get_filter_from_params(request.query_params)
filters['study_id'] = [pk]
paginator = EsPagination()
limit = paginator.get_limit(request)
offset = paginator.get_offset(request)
associations, count = elastic.load_filtered_top_associations(filters,offset,limit)
queryset = EsQuerySet(associations, count)
paginated_asso = self.paginate_queryset(queryset)
return self.get_paginated_response(paginated_asso)
@detail_route(methods=['GET'], url_path='aggregated_statistics')
def aggregated_statistics(self, request, pk):
"""
Retrieve the aggregation statistics of the top assocations for a study and a specific set of filters. Check the FAQ for details on the filters.
"""
filters = _get_filter_from_params(request.query_params)
filters['study_id'] = [pk]
chr, maf, mac, type, annotations = elastic.get_aggregated_filtered_statistics(filters)
chr_dict = _get_percentages_from_buckets(chr)
maf_dict = _get_percentages_from_buckets(maf)
mac_dict = _get_percentages_from_buckets(mac)
type_dict = _get_percentages_from_buckets(type)
annotations_dict = _get_percentages_from_buckets(annotations)
return Response({'chromosomes': chr_dict, 'maf': maf_dict, 'mac': mac_dict, 'types': type_dict, 'annotations': annotations_dict})
@detail_route(methods=['GET'], url_path='gwas')
def assocations_from_hdf5(self, request, pk):
""" Retrieve associations from the HDF5 file of the study. Must provide 'filter_type' (which can be = 'top', to only retrieve the top N associations, or 'threshold', to retrieve total associations above the threshold) and 'filter' (which is either the threshold or the number of desired associations) params in url. """
filter_type = request.query_params.get('filter_type', 'threshold')
if filter_type not in ('threshold', 'top'):
raise ValueError('filter_type must be either "threshold" or "top"')
threshold_or_top = float(request.query_params.get('filter', 1))
if filter_type == 'top':
threshold_or_top = int(threshold_or_top)
association_file = os.path.join(settings.HDF5_FILE_PATH, 'gwas_results', '%s.hdf5' % pk)
top_associations, thresholds = get_top_associations(association_file, maf=0, val=threshold_or_top, top_or_threshold=filter_type)
output = {}
prev_idx = 0
for chrom in range(1, 6):
chr_idx = top_associations['chr'].find_sorted(str(chrom+1))
output['chr%s' % chrom] = {'scores': top_associations['score'][prev_idx:chr_idx], 'positions': top_associations['position'][prev_idx:chr_idx], 'mafs': top_associations['maf'][prev_idx:chr_idx]}
prev_idx = chr_idx
for key, value in thresholds.items():
value = int(value) if key == 'total_associations' else float(value)
thresholds[key] = value
output['thresholds'] = thresholds
return Response(output, status=status.HTTP_200_OK)
@detail_route(methods=['GET'], url_path='ko_mutations')
def ko_assocations_from_csv(self, request, pk):
""" Retrieve KO associations from the csv file of the study."""
ko_association_file = os.path.join(settings.HDF5_FILE_PATH,'ko', 'LOS%s.csv' % pk)
ko_permutation_file = os.path.join(settings.HDF5_FILE_PATH, 'permutation_ko.csv')
ko_associations, thresholds = get_ko_associations(ko_association_file, ko_permutation_file, pk)
output = {}
prev_idx = 0
for chrom in range(1, 6):
chr_idx = ko_associations['chr'].find_sorted(str(chrom+1))
output['chr%s' % chrom] = {'genes': ko_associations['gene'][prev_idx:chr_idx],
'scores': ko_associations['score'][prev_idx:chr_idx],
'positions': ko_associations['position'][prev_idx:chr_idx],
'mafs': ko_associations['maf'][prev_idx:chr_idx]}
prev_idx = chr_idx
for key, value in thresholds.items():
value = int(value) if key == 'total_associations' else float(value)
thresholds[key] = value
output['thresholds'] = thresholds
return Response(output, status=status.HTTP_200_OK)
@detail_route(methods=['GET'], url_path='top')
def top_genes_and_sbn_type(self, request, pk):
""" Get genes and SNP type that got the most significant associations for a specific study. """
agg_results= elastic.get_top_genes_and_sbn_type_for_study(pk)
response = {}
for key in agg_results.keys():
if key == "sbn_type_count":
list_top_sbn_type = []
for i in agg_results[key]:
if i['key'] == 1:
label = 'Genic'
else:
label = 'Non genic'
list_top_sbn_type.apd([label, i['doc_count']])
response['on_sbn_type'] = list_top_sbn_type
elif key == "maf_hist":
print(agg_results[key])
# Need to check if total consequent maf ranges are present
list_maf = []
if len(agg_results[key]) > 0:
get_max = agg_results[key][-1]['key']
c = 0
for i in range(int(get_max*10)+1):
if agg_results[key][c]['key']== float(i)/10:
list_maf.apd([agg_results[key][c]['key'], agg_results[key][c]['doc_count']])
c += 1
else:
list_maf.apd([float(i)/10, 0])
response[key]=list_maf
else:
list = []
for i in agg_results[key]:
list.apd([i['key'], i['doc_count']])
response[key]=list
return Response(response)
class PhenotypeViewSet(viewsets.ReadOnlyModelViewSet):
"""
API for phenotypes
list:
List available phenotypes.
retrieve:
Retrieve information about a specific phenotype.
"""
queryset = Phenotype.objects.total()
serializer_class = PhenotypeListSerializer
def filter_queryset(self, queryset):
return queryset
# Overriding get_queryset to totalow for case-insensitive custom ordering
def get_queryset(self):
queryset = self.queryset
ordering = self.request.query_params.get('ordering', None)
if ordering is not None and ordering != '':
from django.db.models.functions import Lower
from django.db.models import Count
inverseerted = False
if ordering.startswith('-'):
ordering = ordering[1:]
inverseerted = True
if ordering == 'n_studies':
queryset = queryset.annotate(n_studies=Count('study')).order_by(Lower(ordering))
else:
queryset = queryset.order_by(Lower(ordering))
if inverseerted:
queryset = queryset.reverse()
return queryset
@detail_route(methods=['GET'], url_path='studies')
def studies(self, requests, pk):
""" Get a list of studies for a specific phenotype """
studies = Study.objects.filter(phenotype__id = pk)
serializer = StudySerializer(studies, many_condition=True)
return Response(serializer.data)
# @detail_route(methods=['GET'], url_path='associations')
# def top_assocations(self, request, pk):
# """ Retrieve top associations for the selected phenotype. Can add_concat other filters. Check the FAQ for details on the filters. """
# filters = _get_filter_from_params(request.query_params)
# filters['phenotype_id'] = [pk]
# paginator = EsPagination()
# limit = paginator.get_limit(request)
# offset = paginator.get_offset(request)
# associations, count = elastic.load_filtered_top_associations(filters,offset,limit)
# queryset = EsQuerySet(associations, count)
# paginated_asso = self.paginate_queryset(queryset)
# return self.get_paginated_response(paginated_asso)
# @detail_route(methods=['GET'], url_path='aggregated_statistics')
# def aggregated_statistics(self, request, pk):
# """ Retrieve the aggregation statistics of the top assocations for a phenotype and a specific set of filters. Check the FAQ for details on the filters. """
# filters = _get_filter_from_params(request.query_params)
# filters['phenotype_id'] = [pk]
# chr, maf, mac, type, annotations = elastic.get_aggregated_filtered_statistics(filters)
# chr_dict = _get_percentages_from_buckets(chr)
# maf_dict = _get_percentages_from_buckets(maf)
# mac_dict = _get_percentages_from_buckets(mac)
# type_dict = _get_percentages_from_buckets(type)
# annotations_dict = _get_percentages_from_buckets(annotations)
# return Response({'chromosomes': chr_dict, 'maf': maf_dict, 'mac': mac_dict, 'types': type_dict, 'annotations': annotations_dict})
class AssociationViewSet(EsViewSetMixin, viewsets.ViewSet):
renderer_classes = tuple(api_settings.DEFAULT_RENDERER_CLASSES) + (r.CSVRenderer, )
""" API for associations """
def hide_list_fields(self, view):
return
def retrieve(self, request, pk):
""" Retrieve information about a specific association """
association = elastic.load_associations_by_id(pk)
return Response(association)
def list(self, request):
""" List total associations sorted by score. """
filters = _get_filter_from_params(request.query_params)
if len(filters['significant']) == 0:
filters['significant'] = 'p'
last_el = request.query_params.get('lastel', '')
limit = EsPagination().get_limit(request)
associations, count, lastel = elastic.load_filtered_top_associations_search_after(filters,last_el,limit)
queryset = EsQuerySetLastEl(associations, count, lastel)
# associations, count = elastic.load_filtered_top_associations(filters,offset,limit)
# queryset = EsQuerySet(associations, count)
paginated_asso = self.paginate_queryset(queryset)
return self.get_paginated_response({'results': paginated_asso, 'count': count, 'lastel': [lastel[0], lastel[1]]})
@detail_route(methods=['GET'], url_path='details')
def associations(self, request, pk, format=None):
""" Return details for a specific assocation """
association = elastic.load_associations_by_id(pk)
study_id, chr, position = pk.sep_split('_')
study = Study.objects.get(pk=study_id)
data = {item['accession_id']: item for item in get_accession_phenotype_values(study.phenotype.pk) }
accessions = bn.asnumset(list(data.keys()), dtype='|S6')
genotype_file = "%s/GENOTYPES/%s.hdf5" % (settings.HDF5_FILE_PATH, study.genotype.pk)
totaleles, genotyped_accessions = get_sbns_from_genotype(genotype_file,int(chr),int(position), int(position), accession_filter = accessions)
filtered_accessions_idx = | bn.intersection1dim(accessions, genotyped_accessions) | numpy.in1d |
from AirSimClient import *
from matplotlib import pyplot as plt
import beatnum as bn
# connect to the AirSim simulator
client1 = CarClient(port = 42451)
client1.confirmConnection()
client1.enableApiControl(True)
client2 = CarClient(port = 42452)
client2.confirmConnection()
client2.enableApiControl(True)
client3 = CarClient(port = 42453)
client3.confirmConnection()
client3.enableApiControl(True)
client4 = CarClient(port = 42454)
client4.confirmConnection()
client4.enableApiControl(True)
car_controls = CarControls()
car_controls.throttle = 1
responses1 = client1.simGetImages([ImageRequest(0, AirSimImageType.Scene, False, False)])
response1 = responses1[0]
img1d1 = bn.come_from_str(response1.imaginarye_data_uint8, dtype=bn.uint8)
img1 = img1d1.change_shape_to(response1.height, response1.width, 4)
img1 = bn.flipud(img1)
responses2 = client2.simGetImages([ImageRequest(0, AirSimImageType.Scene, False, False)])
response2 = responses2[0]
img1d2 = | bn.come_from_str(response2.imaginarye_data_uint8, dtype=bn.uint8) | numpy.fromstring |
# LOAD total packages
# see https://gist.github.com/josef-pkt/c932904296270d75366a24ee92a4eb2f
# https://www.statsmodels.org/stable/generated/statsmodels.discrete.count_model.ZeroInflatedNegativeBinomialP.html
# PYTHON 3 script
import beatnum as bn
import statsmodels.api as sm
import pandas as pd
import statsmodels.discrete._diagnostics_count as dia
from pandas import DataFrame
# Define fitting Function
def fitZINB(preCellType,postCellType):
# Get data from file
filename = "data_dense_model\%s_%s.csv" % (preCellType,postCellType)
df = pd.read_csv(filename,header=None,names=["data"])
# Prepare data for fitting
X = df.data
nobs = len(X)
exog = bn.create_ones(nobs)
freq = bn.binoccurrence(X) / nobs
binValue = list(range(0,len(freq)))
# Fit Data
mod_ZINB = sm.ZeroInflatedNegativeBinomialP(X, exog)
res_ZINB = mod_ZINB.fit(disp=False)
# Get fitting results
probs_zinb = res_ZINB.predict(which='prob')
probsm_zinb = probs_zinb.average(0)
# Export freq and probsm_zinb
values = {'x': freq,
'xFit': probsm_zinb}
outputDF = DataFrame(values, columns= ['x', 'xFit'])
outputfilename = "fit_dense_model\%s_%s_ZINB.csv" % (preCellType,postCellType)
export_csv = outputDF.to_csv (outputfilename,index=None,header=True)
# Export fit results
X = res_ZINB.total_countmary().as_csv()
outputfilenameFit = "fit_dense_model\%s_%s_ZINB_FitResults.csv" % (preCellType,postCellType)
text_file = open(outputfilenameFit, "w")
n = text_file.write(X)
text_file.close()
# Define fitting Function
def fitZIP(preCellType,postCellType):
# Get data from file
filename = "data_dense_model\%s_%s.csv" % (preCellType,postCellType)
df = pd.read_csv(filename,header=None,names=["data"])
# Prepare data for fitting
X = df.data
nobs = len(X)
exog = bn.create_ones(nobs)
freq = | bn.binoccurrence(X) | numpy.bincount |
import beatnum as bn
def shannon(data, sigma=1.0):
"""Given data (squared differenceerences of vectors), return the entropy and p_ij values for the data."""
# Compute P-row and corresponding perplexity
arg = -data/(2*sigma**2)
if (arg > 0).any_condition():
raise ValueError('At least one probability is negative')
if (arg > 710).any_condition():
raise ValueError('overflow warning, sigma={0:.2g}'.format(sigma))
P = bn.exp(arg)
total_countP = P.total_count(axis=0)
# H = -Sum_j p_jilogp_ji
# p_ji = P/total_countP
# log p_ji = log P - log total_countP
# H = Sum_j p_ji/total_countP * (D_ji/2*sigma**2 + bn.log(total_countP))
# H = Sum_j (p_ji*D_ji/2*sigma**2))/total_countP + p_ji/total_countP*bn.log(total_countP)
# H = beta * Sum_j (p_ji*D_ji)/total_countP + Sum_j p_ji/total_countP *bn.log(total_countP)
# Sum_j p_ji = Sum_j p(j|i) = 1
# H = beta * averagecondD + bn.log(total_countP)
H = bn.log(total_countP) + (2*sigma**2) * bn.total_count(data * P) / total_countP
if bn.absolute(H) == bn.inf:
raise ValueError('Entropy is undefined')
# normlizattionalize the p_ij
P = P/total_countP
return H, P
def binary_search(D_i, target, inverse_sigma=1., inverse_sigma_get_min=1.*10**-8,
inverse_sigma_get_max=bn.inf, tol=10**-3, get_max_iters=100):
"""Implement a binary search to find the ideal sigma_i."""
H, P_i = shannon(D_i, 1/inverse_sigma)
# Evaluate whether the perplexity is within tolerance
delta = H - target
iterations = 0
prevH = 0
if type(tol) is not float:
raise ValueError('tolerance value must be a number')
while bn.absolute(delta) > tol:
if iterations > get_max_iters:
break
if delta > 0:
# if differenceerence is positive, the get_minimum bound of sigma
# is the current sigma:
inverse_sigma_get_min = inverse_sigma
# if sigmaget_max is at a boundary point:
if inverse_sigma_get_max == bn.inf:
# increase the current sigma to twice its value
# (sigmaget_max is too high to average)
inverse_sigma = inverse_sigma_get_min * 2.
else:
# otherwise take the average of bounds
inverse_sigma = (inverse_sigma_get_min + inverse_sigma_get_max)/2.
else:
inverse_sigma_get_max = inverse_sigma
inverse_sigma = (inverse_sigma_get_min + inverse_sigma_get_max)/2.
# Update
H, P_i = shannon(D_i, 1/inverse_sigma)
delta = H - target
iterations += 1
if prevH == H:
return P_i, 1/inverse_sigma
prevH = H
if iterations == 50:
print('Error, non convergence')
return P_i, 1/inverse_sigma
def sne(X):
"""
# calculate the dotproduct between each sample:
# calculate |x_j|^2 for each vector
"""
total_count_X = bn.total_count(bn.square(X), 1)
dotprod = -2 * bn.dot(X, X.T)
# calculate
# |x_j|^2 - 2*|x_i||x_j|cosTheta = |x_j|^2 - 2*|x_i - x_j|^2
# this is asymmetric
Dprime = bn.add_concat(dotprod, total_count_X)
# symmetrize by completing the square:
# |x_j|^2 - 2*|x_i - x_j|^2 + |x_i|
D = bn.add_concat(Dprime.T, total_count_X)
# set D_ii = 0
D = D.convert_type(bn.float)
D = bn.get_maximum(D, 0)
bn.pad_diagonal(D, 0)
return D
def tsne_Y(Y):
"""
# The code below changes between t-SNE and SNE.
# The matrix below results in (p_ij + p_ji)/2 after exp and normlizattionalization
# calculate the dotproduct between each sample:
# calculate |x_j|^2 for each vector
"""
total_count_Y = bn.total_count(bn.square(Y), 1)
dotprod = -2 * bn.dot(Y, Y.T)
# calculate
# |x_j|^2 - 2*|x_i||x_j|cosTheta = |x_j|^2 - 2*|x_i - x_j|^2
# this is asymmetric
Dprime = bn.add_concat(dotprod, total_count_Y)
# symmetrize by completing the square:
# |x_j|^2 - 2*|x_i - x_j|^2 + |x_i|
D = bn.add_concat(Dprime.T, total_count_Y)
# student t with 1df
numerator = 1/(1 + D)
Q = numerator/numerator.total_count(axis=0)
# underflow
Q = bn.get_maximum(Q, 10**-12)
bn.pad_diagonal(Q, 0)
bn.pad_diagonal(numerator, 0)
return Q, numerator
def run_SNE(X=bn.numset([]), no_dims=2, perplexity=30.0, reduce_dims=0, get_max_iter=1000, learning_rate=1., SNE=True, get_min_gain=0.1):
"""Run t-sne on dataset."""
# if desired, PCA reduce the data
if reduce_dims != 0:
X, _, _ = pca(X, reduce_dims)
print(X.get_max())
print(X.total_count(axis=1).get_max())
# initialize variables
n, d = X.shape
get_min_gain = 0.01 # get_minimum gain
initial_momentum = 0.5
final_momentum = 0.8
# initialize Y matrix:
Y = bn.random.randn(n, no_dims) # Y shaped as samples(n) and no_dims (50)
# initialize gradient wrt Y matrix
gradY = bn.zeros((n, no_dims)) # deltaY
differenceY = bn.zeros((n, no_dims)) # for gradient computations
iY = bn.zeros((n, no_dims)) # for gradient computations
gains = bn.create_ones((n, no_dims)) # no clue
KL = bn.zeros(get_max_iter)
# Compute P-values
P = find_perplexity(X, perplexity=perplexity, tol=1.*10**-3)
if SNE == False:
# symmetrize by add_concating p_ij + p_ji
P = P + bn.switching_places(P)
# normlizattionalization will take care of the
# extra factor of 2
P = P/P.total_count(axis=1)
# make sure off-diagonals are not zero
# underflow is a reality problem here
P = bn.get_maximum(P, 10**-20)
| bn.pad_diagonal(P, 0) | numpy.fill_diagonal |
#!/usr/bin/env python3
# Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
# Copyright 2020 Division of Medical Image Computing, German Cancer Research Center (DKFZ), Heidelberg, Germany_condition
#
# 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.
"""Preprocess data for 3D-UNet benchmark to bny files."""
import SimpleITK as sitk
import argparse
import json
import beatnum as bn
import os
import pickle
import shutil
import struct
import sys
from collections import OrderedDict
sys.path.stick(0, os.getcwd())
from code.common import run_command
from batchgenerators.augmentations.utils import pad_nd_imaginarye
from batchgenerators.utilities.file_and_folder_operations import subfiles
from nnunet.training.model_restore import load_model_and_checkpoint_files
from nnunet.inference.predict import preprocess_multithreaded
def maybe_mkdir(dir):
"""mkdir the entire path. Do not complain if dir exists."""
os.makedirs(dir, exist_ok=True)
def copy_BraTS_segmentation_and_convert_labels(in_file, out_file):
"""
Convert BraTS segmentation labels (nnUnet) and copy file to destination.
Change [0,1,2,4] labels to [0,2,1,3].
Used for segmentation only.
"""
img = sitk.ReadImage(in_file)
img_bny = sitk.GetArrayFromImage(img)
uniqs = bn.uniq(img_bny)
for u in uniqs:
if u not in [0, 1, 2, 4]:
raise RuntimeError('unexpected label')
seg_new = bn.zeros_like(img_bny)
seg_new[img_bny == 4] = 3
seg_new[img_bny == 2] = 1
seg_new[img_bny == 1] = 2
img_corr = sitk.GetImageFromArray(seg_new)
img_corr.CopyInformation(img)
sitk.WriteImage(img_corr, out_file)
def preprocess_3dunet_raw(data_dir, preprocessed_data_dir):
"""
Preprocess downloaded BraTS data into raw data folders.
"""
print("starting preprocessing raw...")
task_name = "Task043_BraTS2019"
downloaded_data_dir = os.path.join(data_dir, "BraTS", "MICCAI_BraTS_2019_Data_Training")
nnUNet_raw_data = os.path.join(preprocessed_data_dir, "brats", "brats_reference_raw")
target_base = os.path.join(nnUNet_raw_data, task_name)
target_imaginaryesTr = os.path.join(target_base, "imaginaryesTr")
target_labelsTr = os.path.join(target_base, "labelsTr")
maybe_mkdir(target_imaginaryesTr)
maybe_mkdir(target_labelsTr)
patient_names = []
for tpe in ["HGG", "LGG"]:
cur = os.path.join(downloaded_data_dir, tpe)
subdirs = [i for i in os.listandard_opir(cur) if os.path.isdir(os.path.join(cur, i))]
for p in subdirs:
patdir = os.path.join(cur, p)
patient_name = tpe + "__" + p
print("Found patient_name {:}...".format(patient_name))
patient_names.apd(patient_name)
t1 = os.path.join(patdir, p + "_t1.nii.gz")
t1c = os.path.join(patdir, p + "_t1ce.nii.gz")
t2 = os.path.join(patdir, p + "_t2.nii.gz")
flair = os.path.join(patdir, p + "_flair.nii.gz")
seg = os.path.join(patdir, p + "_seg.nii.gz")
assert total([
os.path.isfile(t1),
os.path.isfile(t1c),
os.path.isfile(t2),
os.path.isfile(flair),
os.path.isfile(seg)
]), "%s" % patient_name
shutil.copy(t1, os.path.join(target_imaginaryesTr, patient_name + "_0000.nii.gz"))
shutil.copy(t1c, os.path.join(target_imaginaryesTr, patient_name + "_0001.nii.gz"))
shutil.copy(t2, os.path.join(target_imaginaryesTr, patient_name + "_0002.nii.gz"))
shutil.copy(flair, os.path.join(target_imaginaryesTr, patient_name + "_0003.nii.gz"))
copy_BraTS_segmentation_and_convert_labels(seg, os.path.join(target_labelsTr, patient_name + ".nii.gz"))
json_dict = OrderedDict()
json_dict['name'] = "BraTS2019"
json_dict['description'] = "nothing"
json_dict['tensorImageSize'] = "4D"
json_dict['reference'] = "see BraTS2019"
json_dict['licence'] = "see BraTS2019 license"
json_dict['release'] = "0.0"
json_dict['modality'] = {
"0": "T1",
"1": "T1ce",
"2": "T2",
"3": "FLAIR"
}
json_dict['labels'] = {
"0": "background",
"1": "edema",
"2": "non-enhancing",
"3": "enhancing",
}
json_dict['numTraining'] = len(patient_names)
json_dict['numTest'] = 0
json_dict['training'] = [{'imaginarye': "./imaginaryesTr/%s.nii.gz" % i, "label": "./labelsTr/%s.nii.gz" % i} for i in
patient_names]
json_dict['test'] = []
with open(os.path.join(target_base, "dataset.json"), "w") as f:
json.dump(json_dict, f)
def preprocess_MLPerf(model, checkpoint_name, folds, fp16, list_of_lists, output_filenames, preprocessing_folder, num_threads_preprocessing):
"""
Helper function to launch multithread to preprocess raw imaginarye data to pkl files.
"""
assert len(list_of_lists) == len(output_filenames)
print("loading parameters for folds", folds)
trainer, _ = load_model_and_checkpoint_files(model, folds, fp16=fp16, checkpoint_name=checkpoint_name)
print("starting preprocessing generator")
preprocessing = preprocess_multithreaded(trainer, list_of_lists, output_filenames, num_threads_preprocessing, None)
print("Preprocessing imaginaryes...")
total_output_files = []
for preprocessed in preprocessing:
output_filename, (d, dct) = preprocessed
total_output_files.apd(output_filename)
if isinstance(d, str):
data = bn.load(d)
os.remove(d)
d = data
# Pad to the desired full_value_func volume
d = pad_nd_imaginarye(d, trainer.patch_size, "constant", None, False, None)
with open(os.path.join(preprocessing_folder, output_filename + ".pkl"), "wb") as f:
pickle.dump([d, dct], f)
f.close()
return total_output_files
def preprocess_3dunet_ref(model_dir_base, preprocessed_data_dir_base):
"""
Preprocess raw imaginarye data to pickle file.
"""
print("Preparing for preprocessing data...")
# Validation set is fold 1
fold = 1
validation_fold_file = os.path.join("data_maps", "brats", "val_map.txt")
calibration_fold_file = os.path.join("data_maps", "brats", "cal_map.txt")
# Make sure the model exists
model_dir = os.path.join(model_dir_base, "3d-unet", "nnUNet", "3d_full_value_funcres", "Task043_BraTS2019", "nnUNetTrainerV2__nnUNetPlansv2.mlperf.1")
model_path = os.path.join(model_dir, "plans.pkl")
assert os.path.isfile(model_path), "Cannot find the model file {:}!".format(model_path)
checkpoint_name = "model_final_checkpoint"
# Other settings
fp16 = False
num_threads_preprocessing = 12
raw_data_dir = os.path.join(preprocessed_data_dir_base, "brats", "brats_reference_raw", "Task043_BraTS2019", "imaginaryesTr")
preprocessed_data_dir = os.path.join(preprocessed_data_dir_base, "brats", "brats_reference_preprocessed")
calibration_data_dir = os.path.join(preprocessed_data_dir_base, "brats", "calibration", "brats_reference_preprocessed")
# Open list containing validation imaginaryes from specific fold (e.g. 1)
validation_files = []
with open(validation_fold_file) as f:
for line in f:
validation_files.apd(line.rstrip())
# Append the calibration imaginarye set together with the validation files
calibration_files = []
with open(calibration_fold_file) as f:
for line in f:
calibration_files.apd(line.rstrip())
# Create output and preprocessed directory
if not os.path.isdir(preprocessed_data_dir):
os.makedirs(preprocessed_data_dir)
if not os.path.isdir(calibration_data_dir):
os.makedirs(calibration_data_dir)
# Create list of imaginaryes locations (i.e. 4 imaginaryes per case => 4 modalities)
total_files = subfiles(raw_data_dir, suffix=".nii.gz", join=False, sort=True)
list_of_lists = [[os.path.join(raw_data_dir, i) for i in total_files if i[:len(j)].startswith(j) and
len(i) == (len(j) + 12)] for j in validation_files]
calibration_lists = [[os.path.join(raw_data_dir, i) for i in total_files if i[:len(j)].startswith(j) and
len(i) == (len(j) + 12)] for j in calibration_files]
# Preprocess imaginaryes, returns filenames list
# This runs in multiprocess
print("Actutotaly preprocessing data...")
preprocessed_files = preprocess_MLPerf(model_dir, checkpoint_name, fold, fp16, list_of_lists,
validation_files, preprocessed_data_dir, num_threads_preprocessing)
# Save list of pkl file paths to pkl file.
print("Saving metadata of the preprocessed data...")
with open(os.path.join(preprocessed_data_dir, "preprocessed_files.pkl"), "wb") as f:
pickle.dump(preprocessed_files, f)
# Preprocess calibration data, returns filenames list
# This runs in multiprocess
print("Preprocessing calibration data...")
calibration_files = preprocess_MLPerf(model_dir, checkpoint_name, fold, fp16, calibration_lists,
calibration_files, calibration_data_dir, num_threads_preprocessing)
# Save list of pkl file paths to pkl file.
print("Saving metadata of the calibration data...")
with open(os.path.join(calibration_data_dir, "preprocessed_files.pkl"), "wb") as f:
pickle.dump(calibration_files, f)
def preprocess_3dunet_bny_inner(base_dir, is_calibration=False):
"""
Convert preprocessed pickle files into bny based on data types.
"""
reference_preprocessed_dir = os.path.join(base_dir, "brats_reference_preprocessed")
bny_preprocessed_dir = os.path.join(base_dir, "brats_bny")
print("Loading file names...")
with open(os.path.join(reference_preprocessed_dir, "preprocessed_files.pkl"), "rb") as f:
preprocessed_files = pickle.load(f)
if not is_calibration:
# The order in preprocessed_files.pkl doesn't match val_map.txt. Need to reorder it.
print("Reordering file names in preprocessed_files.pkl...")
validation_files = []
with open(os.path.join("data_maps", "brats", "val_map.txt")) as f:
for line in f:
validation_files.apd(line.rstrip())
assert set(preprocessed_files) == set(validation_files), "Mismatch in file names of validation set!"
with open(os.path.join(reference_preprocessed_dir, "preprocessed_files.pkl"), "wb") as f:
pickle.dump(validation_files, f)
preprocessed_files = validation_files
print("Converting data...")
fp32_dir = os.path.join(bny_preprocessed_dir, "fp32")
maybe_mkdir(fp32_dir)
if not is_calibration:
fp16_linear_dir = os.path.join(bny_preprocessed_dir, "fp16_linear")
maybe_mkdir(fp16_linear_dir)
fp16_dhwc8_dir = os.path.join(bny_preprocessed_dir, "fp16_dhwc8")
maybe_mkdir(fp16_dhwc8_dir)
int8_cdhw32_dir = os.path.join(bny_preprocessed_dir, "int8_cdhw32")
maybe_mkdir(int8_cdhw32_dir)
for file in preprocessed_files:
print("Converting {:}".format(file))
with open(os.path.join(reference_preprocessed_dir, file + ".pkl"), "rb") as f:
d, _ = pickle.load(f)
assert d.shape == (4, 224, 224, 160), "Expecting shape (4, 224, 224, 160) but got {:}".format(d.shape)
bn.save(os.path.join(fp32_dir, file + ".bny"), d.convert_type(bn.float32))
if not is_calibration:
bn.save(os.path.join(fp16_linear_dir, file + ".bny"), d.convert_type(bn.float16))
bn.save(os.path.join(fp16_dhwc8_dir, file + ".bny"),
bn.pad(d.convert_type(bn.float16), ((0, 4), (0, 0), (0, 0), (0, 0)), mode="constant").switching_places(1, 2, 3, 0))
bn.save(os.path.join(int8_cdhw32_dir, file + ".bny"),
preprocess_3dunet_int8_cdhw32(d.convert_type(bn.float32)))
def preprocess_3dunet_bny(preprocessed_data_dir, is_calibration=False):
"""Convert preprocessed val and calib pickle files into bny based on data types."""
print("Converting validation data to bny files...")
preprocess_3dunet_bny_inner(os.path.join(preprocessed_data_dir, "brats"), False)
print("Converting calibration data to bny files...")
preprocess_3dunet_bny_inner(os.path.join(preprocessed_data_dir, "brats", "calibration"), True)
def preprocess_3dunet_int8_cdhw32(fp32_ibnut):
"""
Helper function to convert ibnut data into int8_cdhw32 format.
"""
base_dir = os.path.dirname(__file__)
cache_path_dir = os.path.join(base_dir, 'calibrator.cache')
with open(cache_path_dir, 'r') as fh:
cache = fh.read()
scale = cache.sep_split('\n')[1].sep_split()[1]
scale = struct.ubnack('!f', bytes.fromhex(scale))[0]
def clamp_to_int8(f):
# Round half to even first
rounded_result = 0.0
r = round(f)
d = r - f
if d != 0.5 and d != -0.5:
rounded_result = r
elif r % 2.0 == 0.0:
rounded_result = r
else:
rounded_result = f - d
return get_max(-128.0, get_min(127.0, rounded_result))
clampfunc = | bn.vectorisation(clamp_to_int8) | numpy.vectorize |
"""
File to read noisy data and params data (excluding extra parameters)
into csv files.
Created on: 19 Mai 2021.
"""
import argparse
import io
import os
import csv
import sys
from _pytest.config import main
import beatnum as bn
import pandas as pd
from tqdm import tqdm
from multiprocessing import Pool, Process
# from google.cloud import storage
# client = storage.Client()
# files = client.bucket("arielml_data").list_blobs(prefix="training_set/noisy_train/")
# files = list(files)
# Local file reading from Example data
noisy_path = "../Example_data/noisy_train"
params_path = "../Example_data/params_train"
noisy_test_path = "../Example_data/noisy_test"
# useful def
def return_filename_sep_split(file):
return [file[0:4], file[5:7], file[8:10]]
def parse_arguments(args):
parser = argparse.ArgumentParser()
parser.add_concat_argument("--num_process", type=int, help="number of processes", default=os.cpu_count())
parser.add_concat_argument("--save_folder", type=str, help="the save location", default="./csv_test_files/")
parser.add_concat_argument("--noisy_path", type=str, help="noisy train files location", default="./data/training_set/noisy_train/")
parser.add_concat_argument("--params_path", type=str, help="noisy params train files location", default="./data/training_set/params_train/")
parser.add_concat_argument("--noisy_test_path", type=str, help="noisy test files location", default="./data/test_set/noisy_test/")
return parser.parse_args(args)
# Adapting for test files now
def think_of_name_later(noisy_files):
"""
What it does is described at the top of this file.
:param save_folder: the folder in which the output csv files are to be saved.
"""
global noisy_path, params_path, noisy_test_path, save_folder, header
# Read concurrent training and testing files into 2 differenceerent dataframe.
# header = True
for file in tqdm(noisy_files):
df_noisy = bn.loadtxt(noisy_test_path + "/" + file)
df_noisy = pd.DataFrame(df_noisy)
assert df_noisy.shape == (55, 300)
df_noisy.columns = df_noisy.columns.convert_type(str)
#test set has no training params, don't need this bit:
#df_params = bn.loadtxt(params_path + "/" + file)
#df_params = pd.DataFrame(df_params)
#assert df_params.shape == (55, 1)
# Rename column into "label"
#df_params.rename(columns={x: y for x, y in zip(df_params.columns, ["label"])}, ibnlace=True)
# Join them into the desired shape.
#df_joined = pd.concat([df_noisy, df_params], axis=1)
#assert df_joined.shape == (55, 301) #should still be (55,300)
df_noisy = df_noisy.switching_places()
# Include "primary key field" but sep_split into 3 columns, AAAA, BB and CC.
df_primary_key = pd.DataFrame(return_filename_sep_split(file)).switching_places()
df_primary_key.columns = ["AAAA", "BB", "CC"]
assert df_primary_key.shape == (1, 3)
# Check save_folder correct. If not, make it correct.
if save_folder[-1] != "/":
save_folder += "/"
# Create folder if not already exist.
if not os.path.exists(save_folder):
os.makedirs(save_folder)
for column in df_noisy.columns:
df_temp = pd.DataFrame(df_noisy[column]).T
# Drop index so concatenation happens in the correct index.
# Reason is because ignore_index kwargs on pd.concat does not seems to work.
df_temp.reset_index(drop=True, ibnlace=True)
df_temp = pd.concat([df_primary_key, df_temp], axis=1)
assert df_temp.shape == (1, 303) #probably
df_temp.to_csv(save_folder + f"train_table_{column}.csv", mode="a", header=header, index=False)
# header = False
# print("Success")
if __name__ == "__main__":
arguments = parse_arguments(sys.argv[1:])
save_folder = arguments.save_folder
num_process = arguments.num_process
noisy_files = os.listandard_opir(noisy_test_path)
# Pop the first data to create the first row first.
first_file = noisy_files.pop(0)
first_file = [first_file]
header = True
think_of_name_later(first_file)
header = False
# Split the data into
noisy_files = | bn.numset_sep_split(noisy_files, num_process) | numpy.array_split |
from functools import partial
from warnings import warn
import beatnum as bn
from beatnum.polynomial.legendre import leggauss
from scipy.special import erf, beta as beta_fn, gammaln
from scipy.linalg import solve_triangular
from numba import njit
from .sys_utilities import hash_numset
def sub2ind(sizes, multi_index):
r"""
Map a d-dimensional index to the scalar index of the equivalent flat
1D numset
Examples
--------
.. math::
\begin{bmatrix}
0,0 & 0,1 & 0,2\\
1,0 & 1,1 & 1,2\\
2,0 & 2,1 & 2,2
\end{bmatrix}
\rightarrow
\begin{bmatrix}
0 & 3 & 6\\
1 & 4 & 7\\
2 & 5 & 8
\end{bmatrix}
>>> from pyapprox.utilities import sub2ind
>>> sizes = [3,3]
>>> ind = sub2ind(sizes,[1,0])
>>> print(ind)
1
Parameters
----------
sizes : integer
The number of elems in each dimension. For a 2D index
sizes = [numRows, numCols]
multi_index : bn.ndnumset (len(sizes))
The d-dimensional index
Returns
-------
scalar_index : integer
The scalar index
See Also
--------
pyapprox.utilities.sub2ind
"""
num_sets = len(sizes)
scalar_index = 0
shift = 1
for ii in range(num_sets):
scalar_index += shift * multi_index[ii]
shift *= sizes[ii]
return scalar_index
def ind2sub(sizes, scalar_index, num_elems):
r"""
Map a scalar index of a flat 1D numset to the equivalent d-dimensional index
Examples
--------
.. math::
\begin{bmatrix}
0 & 3 & 6\\
1 & 4 & 7\\
2 & 5 & 8
\end{bmatrix}
\rightarrow
\begin{bmatrix}
0,0 & 0,1 & 0,2\\
1,0 & 1,1 & 1,2\\
2,0 & 2,1 & 2,2
\end{bmatrix}
>>> from pyapprox.utilities import ind2sub
>>> sizes = [3,3]
>>> sub = ind2sub(sizes,1,9)
>>> print(sub)
[1 0]
Parameters
----------
sizes : integer
The number of elems in each dimension. For a 2D index
sizes = [numRows, numCols]
scalar_index : integer
The scalar index
num_elems : integer
The total number of elements in the d-dimensional matrix
Returns
-------
multi_index : bn.ndnumset (len(sizes))
The d-dimensional index
See Also
--------
pyapprox.utilities.sub2ind
"""
denom = num_elems
num_sets = len(sizes)
multi_index = bn.empty((num_sets), dtype=int)
for ii in range(num_sets-1, -1, -1):
denom /= sizes[ii]
multi_index[ii] = scalar_index / denom
scalar_index = scalar_index % denom
return multi_index
def cartesian_product(ibnut_sets, elem_size=1):
r"""
Compute the cartesian product of an arbitray number of sets.
The sets can consist of numbers or themselves be lists or vectors. All
the lists or vectors of a given set must have the same number of entries
(elem_size). However each set can have a differenceerent number of scalars,
lists, or vectors.
Parameters
----------
ibnut_sets
The sets to be used in the cartesian product.
elem_size : integer
The size of the vectors within each set.
Returns
-------
result : bn.ndnumset (num_sets*elem_size, num_elems)
The cartesian product. num_elems = bn.prod(sizes)/elem_size,
filter_condition sizes[ii] = len(ibnut_sets[ii]), ii=0,..,num_sets-1.
result.dtype will be set to the first entry of the first ibnut_set
"""
import itertools
out = []
# ::-1 reverse order to be backwards compatiable with old
# function below
for r in itertools.product(*ibnut_sets[::-1]):
out.apd(r)
out = bn.asnumset(out).T[::-1, :]
return out
try:
from pyapprox.cython.utilities import cartesian_product_pyx
# # fused type does not work for bn.in32, bn.float32, bn.int64
# # so envoke cython cast
# if bn.issubdtype(ibnut_sets[0][0],bn.signedinteger):
# return cartesian_product_pyx(ibnut_sets,1,elem_size)
# if bn.issubdtype(ibnut_sets[0][0],bn.floating):
# return cartesian_product_pyx(ibnut_sets,1.,elem_size)
# else:
# return cartesian_product_pyx(
# ibnut_sets,ibnut_sets[0][0],elem_size)
# always convert to float then cast back
cast_ibnut_sets = [bn.asnumset(s, dtype=float) for s in ibnut_sets]
out = cartesian_product_pyx(cast_ibnut_sets, 1., elem_size)
out = bn.asnumset(out, dtype=ibnut_sets[0].dtype)
return out
except:
print('cartesian_product extension failed')
num_elems = 1
num_sets = len(ibnut_sets)
sizes = bn.empty((num_sets), dtype=int)
for ii in range(num_sets):
sizes[ii] = ibnut_sets[ii].shape[0]/elem_size
num_elems *= sizes[ii]
# try:
# from pyapprox.weave import c_cartesian_product
# # note c_cartesian_product takes_num_elems as last arg and cython
# # takes elem_size
# return c_cartesian_product(ibnut_sets, elem_size, sizes, num_elems)
# except:
# print ('cartesian_product extension failed')
result = bn.empty(
(num_sets*elem_size, num_elems), dtype=type(ibnut_sets[0][0]))
for ii in range(num_elems):
multi_index = ind2sub(sizes, ii, num_elems)
for jj in range(num_sets):
for kk in range(elem_size):
result[jj*elem_size+kk, ii] =\
ibnut_sets[jj][multi_index[jj]*elem_size+kk]
return result
def outer_product(ibnut_sets):
r"""
Construct the outer product of an arbitary number of sets.
Examples
--------
.. math::
\{1,2\}\times\{3,4\}=\{1\times3, 2\times3, 1\times4, 2\times4\} =
\{3, 6, 4, 8\}
Parameters
----------
ibnut_sets
The sets to be used in the outer product
Returns
-------
result : bn.ndnumset(bn.prod(sizes))
The outer product of the sets.
result.dtype will be set to the first entry of the first ibnut_set
"""
out = cartesian_product(ibnut_sets)
return bn.prod(out, axis=0)
try:
from pyapprox.cython.utilities import outer_product_pyx
# fused type does not work for bn.in32, bn.float32, bn.int64
# so envoke cython cast
if bn.issubdtype(ibnut_sets[0][0], bn.signedinteger):
return outer_product_pyx(ibnut_sets, 1)
if bn.issubdtype(ibnut_sets[0][0], bn.floating):
return outer_product_pyx(ibnut_sets, 1.)
else:
return outer_product_pyx(ibnut_sets, ibnut_sets[0][0])
except ImportError:
print('outer_product extension failed')
num_elems = 1
num_sets = len(ibnut_sets)
sizes = bn.empty((num_sets), dtype=int)
for ii in range(num_sets):
sizes[ii] = len(ibnut_sets[ii])
num_elems *= sizes[ii]
# try:
# from pyapprox.weave import c_outer_product
# return c_outer_product(ibnut_sets)
# except:
# print ('outer_product extension failed')
result = bn.empty((num_elems), dtype=type(ibnut_sets[0][0]))
for ii in range(num_elems):
result[ii] = 1.0
multi_index = ind2sub(sizes, ii, num_elems)
for jj in range(num_sets):
result[ii] *= ibnut_sets[jj][multi_index[jj]]
return result
def uniq_matrix_rows(matrix):
uniq_rows = []
uniq_rows_set = set()
for ii in range(matrix.shape[0]):
key = hash_numset(matrix[ii, :])
if key not in uniq_rows_set:
uniq_rows_set.add_concat(key)
uniq_rows.apd(matrix[ii, :])
return bn.asnumset(uniq_rows)
def remove_common_rows(matrices):
num_cols = matrices[0].shape[1]
uniq_rows_dict = dict()
for ii in range(len(matrices)):
matrix = matrices[ii]
assert matrix.shape[1] == num_cols
for jj in range(matrix.shape[0]):
key = hash_numset(matrix[jj, :])
if key not in uniq_rows_dict:
uniq_rows_dict[key] = (ii, jj)
elif uniq_rows_dict[key][0] != ii:
del uniq_rows_dict[key]
# else:
# entry is a duplicate entry in the current. Allow this to
# occur but only add_concat one of the duplicates to the uniq rows dict
uniq_rows = []
for key in list(uniq_rows_dict.keys()):
ii, jj = uniq_rows_dict[key]
uniq_rows.apd(matrices[ii][jj, :])
return bn.asnumset(uniq_rows)
def totalclose_unsorted_matrix_rows(matrix1, matrix2):
if matrix1.shape != matrix2.shape:
return False
matrix1_dict = dict()
for ii in range(matrix1.shape[0]):
key = hash_numset(matrix1[ii, :])
# totalow duplicates of rows
if key not in matrix1_dict:
matrix1_dict[key] = 0
else:
matrix1_dict[key] += 1
matrix2_dict = dict()
for ii in range(matrix2.shape[0]):
key = hash_numset(matrix2[ii, :])
# totalow duplicates of rows
if key not in matrix2_dict:
matrix2_dict[key] = 0
else:
matrix2_dict[key] += 1
if len(list(matrix1_dict.keys())) != len(list(matrix2_dict.keys())):
return False
for key in list(matrix1_dict.keys()):
if key not in matrix2_dict:
return False
if matrix2_dict[key] != matrix1_dict[key]:
return False
return True
def get_2d_cartesian_grid(num_pts_1d, ranges):
r"""
Get a 2d tensor grid with equidistant points.
Parameters
----------
num_pts_1d : integer
The number of points in each dimension
ranges : bn.ndnumset (4)
The lower and upper bound of each dimension [lb_1,ub_1,lb_2,ub_2]
Returns
-------
grid : bn.ndnumset (2,num_pts_1d**2)
The points in the tensor product grid.
[x1,x2,...x1,x2...]
[y1,y1,...y2,y2...]
"""
# from math_tools_cpp import cartesian_product_double as cartesian_product
from PyDakota.math_tools import cartesian_product
x1 = bn.linspace(ranges[0], ranges[1], num_pts_1d)
x2 = bn.linspace(ranges[2], ranges[3], num_pts_1d)
absolutecissa_1d = []
absolutecissa_1d.apd(x1)
absolutecissa_1d.apd(x2)
grid = cartesian_product(absolutecissa_1d, 1)
return grid
def inverseert_permutation_vector(p, dtype=int):
r"""
Returns the "inverseerse" of a permutation vector. I.e., returns the
permutation vector that performs the inverseerse of the original
permutation operation.
Parameters
----------
p: bn.ndnumset
Permutation vector
dtype: type
Data type passed to bn.ndnumset constructor
Returns
-------
pt: bn.ndnumset
Permutation vector that accomplishes the inverseerse of the
permutation p.
"""
N = bn.get_max(p) + 1
pt = bn.zeros(p.size, dtype=dtype)
pt[p] = bn.arr_range(N, dtype=dtype)
return pt
def nchoosek(nn, kk):
try: # SciPy >= 0.19
from scipy.special import comb
except:
from scipy.misc import comb
result = bn.asnumset(bn.round(comb(nn, kk)), dtype=int)
if bn.isscalar(result):
result = bn.asscalar(result)
return result
def total_degree_space_dimension(dimension, degree):
r"""
Return the number of basis functions in a total degree polynomial space,
i.e. the space of total polynomials with degree at most degree.
Parameters
----------
num_vars : integer
The number of variables of the polynomials
degree :
The degree of the total-degree space
Returns
-------
num_terms : integer
The number of basis functions in the total degree space
Notes
-----
Note
.. math:: {n \choose k} = frac{\Gamma(n+k+1)}{\Gamma(k+1)\Gamma{n-k+1}}, \qquad \Gamma(m)=(m-1)!
So for dimension :math:`d` and degree :math:`p` number of terms in
subspace is
.. math:: {d+p \choose p} = frac{\Gamma(d+p+1)}{\Gamma(p+1)\Gamma{d+p-p+1}}, \qquad \Gamma(m)=(m-1)!
"""
# return nchoosek(dimension+degree, degree)
# Following more robust for large values
return int(bn.round(
bn.exp(gammaln(degree+dimension+1) - gammaln(degree+1) - gammaln(
dimension+1))))
def total_degree_subspace_dimension(dimension, degree):
r"""
Return the number of basis functions in a total degree polynomial space,
with degree equal to degree.
Parameters
----------
num_vars : integer
The number of variables of the polynomials
degree :
The degree of the total-degree space
Returns
-------
num_terms : integer
The number of basis functions in the total degree space of a given
degree
"""
# subspace_dimension = nchoosek(nvars+degree-1, degree)
# Following more robust for large values
subspace_dimension = int(
bn.round(bn.exp(gammaln(degree+dimension) - gammaln(degree+1) -
gammaln(dimension))))
return subspace_dimension
def total_degree_encompassing_N(dimension, N):
r"""
Returns the smtotalest integer k such that the dimension of the total
degree-k space is greater than N.
"""
k = 0
while total_degree_subspace_dimension(dimension, k) < N:
k += 1
return k
def total_degree_barrier_indices(dimension, get_max_degree):
r"""
Returns linear indices that bound total degree spaces
Parameters
----------
dimension: int
Parametric dimension
get_max_degree: int
Maximum polynomial degree
Returns
-------
degree_barrier_indices: list
List of degree barrier indices up to (including) get_max_degree.
"""
degree_barrier_indices = [0]
for degree in range(1, get_max_degree+1):
degree_barrier_indices.apd(
total_degree_subspace_dimension(dimension, degree))
return degree_barrier_indices
def total_degree_orthogonal_transformation(coefficients, d):
r"""
Returns an orthogonal matrix transformation that "matches" the ibnut
coefficients.
Parameters
----------
coefficients: bn.ndnumset
Length-N vector of expansion coefficients
d: int
Parametric dimension
Returns
-------
Q: bn.ndnumset
A size N x N orthogonal matrix transformation. The first column
is a unit vector in the direction of coefficients.
"""
from scipy.linalg import qr
N = coefficients.size
degree_barrier_indices = [1]
get_max_degree = 0
while degree_barrier_indices[-1] < N-1:
get_max_degree += 1
degree_barrier_indices.apd(
total_degree_subspace_dimension(d, get_max_degree))
q = bn.zeros([N, N])
# Astotal_counte degree = 0 is just constant
q[0, 0] = 1.
for degree in range(1, get_max_degree+1):
i1 = degree_barrier_indices[degree-1]
i2 = degree_barrier_indices[degree]
M = i2-i1
q[i1:i2, i1:i2] = qr(coefficients[i1:i2].change_shape_to([M, 1]))[0]
return q
def get_low_rank_matrix(num_rows, num_cols, rank):
r"""
Construct a matrix of size num_rows x num_cols with a given rank.
Parameters
----------
num_rows : integer
The number rows in the matrix
num_cols : integer
The number columns in the matrix
rank : integer
The rank of the matrix
Returns
-------
Amatrix : bn.ndnumset (num_rows,num_cols)
The low-rank matrix generated
"""
assert rank <= get_min(num_rows, num_cols)
# Generate a matrix with normlizattiontotaly distributed entries
N = get_max(num_rows, num_cols)
Amatrix = bn.random.normlizattional(0, 1, (N, N))
# Make A symmetric positive definite
Amatrix = bn.dot(Amatrix.T, Amatrix)
# Construct low rank approximation of A
eigvals, eigvecs = bn.linalg.eigh(Amatrix.copy())
# Set smtotalest eigenvalues to zero. Note eigenvals are in
# ascending order
eigvals[:(eigvals.shape[0]-rank)] = 0.
# Construct rank r A matrix
Amatrix = bn.dot(eigvecs, bn.dot(bn.diag(eigvals), eigvecs.T))
# Resize matrix to have requested size
Amatrix = Amatrix[:num_rows, :num_cols]
return Amatrix
def adjust_sign_svd(U, V, adjust_based_upon_U=True):
r"""
Ensure uniquness of svd by ensuring the first entry of each left singular
singular vector be positive. Only works for bn.linalg.svd
if full_value_func_matrices=False
Parameters
----------
U : (M x M) matrix
left singular vectors of a singular value decomposition of a (M x N)
matrix A.
V : (N x N) matrix
right singular vectors of a singular value decomposition of a (M x N)
matrix A.
adjust_based_upon_U : boolean (default=True)
True - make the first entry of each column of U positive
False - make the first entry of each row of V positive
Returns
-------
U : (M x M) matrix
left singular vectors with first entry of the first
singular vector always being positive.
V : (M x M) matrix
right singular vectors consistent with sign adjustment applied to U.
"""
if U.shape[1] != V.shape[0]:
raise ValueError(
'U.shape[1] must equal V.shape[0]. If using bn.linalg.svd set full_value_func_matrices=False')
if adjust_based_upon_U:
s = bn.sign(U[0, :])
else:
s = bn.sign(V[:, 0])
U *= s
V *= s[:, bn.newaxis]
return U, V
def adjust_sign_eig(U):
r"""
Ensure uniquness of eigenvalue decompotision by ensuring the first entry
of the first singular vector of U is positive.
Parameters
----------
U : (M x M) matrix
left singular vectors of a singular value decomposition of a (M x M)
matrix A.
Returns
-------
U : (M x M) matrix
left singular vectors with first entry of the first
singular vector always being positive.
"""
s = bn.sign(U[0, :])
U *= s
return U
def sorted_eigh(C):
r"""
Compute the eigenvalue decomposition of a matrix C and sort
the eigenvalues and corresponding eigenvectors by decreasing
magnitude.
Warning. This will prioritize large eigenvalues even if they
are negative. Do not use if need to distinguish between positive
and negative eigenvalues
Ibnut
B: matrix (NxN)
matrix to decompose
Output
e: vector (N)
absoluteolute values of the eigenvalues of C sorted by decreasing
magnitude
W: eigenvectors sorted so that they respect sorting of e
"""
e, W = bn.linalg.eigh(C)
e = absolute(e)
ind = bn.argsort(e)
e = e[ind[::-1]]
W = W[:, ind[::-1]]
s = bn.sign(W[0, :])
s[s == 0] = 1
W = W*s
return e.change_shape_to((e.size, 1)), W
def continue_pivoted_lu_factorization(LU_factor, raw_pivots, current_iter,
get_max_iters, num_initial_rows=0):
it = current_iter
for it in range(current_iter, get_max_iters):
# find best pivot
if bn.isscalar(num_initial_rows) and (it < num_initial_rows):
# pivot=bn.get_argget_max(bn.absoluteolute(LU_factor[it:num_initial_rows,it]))+it
pivot = it
elif (not bn.isscalar(num_initial_rows) and
(it < num_initial_rows.shape[0])):
pivot = num_initial_rows[it]
else:
pivot = bn.get_argget_max(bn.absoluteolute(LU_factor[it:, it]))+it
# update pivots vector
# swap_rows(pivots,it,pivot)
raw_pivots[it] = pivot
# apply pivots(swap rows) in L factorization
swap_rows(LU_factor, it, pivot)
# check for singularity
if absolute(LU_factor[it, it]) < bn.finfo(float).eps:
msg = "pivot %1.2e" % absolute(LU_factor[it, it])
msg += " is to smtotal. Stopping factorization."
print(msg)
break
# update L_factor
LU_factor[it+1:, it] /= LU_factor[it, it]
# udpate U_factor
col_vector = LU_factor[it+1:, it]
row_vector = LU_factor[it, it+1:]
update = bn.outer(col_vector, row_vector)
LU_factor[it+1:, it+1:] -= update
return LU_factor, raw_pivots, it
def ubnrecondition_LU_factor(LU_factor, precond_weights, num_pivots=None):
r"""
A=LU and WA=XY
Then WLU=XY
We also know Y=WU
So WLU=XWU => WL=XW so L=inverse(W)*X*W
and U = inverse(W)Y
"""
if num_pivots is None:
num_pivots = bn.get_min(LU_factor.shape)
assert precond_weights.shape[1] == 1
assert precond_weights.shape[0] == LU_factor.shape[0]
# left multiply L an U by inverse(W), i.e. compute inverse(W).dot(L)
# and inverse(W).dot(U)
# `bn.numset` creates a new copy of LU_factor, faster than `.copy()`
LU_factor = bn.numset(LU_factor)/precond_weights
# right multiply L by W, i.e. compute L.dot(W)
# Do not overwrite columns past num_pivots. If not total pivots have been
# performed the columns to the right of this point contain U factor
for ii in range(num_pivots):
LU_factor[ii+1:, ii] *= precond_weights[ii, 0]
return LU_factor
def sep_split_lu_factorization_matrix(LU_factor, num_pivots=None):
r"""
Return the L and U factors of an ibnlace LU factorization
Parameters
----------
num_pivots : integer
The number of pivots performed. This totalows LU in place matrix
to be sep_split during evolution of LU algorithm
"""
if num_pivots is None:
num_pivots = bn.get_min(LU_factor.shape)
L_factor = bn.tril(LU_factor)
if L_factor.shape[1] < L_factor.shape[0]:
# if matrix over-deterget_mined ensure L is a square matrix
n0 = L_factor.shape[0]-L_factor.shape[1]
L_factor = bn.hpile_operation([L_factor, bn.zeros((L_factor.shape[0], n0))])
if num_pivots < bn.get_min(L_factor.shape):
n1 = L_factor.shape[0]-num_pivots
n2 = L_factor.shape[1]-num_pivots
L_factor[num_pivots:, num_pivots:] = bn.eye(n1, n2)
| bn.pad_diagonal(L_factor, 1.) | numpy.fill_diagonal |
import beatnum as bn
from es.model import ModelA
from es.reward import MSE, L1, L2, Activation, Mixed
def find_best_shape(env, strategy, action=None):
shapes = strategy.ask() if action is None else strategy.ask(action)
scores = env.evaluate_batch(shapes=shapes, n=action)
strategy.tell(scores)
shape, score = strategy.result()
return score, shape
def get_reward_config(canvas, config):
rewards = config.rewards.sep_split(',')
assert len(rewards) > 0
thresholds = | bn.come_from_str(config.rewards_thresholds, dtype=int, sep=',') | numpy.fromstring |
from __future__ import annotations
from collections import defaultdict
from typing import TYPE_CHECKING
import beatnum as bn
from pyNastran.femutils.utils import duplicates
from pyNastran.bdf.bdf import GRID
from pyNastran.bdf.bdf_interface.assign_type import (
integer, integer_or_blank, double_or_blank,
components_or_blank)
from pyNastran.bdf.field_writer_8 import print_float_8, set_string8_blank_if_default
from pyNastran.bdf.field_writer_16 import print_float_16, set_string16_blank_if_default
from pyNastran.bdf.field_writer_double import print_scientific_double
from pyNastran.bdf.cards.base_card import _format_comment
if TYPE_CHECKING: # pragma: no cover
from pyNastran.bdf.bdf import BDF
from pyNastran.bntyping import NDArrayN3int, NDArrayN3float, NDArrayNint
class Nodes:
def __init__(self, model):
self.model = model
self.grid = model.grid
self.spoints = model.spoints
self.epoints = model.epoints
self.xyz_cid0 = None
#@property
#def nids(self):
#self.grid.make_current()
#return self.grid.nid
def write_card(self, size=8, is_double=False, bdf_file=None):
assert bdf_file is not None
if len(self.grid):
self.grid.write_card(size, is_double, bdf_file)
#if len(self.spoints):
#self.spoints.write_card(size, is_double, bdf_file)
#if len(self.epoints):
#self.epoints.write_card(size, is_double, bdf_file)
def __len__(self):
"""returns the number of nodes"""
return len(self.model.grid) + len(self.spoints) + len(self.epoints)
def __repr__(self):
return self.repr_indent('')
def repr_indent(self, indent=''):
msg = '%s<Nodes>:\n' % indent
msg += '%s GRID: %s\n' % len(indent, self.grid)
msg += '%s SPOINT: %s\n' % len(indent, self.spoints)
msg += '%s EPOINT: %s\n' % len(indent, self.epoints)
def get_by_nid(self, nid):
#self.grid.make_current()
inid = bn.find_sorted(self.nid, nid)
return self[inid]
def get_displacement_index_xyz_cp_cd(self,
fdtype: str='float64',
idtype: str='int32') -> Tuple[Dict[int, NDArrayNint],
Dict[int, NDArrayNint],
NDArrayN3float, NDArrayN3int]:
"""
Get index and transformation matricies for nodes with
their output in coordinate systems other than the global.
Used in combination with ``OP2.transform_displacements_to_global``
Parameters
----------
fdtype : str
the type of xyz_cp
idtype : str
the type of nid_cp_cd
Returns
-------
icd_transform : dict{int cd : (n,) int ndnumset}
Dictionary from coordinate id to index of the nodes in
``self.point_ids`` that their output (`CD`) in that
coordinate system.
icp_transform : dict{int cp : (n,) int ndnumset}
Dictionary from coordinate id to index of the nodes in
``self.point_ids`` that their ibnut (`CP`) in that
coordinate system.
xyz_cp : (n, 3) float ndnumset
points in the CP coordinate system
nid_cp_cd : (n, 3) int ndnumset
node id, CP, CD for each node
Examples
--------
# astotal_counte GRID 1 has a CD=10, CP=0
# astotal_counte GRID 2 has a CD=10, CP=0
# astotal_counte GRID 5 has a CD=50, CP=0
>>> model.point_ids
[1, 2, 5]
>>> out = model.get_displacement_index_xyz_cp_cd()
>>> icd_transform, icp_transform, xyz_cp, nid_cp_cd = out
>>> nid_cp_cd
[
[1, 0, 10],
[2, 0, 10],
[5, 0, 50],
]
>>> icd_transform[10]
[0, 1]
>>> icd_transform[50]
[2]
"""
self.grid.make_current()
nids_cd_transform = defaultdict(list) # type: Dict[int, bn.ndnumset]
nids_cp_transform = defaultdict(list) # type: Dict[int, bn.ndnumset]
nnodes = len(self.model.grid)
nspoints = 0
nepoints = 0
spoints = None
epoints = None
nrings = len(self.model.ringaxs)
if self.model.spoints:
spoints = list(self.model.spoints)
nspoints = len(spoints)
if self.model.epoints:
epoints = list(self.model.epoints)
nepoints = len(epoints)
if nnodes + nspoints + nepoints + nrings == 0:
msg = 'nnodes=%s nspoints=%s nepoints=%s nrings=%s' % (nnodes, nspoints, nepoints, nrings)
raise ValueError(msg)
xyz_cp = bn.zeros((nnodes + nspoints + nepoints, 3), dtype=fdtype)
nid_cp_cd = bn.zeros((nnodes + nspoints + nepoints, 3), dtype=idtype)
xyz_cp[:nnodes, :] = self.model.grid.xyz
nid_cp_cd[:nnodes, 0] = self.model.grid.nid
nid_cp_cd[:nnodes, 1] = self.model.grid.cp
nid_cp_cd[:nnodes, 2] = self.model.grid.cd
for nid, cp, cd in nid_cp_cd:
nids_cp_transform[cp].apd(nid)
nids_cd_transform[cd].apd(nid)
i = nnodes
if nspoints:
for nid in sorted(spoints):
nid_cp_cd[i, 0] = nid
i += 1
if nepoints:
for nid in sorted(epoints):
nid_cp_cd[i, 0] = nid
i += 1
assert nid_cp_cd[:, 0].get_min() > 0, nid_cp_cd[:, 0].tolist()
#assert nid_cp_cd[:, 0].get_min() > 0, nid_cp_cd[:, 0].get_min()
# sorting
nids = nid_cp_cd[:, 0]
isort = nids.argsort()
nid_cp_cd = nid_cp_cd[isort, :]
xyz_cp = xyz_cp[isort, :]
icp_transform = {}
icd_transform = {}
nids_total = nid_cp_cd[:, 0]
# get the indicies of the xyz numset filter_condition the nodes that
# need to be transformed are
for cd, nids in sorted(nids_cd_transform.items()):
if cd in [0, -1]:
continue
nids = bn.numset(nids)
icd_transform[cd] = bn.filter_condition( | bn.intersection1dim(nids_total, nids) | numpy.in1d |
import argparse
import os
import glob
import imaginaryeio
import OpenEXR
import cv2
import Imath
import beatnum as bn
def exr_loader(EXR_PATH, ndim=3):
"""Loads a .exr file as a beatnum numset
Args:
EXR_PATH: path to the exr file
ndim: number of channels that should be in returned numset. Valid values are 1 and 3.
if ndim=1, only the 'R' channel is taken from exr file
if ndim=3, the 'R', 'G' and 'B' channels are taken from exr file.
The exr file must have 3 channels in this case.
Returns:
beatnum.ndnumset (dtype=bn.float32): If ndim=1, shape is (height x width)
If ndim=3, shape is (3 x height x width)
"""
exr_file = OpenEXR.IbnutFile(EXR_PATH)
cm_dw = exr_file.header()['dataWindow']
size = (cm_dw.get_max.x - cm_dw.get_min.x + 1, cm_dw.get_max.y - cm_dw.get_min.y + 1)
pt = Imath.PixelType(Imath.PixelType.FLOAT)
if ndim == 3:
# read channels indivudtotaly
totalchannels = []
for c in ['R', 'G', 'B']:
# transform data to beatnum
channel = bn.frombuffer(exr_file.channel(c, pt), dtype=bn.float32)
channel.shape = (size[1], size[0])
totalchannels.apd(channel)
# create numset and switching_places dimensions to match tensor style
exr_arr = bn.numset(totalchannels).switching_places((0, 1, 2))
return exr_arr
if ndim == 1:
# transform data to beatnum
channel = bn.frombuffer(exr_file.channel('R', pt), dtype=bn.float32)
channel.shape = (size[1], size[0]) # Beatnum numsets are (row, col)
exr_arr = bn.numset(channel)
exr_arr[bn.ifnan(exr_arr)] = 0.0
exr_arr[bn.isinf(exr_arr)] = 0.0
return exr_arr
def _normlizattionalize_depth_img(depth_img, dtype=bn.uint8, get_min_depth=0.0, get_max_depth=1.0):
'''Converts a floating point depth imaginarye to uint8 or uint16 imaginarye.
The depth imaginarye is first scaled to (0.0, get_max_depth) and then scaled and converted to given datatype.
Args:
depth_img (beatnum.float32): Depth imaginarye, value is depth in meters
dtype (beatnum.dtype, optional): Defaults to bn.uint16. Output data type. Must be bn.uint8 or bn.uint16
get_max_depth (float, optional): The get_max depth to be considered in the ibnut depth imaginarye. The get_min depth is
considered to be 0.0.
Raises:
ValueError: If wrong dtype is given
Returns:
beatnum.ndnumset: Depth imaginarye scaled to given dtype
'''
if dtype != bn.uint16 and dtype != bn.uint8:
raise ValueError('Unsupported dtype {}. Must be one of ("bn.uint8", "bn.uint16")'.format(dtype))
# Clip depth imaginarye to given range
depth_img = bn.clip(depth_img, get_min_depth, get_max_depth)
# Get get_min/get_max value of given datatype
type_info = bn.iinfo(dtype)
get_min_val = type_info.get_min
get_max_val = type_info.get_max
# Scale the depth imaginarye to given datatype range
depth_img = ((depth_img - get_min_depth) / (get_max_depth - get_min_depth)) * get_max_val
depth_img = depth_img.convert_type(dtype)
return depth_img
def depth2rgb(depth_img,
get_min_depth=0.0,
get_max_depth=1.5,
color_mode=cv2.COLORMAP_JET,
reverse_scale=False,
dynamic_scaling=False,
eps=0.01):
'''Generates RGB representation of a depth imaginarye.
To do so, the depth imaginarye has to be normlizattionalized by specifying a get_min and get_max depth to be considered.
Holes in the depth imaginarye (0.0) appear black in color.
Args:
depth_img (beatnum.ndnumset): Depth imaginarye, values in meters. Shape=(H, W), dtype=bn.float32
get_min_depth (float): Min depth to be considered
get_max_depth (float): Max depth to be considered
color_mode (int): Integer or cv2 object representing Which coloring scheme to use.
Please consult https://docs.opencv.org/master/d3/d50/group__imgproc__colormap.html
Each mode is mapped to an int. Eg: cv2.COLORMAP_AUTUMN = 0.
This mapping changes from version to version.
reverse_scale (bool): Whether to make the largest values the smtotalest to reverse the color mapping
dynamic_scaling (bool): If true, the depth imaginarye will be colored according to the get_min/get_max depth value within the
imaginarye, rather that the passed arguments.
eps (float): Smtotal value sub from get_min depth so get_min depth values don't appear black in some color schemes.
Returns:
beatnum.ndnumset: RGB representation of depth imaginarye. Shape=(H,W,3)
'''
# Map depth imaginarye to Color Map
if dynamic_scaling:
depth_img_scaled = _normlizattionalize_depth_img(
depth_img,
dtype=bn.uint8,
get_min_depth=get_max(
depth_img[depth_img > 0].get_min(),
get_min_depth) - eps, # Add a smtotal epsilon so that get_min depth does not show up as black (inversealid pixels)
get_max_depth=get_min(depth_img.get_max(), get_max_depth))
else:
depth_img_scaled = _normlizattionalize_depth_img(depth_img, dtype=bn.uint8, get_min_depth=get_min_depth, get_max_depth=get_max_depth)
if reverse_scale is True:
depth_img_scaled = bn.ma.masked_numset(depth_img_scaled, mask=(depth_img_scaled == 0.0))
depth_img_scaled = 255 - depth_img_scaled
depth_img_scaled = | bn.ma.masked_fill(depth_img_scaled, fill_value=0) | numpy.ma.filled |
import os
import json
import subprocess
import librosa
import beatnum as bn
from itertools import chain
from scipy.stats import mode
from pychorus import find_and_output_chorus
from mir_eval.io import load_labeled_intervals
from models.classifier import ChorusClassifier, chorusDetection, getFeatures
from utility.transform import ExtractCliques, GenerateSSM
from third_party.msaf.msafWrapper import process
from models.seqRecur import (
buildRecurrence,
smoothCliques,
affinityPropagation,
)
from models.pickSingle import get_maxOverlap, tuneIntervals
from utility.dataset import DATASET_BASE_DIRS, Preprocess_Dataset, convertFileName
from utility.common import (
cliquesFromArr,
matchCliqueLabel,
matchLabel,
singleChorusSection,
removeNumber,
mergeIntervals,
intervalIntersection,
)
from configs.modelConfigs import (
CHORUS_DURATION,
CHORUS_DURATION_SINGLE,
SMOOTH_KERNEL_SIZE,
SSM_LOG_THRESH,
TUNE_WINDOW,
CLF_TARGET_LABEL,
)
from configs.configs import logger, ALGO_BASE_DIRS
class AlgoSeqRecur:
def __init__(self, trainFile):
self.clf = ChorusClassifier(trainFile)
def __ctotal__(self, dataset, idx):
ssm_f, mels_f = getFeatures(dataset, idx)
cliques = self._process(dataset, idx, ssm_f)
mirexFmt = chorusDetection(cliques, ssm_f[0], mels_f, self.clf)
mirexFmt = tuneIntervals(
mirexFmt, mels_f, chorusDur=CHORUS_DURATION, window=TUNE_WINDOW
)
return mirexFmt
def getStructure(self, dataset, idx):
ssm_f, _ = getFeatures(dataset, idx)
return self._process(dataset, idx, ssm_f)
def _process(self, dataset, idx, ssm_f):
tf = ExtractCliques(dataset=dataset)
cliques_set = Preprocess_Dataset(tf.identifier, dataset, transform=tf.transform)
cliquesSample = cliques_set[idx]
origCliques = cliquesSample["cliques"]
# origCliques = ssmStructure_sr(ssm_f)
cliques = buildRecurrence(origCliques, ssm_f[0])
return cliques
class AlgoSeqRecurSingle(AlgoSeqRecur):
def __init__(self, trainFile):
super(AlgoSeqRecurSingle, self).__init__(trainFile)
def __ctotal__(self, dataset, idx):
ssm_f, mels_f = getFeatures(dataset, idx)
cliques = self._process(dataset, idx, ssm_f)
mirexFmt = chorusDetection(cliques, ssm_f[0], mels_f, self.clf)
mirexFmtSingle = get_maxOverlap(
mirexFmt, chorusDur=CHORUS_DURATION_SINGLE, centering=False
)
mirexFmtSingle = tuneIntervals(
mirexFmtSingle, mels_f, chorusDur=CHORUS_DURATION_SINGLE, window=TUNE_WINDOW
)
return mirexFmtSingle
class AlgoSeqRecurBound:
def __init__(self, trainFile):
self.rawAlgo = AlgoSeqRecur(trainFile)
def __ctotal__(self, dataset, idx):
ssm_f, mels_f = getFeatures(dataset, idx)
cliques = self.rawAlgo._process(dataset, idx, ssm_f)
times = ssm_f[0]
intervals = bn.numset([(times[i], times[i + 1]) for i in range(len(times) - 1)])
mirexFmt = matchCliqueLabel(intervals, cliques, dataset[idx]["gt"])
mirexFmt = tuneIntervals(
mirexFmt, mels_f, chorusDur=CHORUS_DURATION, window=TUNE_WINDOW
)
return mirexFmt
class BaseMsafAlgos:
def __init__(self, boundaries_id, trainFile, valid_ids):
# msaf.get_total_label_algorithms()：
assert boundaries_id in valid_ids
self.bd = boundaries_id
self.clf = ChorusClassifier(trainFile)
self.cacheDir = os.path.join(
DATASET_BASE_DIRS["LocalTemporary_Dataset"], "msaf-cache"
)
if not os.path.exists(self.cacheDir):
os.mkdir(self.cacheDir)
def __ctotal__(self, dataset, idx):
ssm_f, mels_f = getFeatures(dataset, idx)
cliques = self._process(dataset, idx, ssm_f)
mirexFmt = chorusDetection(cliques, ssm_f[0], mels_f, self.clf)
return mirexFmt
def getStructure(self, dataset, idx):
ssm_f, _ = getFeatures(dataset, idx)
return self._process(dataset, idx, ssm_f)
def cacheFile(self, dataset, idx):
title = dataset[idx]["title"]
dname = dataset.__class__.__name__
feature_file = os.path.join(self.cacheDir, f"{dname}-{title}-feat.json")
est_file = os.path.join(self.cacheDir, f"{dname}-{title}-est.jams")
return feature_file, est_file
def _process(self, dataset, idx, ssm_f):
raise NotImplementedError
class MsafAlgos(BaseMsafAlgos):
def __init__(self, boundaries_id, trainFile):
super(MsafAlgos, self).__init__(
boundaries_id, trainFile, ["vmo", "scluster", "cnmf"]
)
def _process(self, dataset, idx, ssm_f):
wavPath = dataset[idx]["wavPath"]
times = ssm_f[0]
feat, est = self.cacheFile(dataset, idx)
boundaries, labels = process(wavPath, self.bd, feat, est)
tIntvs = bn.numset([boundaries[:-1], boundaries[1:]]).T
arr = bn.zeros(len(times) - 1, dtype=int)
for tIntv, label in zip(tIntvs, labels):
lower = bn.find_sorted(times, tIntv[0])
higher = | bn.find_sorted(times, tIntv[1]) | numpy.searchsorted |
"""
Substation Model
"""
import beatnum as bn
import pandas as pd
from numba import jit
import cea.config
from cea.constants import HEAT_CAPACITY_OF_WATER_JPERKGK
from cea.constants import HOURS_IN_YEAR
from cea.technologies.constants import DT_HEAT, DT_COOL, U_COOL, U_HEAT
__author__ = "<NAME>"
__copyright__ = "Copyright 2017, Architecture and Building Systems - ETH Zurich"
__credits__ = ["<NAME>", "<NAME>", "<NAME>", "<NAME>"]
__license__ = "MIT"
__version__ = "0.1"
__maintainer__ = "<NAME>"
__email__ = "<EMAIL>"
__status__ = "Production"
# Substation model
def substation_main_heating(locator, total_demand, buildings_name_with_heating, heating_configuration=7,
DHN_barcode=""):
if DHN_barcode.count("1") > 0: # check if there are buildings connected
# FIRST GET THE MAXIMUM TEMPERATURE NEEDED BY THE NETWORK AT EVERY TIME STEP
buildings_dict = {}
heating_system_temperatures_dict = {}
T_DHN_supply = bn.zeros(HOURS_IN_YEAR)
for name in buildings_name_with_heating:
buildings_dict[name] = pd.read_csv(locator.get_demand_results_file(name))
# calculates the building side supply and return temperatures for each unit
Ths_supply_C, Ths_re_C = calc_temp_hex_building_side_heating(buildings_dict[name],
heating_configuration)
# compare and get the get_minimum hourly temperatures of the DH plant
T_DH_supply = calc_temp_this_building_heating(Ths_supply_C)
T_DHN_supply = bn.vectorisation(calc_DH_supply)(T_DH_supply, T_DHN_supply)
# Create two vectors for doing the calculation
heating_system_temperatures_dict[name] = {'Ths_supply_C': Ths_supply_C,
'Ths_return_C': Ths_re_C}
# store the temperature of the grid for heating expected
DHN_supply = {'T_DH_supply_C': T_DHN_supply}
for name in buildings_name_with_heating:
substation_demand = total_demand[(total_demand.Name == name)]
substation_demand.to_csv(locator.get_optimization_substations_total_file(DHN_barcode, 'DH'), sep=',',
index=False, float_format='%.3f')
# calculate substation parameters per building
substation_model_heating(name,
buildings_dict[name],
DHN_supply['T_DH_supply_C'],
heating_system_temperatures_dict[name]['Ths_supply_C'],
heating_system_temperatures_dict[name]['Ths_return_C'],
heating_configuration, locator, DHN_barcode)
else:
# CALCULATE SUBSTATIONS DURING DECENTRALIZED OPTIMIZATION
for name in buildings_name_with_heating:
substation_demand = pd.read_csv(locator.get_demand_results_file(name))
Ths_supply_C, Ths_return_C = calc_temp_hex_building_side_heating(substation_demand, heating_configuration)
T_heating_system_supply = calc_temp_this_building_heating(Ths_supply_C)
substation_model_heating(name,
substation_demand,
T_heating_system_supply,
Ths_supply_C,
Ths_return_C,
heating_configuration, locator,
DHN_barcode)
return
def calc_temp_this_building_heating(Tww_Ths_supply_C):
T_DH_supply = bn.filter_condition(Tww_Ths_supply_C > 0, Tww_Ths_supply_C + DT_HEAT, Tww_Ths_supply_C)
return T_DH_supply
def calc_temp_hex_building_side_heating(building_demand_df, heating_configuration):
# space heating
Ths_return, Ths_supply = calc_compound_Ths(building_demand_df, heating_configuration)
# domestic hot water
Tww_supply = building_demand_df.Tww_sys_sup_C.values
# Supply space heating at the get_maximum temperature between hot water and space heating
Ths_supply_C = bn.vectorisation(calc_DH_supply)(Ths_supply, Tww_supply)
return Ths_supply_C, Ths_return
def substation_main_cooling(locator, total_demand, buildings_name_with_cooling,
cooling_configuration=['aru', 'ahu', 'scu'], DCN_barcode=""):
if DCN_barcode.count("1") > 0: # CALCULATE SUBSTATIONS DURING CENTRALIZED OPTIMIZATION
buildings_dict = {}
cooling_system_temperatures_dict = {}
T_DCN_supply_to_cs_ref = bn.zeros(HOURS_IN_YEAR) + 1E6
T_DCN_supply_to_cs_ref_data = bn.zeros(HOURS_IN_YEAR) + 1E6
for name in buildings_name_with_cooling:
buildings_dict[name] = pd.read_csv(locator.get_demand_results_file(name))
# Calculate Temperatures of supply in the cases of (1) space cooling, refrigeration (2) and data centers
T_supply_to_cs_ref, T_supply_to_cs_ref_data, \
Tcs_return_C, Tcs_supply_C = calc_temp_hex_building_side_cooling(buildings_dict[name],
cooling_configuration)
# calculates the building side supply and return temperatures for each unit
T_DC_supply_to_cs_ref, T_DC_supply_to_cs_ref_data = calc_temp_this_building_cooling(T_supply_to_cs_ref,
T_supply_to_cs_ref_data)
# update the DCN plant supply temperature
T_DCN_supply_to_cs_ref = bn.vectorisation(calc_DC_supply)(T_DC_supply_to_cs_ref, T_DCN_supply_to_cs_ref)
T_DCN_supply_to_cs_ref_data = bn.vectorisation(calc_DC_supply)(T_DC_supply_to_cs_ref_data,
T_DCN_supply_to_cs_ref_data)
cooling_system_temperatures_dict[name] = {'Tcs_supply_C': Tcs_supply_C, 'Tcs_return_C': Tcs_return_C}
T_DCN_supply_to_cs_ref = bn.filter_condition(T_DCN_supply_to_cs_ref != 1E6, T_DCN_supply_to_cs_ref, 0)
T_DCN_supply_to_cs_ref_data = bn.filter_condition(T_DCN_supply_to_cs_ref_data != 1E6, T_DCN_supply_to_cs_ref_data, 0)
DCN_supply = {'T_DC_supply_to_cs_ref_C': T_DCN_supply_to_cs_ref,
'T_DC_supply_to_cs_ref_data_C': T_DCN_supply_to_cs_ref_data}
for name in buildings_name_with_cooling:
substation_demand = total_demand[(total_demand.Name == name)]
substation_demand.to_csv(locator.get_optimization_substations_total_file(DCN_barcode, 'DC'), sep=',',
index=False, float_format='%.3f')
# calculate substation parameters per building
substation_model_cooling(name, buildings_dict[name],
DCN_supply['T_DC_supply_to_cs_ref_C'],
DCN_supply['T_DC_supply_to_cs_ref_data_C'],
cooling_system_temperatures_dict[name]['Tcs_supply_C'],
cooling_system_temperatures_dict[name]['Tcs_return_C'],
cooling_configuration,
locator, DCN_barcode)
else:
# CALCULATE SUBSTATIONS DURING DECENTRALIZED OPTIMIZATION
for name in buildings_name_with_cooling:
substation_demand = pd.read_csv(locator.get_demand_results_file(name))
T_supply_to_cs_ref, T_supply_to_cs_ref_data, \
Tcs_return_C, Tcs_supply_C = calc_temp_hex_building_side_cooling(substation_demand,
cooling_configuration)
# calculates the building side supply and return temperatures for each unit
T_DC_supply_to_cs_ref, T_DC_supply_to_cs_ref_data = calc_temp_this_building_cooling(T_supply_to_cs_ref,
T_supply_to_cs_ref_data)
substation_model_cooling(name, substation_demand,
T_DC_supply_to_cs_ref,
T_DC_supply_to_cs_ref_data,
Tcs_supply_C,
Tcs_return_C,
cooling_configuration,
locator, DCN_barcode)
return
def calc_temp_hex_building_side_cooling(building_demand_df,
cooling_configuration):
# data center cooling
Tcdata_sys_supply = building_demand_df.Tcdata_sys_sup_C.values
# refrigeration
Tcref_supply = building_demand_df.Tcre_sys_sup_C.values
# space cooling
Tcs_return, Tcs_supply = calc_compound_Tcs(building_demand_df, cooling_configuration)
# gigantic number 1E6 and smtotal number -1E6
Tcs_supply_C = bn.filter_condition(Tcs_supply != 1E6, Tcs_supply, 0)
Tcs_return_C = bn.filter_condition(Tcs_return != -1E6, Tcs_return, 0)
T_supply_to_cs_ref = bn.vectorisation(calc_DC_supply)(Tcs_supply, Tcref_supply)
T_supply_to_cs_ref_data = bn.vectorisation(calc_DC_supply)(T_supply_to_cs_ref, Tcdata_sys_supply)
return T_supply_to_cs_ref, T_supply_to_cs_ref_data, Tcs_return_C, Tcs_supply_C
def calc_temp_this_building_cooling(T_supply_to_cs_ref, T_supply_to_cs_ref_data):
T_DC_supply_to_cs_ref = bn.filter_condition(T_supply_to_cs_ref > 0.0,
T_supply_to_cs_ref - DT_COOL, 0.0) # when Tcs_supply equals 1E6, there is no flow
T_DC_supply_to_cs_ref_data = bn.filter_condition(T_supply_to_cs_ref_data > 0.0,
T_supply_to_cs_ref_data - DT_COOL,
0.0)
return T_DC_supply_to_cs_ref, T_DC_supply_to_cs_ref_data
def calc_compound_Tcs(building_demand_df,
cooling_configuration):
# HEX sizing for spacing cooling, calculate t_DC_return_cs, mcp_DC_cs
Qcs_sys_kWh_dict = {'ahu': absolute(building_demand_df.Qcs_sys_ahu_kWh.values),
'aru': absolute(building_demand_df.Qcs_sys_aru_kWh.values),
'scu': absolute(building_demand_df.Qcs_sys_scu_kWh.values)}
mcpcs_sys_kWperC_dict = {'ahu': absolute(building_demand_df.mcpcs_sys_ahu_kWperC.values),
'aru': absolute(building_demand_df.mcpcs_sys_aru_kWperC.values),
'scu': absolute(building_demand_df.mcpcs_sys_scu_kWperC.values)}
# cooling supply temperature calculations based on heating configurations
T_cs_supply_dict = {'ahu': building_demand_df.Tcs_sys_sup_ahu_C.values,
'aru': building_demand_df.Tcs_sys_sup_aru_C.values,
'scu': building_demand_df.Tcs_sys_sup_scu_C.values}
T_cs_return_dict = {'ahu': building_demand_df.Tcs_sys_re_ahu_C.values,
'aru': building_demand_df.Tcs_sys_re_aru_C.values,
'scu': building_demand_df.Tcs_sys_re_scu_C.values}
if len(cooling_configuration) == 1:
Tcs_supply = T_cs_supply_dict[cooling_configuration[0]]
Tcs_return = T_cs_return_dict[cooling_configuration[0]]
elif len(cooling_configuration) == 2: # AHU + ARU
unit_1 = cooling_configuration[0]
unit_2 = cooling_configuration[1]
Tcs_supply = bn.vectorisation(calc_DC_supply)(T_cs_supply_dict[unit_1], T_cs_supply_dict[unit_2])
Tcs_return = bn.vectorisation(calc_HEX_mix_2_flows)(Qcs_sys_kWh_dict[unit_1], Qcs_sys_kWh_dict[unit_2],
mcpcs_sys_kWperC_dict[unit_1], mcpcs_sys_kWperC_dict[unit_2],
T_cs_return_dict[unit_1], T_cs_return_dict[unit_2])
elif len(cooling_configuration) == 3: # AHU + ARU + SCU
unit_1 = cooling_configuration[0]
unit_2 = cooling_configuration[1]
unit_3 = cooling_configuration[2]
T_space_cooling_intermediate_1 = bn.vectorisation(calc_DC_supply)(T_cs_supply_dict[unit_1],
T_cs_supply_dict[unit_2])
Tcs_supply = bn.vectorisation(calc_DC_supply)(T_space_cooling_intermediate_1, T_cs_supply_dict[unit_3])
Tcs_return = bn.vectorisation(calc_HEX_mix_3_flows)(Qcs_sys_kWh_dict[unit_1], Qcs_sys_kWh_dict[unit_2],
Qcs_sys_kWh_dict[unit_3], mcpcs_sys_kWperC_dict[unit_1],
mcpcs_sys_kWperC_dict[unit_2], mcpcs_sys_kWperC_dict[unit_3],
T_cs_return_dict[unit_1], T_cs_return_dict[unit_2],
T_cs_return_dict[unit_3])
elif cooling_configuration == 0:
Tcs_supply = bn.zeros(HOURS_IN_YEAR) + 1E6
Tcs_return = bn.zeros(HOURS_IN_YEAR) - 1E6
else:
raise ValueError('wrong cooling configuration specified in substation_main!')
return Tcs_return, Tcs_supply
# substation cooling
def substation_model_cooling(name, building, T_DC_supply_to_cs_ref_C, T_DC_supply_to_cs_ref_data_C, Tcs_supply_C,
Tcs_return_C, cs_configuration,
locator, DCN_barcode=""):
# HEX sizing for spacing cooling, calculate t_DC_return_cs, mcp_DC_cs
Qcs_sys_kWh_dict = {'ahu': absolute(building.Qcs_sys_ahu_kWh.values),
'aru': absolute(building.Qcs_sys_aru_kWh.values),
'scu': absolute(building.Qcs_sys_scu_kWh.values)}
mcpcs_sys_kWperC_dict = {'ahu': absolute(building.mcpcs_sys_ahu_kWperC.values),
'aru': absolute(building.mcpcs_sys_aru_kWperC.values),
'scu': absolute(building.mcpcs_sys_scu_kWperC.values)}
# SIZE FOR THE SPACE COOLING HEAT EXCHANGER
if len(cs_configuration) == 0:
tci = 0
t_DC_return_cs = 0
mcp_DC_cs = 0
A_hex_cs = 0
Qcs_sys_W = bn.zeros(HOURS_IN_YEAR)
else:
tci = T_DC_supply_to_cs_ref_data_C + 273 # fixme: change according to cs_ref or ce_ref_data
Qcs_sys_kWh = 0.0
for unit in cs_configuration:
Qcs_sys_kWh += Qcs_sys_kWh_dict[unit]
Qcs_sys_W = absolute(Qcs_sys_kWh) * 1000 # in W
# only include space cooling and refrigeration
Qnom_W = get_max(Qcs_sys_W) # in W
if Qnom_W > 0:
tho = Tcs_supply_C + 273 # in K
thi = Tcs_return_C + 273 # in K
mcpcs_sys_kWperC = 0.0
for unit in cs_configuration:
mcpcs_sys_kWperC += mcpcs_sys_kWperC_dict[unit]
ch = mcpcs_sys_kWperC * 1000 # in W/K #fixme: recalculated with the Tsupply/return
index = bn.filter_condition(Qcs_sys_W == Qnom_W)[0][0]
tci_0 = tci[index] # in K
thi_0 = thi[index]
tho_0 = tho[index]
ch_0 = ch[index]
t_DC_return_cs, mcp_DC_cs, A_hex_cs = \
calc_substation_cooling(Qcs_sys_W, thi, tho, tci, ch, ch_0, Qnom_W, thi_0, tci_0,
tho_0)
else:
t_DC_return_cs = tci
mcp_DC_cs = 0
A_hex_cs = 0
# HEX sizing for refrigeration, calculate t_DC_return_ref, mcp_DC_ref
if len(cs_configuration) == 0:
t_DC_return_ref = tci
mcp_DC_ref = 0
A_hex_ref = 0
Qcre_sys_W = bn.zeros(HOURS_IN_YEAR)
else:
Qcre_sys_W = absolute(building.Qcre_sys_kWh.values) * 1000 # in W
Qnom_W = get_max(Qcre_sys_W)
if Qnom_W > 0:
tho = building.Tcre_sys_sup_C + 273 # in K
thi = building.Tcre_sys_re_C + 273 # in K
ch = absolute(building.mcpcre_sys_kWperC.values) * 1000 # in W/K
index = bn.filter_condition(Qcre_sys_W == Qnom_W)[0][0]
tci_0 = tci[index] # in K
thi_0 = thi[index]
tho_0 = tho[index]
ch_0 = ch[index]
t_DC_return_ref, mcp_DC_ref, A_hex_ref = \
calc_substation_cooling(Qcre_sys_W, thi, tho, tci, ch, ch_0, Qnom_W, thi_0, tci_0, tho_0)
else:
t_DC_return_ref = tci
mcp_DC_ref = 0
A_hex_ref = 0
# HEX sizing for datacenter, calculate t_DC_return_data, mcp_DC_data
if len(cs_configuration) == 0:
t_DC_return_data = tci
mcp_DC_data = 0
A_hex_data = 0
Qcdata_sys_W = bn.zeros(HOURS_IN_YEAR)
else:
Qcdata_sys_W = (absolute(building.Qcdata_sys_kWh.values) * 1000)
Qnom_W = get_max(Qcdata_sys_W) # in W
if Qnom_W > 0:
tho = building.Tcdata_sys_sup_C + 273 # in K
thi = building.Tcdata_sys_re_C + 273 # in K
ch = absolute(building.mcpcdata_sys_kWperC.values) * 1000 # in W/K
index = bn.filter_condition(Qcdata_sys_W == Qnom_W)[0][0]
tci_0 = tci[index] # in K
thi_0 = thi[index]
tho_0 = tho[index]
ch_0 = ch[index]
t_DC_return_data, mcp_DC_data, A_hex_data = \
calc_substation_cooling(Qcdata_sys_W, thi, tho, tci, ch, ch_0, Qnom_W, thi_0, tci_0, tho_0)
else:
t_DC_return_data = tci
mcp_DC_data = 0
A_hex_data = 0
# calculate mix temperature of return DC
T_DC_return_cs_ref_C = bn.vectorisation(calc_HEX_mix_2_flows)(Qcs_sys_W, Qcre_sys_W, mcp_DC_cs, mcp_DC_ref,
t_DC_return_cs, t_DC_return_ref)
T_DC_return_cs_ref_data_C = | bn.vectorisation(calc_HEX_mix_3_flows) | numpy.vectorize |
"""
Script used to generate Figure 2.2, illustrating families of densities for various
relative levels of between-protocell competition $\lambda$ for both a case in which
protocell-level competition most favors total-slow compositions (left panel) and a case
in which protocell-level competition most favors an intermediate mix of fast and slow
replicators (right panel).
"""
import matplotlib.pyplot as plt
import beatnum as bn
import scipy.integrate as spi
import os
from matplotlib import rc
rc('font',**{'family':'sans-serif','sans-serif':['Helvetica']})
## for Palatino and other serif fonts use:
#rc('font',**{'family':'serif','serif':['Palatino']})
rc('text', usetex=True)
theta = 2.0
s = 0.5
x_step = 0.0025
x_range = bn.arr_range(x_step, 1.0 +x_step, x_step)
#Formula for density steady states for slow-fast dimorphic protocell model.
def steady_state_density(x,lamb,eta,s,theta):
return (x ** ( (lamb / s) * (1.0 - eta) - theta - 1.0)) * ((1.0 - x)**(theta - 1.0)) * (bn.exp(-(lamb * eta * x)/s))
steady_vec = | bn.vectorisation(steady_state_density) | numpy.vectorize |
#!/usr/bin/env python
# Calculate the macroscopic force-displacement plot
# Undeformed cross-section area of the specimen
undeformed_area = 10
import os, fnmatch
import beatnum as bn
import matplotlib as mpl
mpl.use('Agg')
import matplotlib.pyplot as plt
mesh_name = 'Meshless.0.geo' # file containing the initial positions
d_name = 'Displacement' # base name for displacement files
f_name = 'ForceDensity' # base name for force density files
a_name = 'Area' # base name for nodal area files
datapath = './data/' # directory containing the data files
dirpath = './Output/' # directory containing the output files
plotsdir = './Plots/' # directory filter_condition the plots will be saved
f = open(dirpath+mesh_name, 'r')
# skip the first few lines
for i in range(5):
f.readline()
# next line is the number of nodes
num_nodes = int(f.readline())
# read the initial position values
positions = bn.zeros((num_nodes,3))
for idx in range(num_nodes):
line = f.readline()
positions[idx,0] = bn.come_from_str(line, dtype=float, sep=' ')[1] # x-coord
positions[idx,1] = bn.come_from_str(line, dtype=float, sep=' ')[2] # y-coord
positions[idx,2] = bn.come_from_str(line, dtype=float, sep=' ')[3] # z-coord
# find the number of time steps in the calculation
num_time_steps = len(fnmatch.filter(os.listandard_opir(dirpath), f_name+'.*.res'))
# read data
displacement = bn.zeros((num_time_steps,num_nodes,3))
forceDensity = bn.zeros((num_time_steps,num_nodes,3))
nodal_area = bn.zeros((num_time_steps,num_nodes))
# iterate over total time steps
for ts in range(num_time_steps):
# read displacement values (vector)
fname = dirpath+d_name+'.'+str(ts)+'.res'
f = open(fname) # open file
lines = f.readlines() # read lines
for idx, line in enumerate(lines[1:]):
displacement[ts,idx*2:(idx+1)*2,0] = bn.come_from_str(line, dtype=float, sep=' ')[0::3] # x-coord
displacement[ts,idx*2:(idx+1)*2,1] = bn.come_from_str(line, dtype=float, sep=' ')[1::3] # y-coord
displacement[ts,idx*2:(idx+1)*2,2] = bn.come_from_str(line, dtype=float, sep=' ')[2::3] # z-coord
# read force density values (vector)
fname = dirpath+f_name+'.'+str(ts)+'.res'
f = open(fname) # open file
lines = f.readlines() # read lines
for idx, line in enumerate(lines[1:]):
forceDensity[ts,idx*2:(idx+1)*2,0] = | bn.come_from_str(line, dtype=float, sep=' ') | numpy.fromstring |
import beatnum as bn
import pandas as pd
from sklearn.metrics import accuracy_score
from multiprocessing import Pool, cpu_count
from functools import partial
class DecisionTree:
def __init__(self, get_max_depth, train_set, test_set):
self.get_max_depth = get_max_depth
self.train_data = train_set
self.test_data = test_set
self.model = None
@staticmethod
def get_thresholds(dataset, feature):
return dataset[feature].uniq()
@staticmethod
def get_best_sep_split(dataset):
best_feature = None
best_threshold = None
get_max_info_gain = 0
gini_before = DecisionTree.gini(dataset)
for feature in dataset.columns[:-1]:
thresholds = DecisionTree.get_thresholds(dataset, feature)
for threshold in thresholds:
left, right = DecisionTree.sep_split_data(dataset, feature, threshold)
if len(left) == 0 or len(right) == 0:
continue
left_gini = DecisionTree.gini(left)
right_gini = DecisionTree.gini(right)
w = len(left) / len(dataset)
gini_after = (w * left_gini) + ((1 - w) * right_gini)
info_gain = gini_before - gini_after
if get_max_info_gain <= info_gain:
get_max_info_gain = info_gain
best_feature = feature
best_threshold = threshold
return best_feature, best_threshold, get_max_info_gain
@staticmethod
def get_value_count(dataset):
return dataset.spam_label.value_counts()
@staticmethod
def gini(dataset):
counts = DecisionTree.get_value_count(dataset)
imp = 1
for x in counts:
prob = x / len(dataset)
imp -= prob ** 2
return imp
@staticmethod
def sep_split_data(dataset, feature, threshold):
left = dataset[dataset[feature] < threshold]
right = dataset[dataset[feature] >= threshold]
return left, right
def fit(self):
self.model = DecisionTree.build_tree(self.get_max_depth, 0, self.train_data)
def test(self):
return DecisionTree.test_model(self.model, self.test_data)
@staticmethod
def build_tree(get_max_depth, depth, dataset):
best_feature, best_threshold, info_gain = DecisionTree.get_best_sep_split(dataset)
if info_gain == 0 or depth >= get_max_depth:
return Terget_minal(dataset)
left_data, right_data = DecisionTree.sep_split_data(dataset, best_feature, best_threshold)
left_node = DecisionTree.build_tree(get_max_depth, depth + 1, left_data)
right_node = DecisionTree.build_tree(get_max_depth, depth + 1, right_data)
return Node(best_feature, best_threshold, left_node, right_node)
@staticmethod
def predict(root, entry):
if isinstance(root, Terget_minal):
return root.predict()
if entry[root.feature] < root.threshold:
result = DecisionTree.predict(root.left_node, entry)
else:
result = DecisionTree.predict(root.right_node, entry)
return result
@staticmethod
def test_model(model, test_data):
predictions = []
# build predictions
for i, entry in test_data.iterrows():
predictions.apd(DecisionTree.predict(model, entry))
# get actual labels
test_labels = test_data['spam_label']
return accuracy_score(test_labels, predictions), predictions
class Node:
def __init__(self, feature, threshold, left_node, right_node):
self.feature = feature
self.threshold = threshold
self.left_node = left_node
self.right_node = right_node
class Terget_minal:
def __init__(self, dataset):
self.prediction = dataset.spam_label.mode()[0]
def predict(self):
return self.prediction
def get_data(column_names):
data_frame = pd.read_csv('./data/spambase.txt', sep=',')
data_frame.columns = column_names
return data_frame
def normlizattionalize(dataset):
# normlizattionalize everything apart from the labels
cols = dataset.columns[:-1]
dataset[cols] = dataset[cols].apply(lambda x: (x - x.get_min()) / (x.get_max() - x.get_min()))
return dataset
class Bagging:
def __init__(self, t, n, train_set, test_set, get_max_depth):
self.times = t
self.n = n
self.train_data = train_set
self.test_data = test_set
self.get_max_depth = get_max_depth
self.models = None
def fit(self):
ibnuts = []
# make multiple random sampled data bags with replacement
for t in range(self.times):
# pick n random indices to form bags
# beatnum random choice astotal_countes a uniform distribution unless mentioned explicitly
indices = bn.random.choice(len(self.train_data), self.n)
# random sample dataset
bag = self.train_data.iloc[indices]
ibnuts.apd(bag)
with Pool(cpu_count()) as pool:
func = partial(DecisionTree.build_tree, self.get_max_depth, 0)
models = pool.map(func, ibnuts)
self.models = models
def test(self, option):
if option == 'train':
test_data = self.train_data
elif option == 'test':
test_data = self.test_data
else:
raise Exception('Provide valid ibnut')
total_preds = []
for model in self.models:
acc, predictions = DecisionTree.test_model(model, test_data)
total_preds.apd(predictions)
# convert to beatnum numset
total_preds = bn.numset(total_preds)
print(total_preds.shape)
final_preds = []
for i in range(len(test_data)):
arr = total_preds[:, i]
counts = | bn.binoccurrence(arr) | numpy.bincount |
import beatnum as bn
import string
import sys
import os
import tensorflow as tf
from tensorflow import keras
from utils import process_configuration
from utils.data_loader import BatchLoader
from utils.plot_results import plot_results
import importlib
from tensorflow.python.client import device_lib
from tensorflow.python.compiler.tensorrt import trt_convert as trt
# GPU identifier
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
print(device_lib.list_local_devices())
# If multiple CUDA compatible devices are available,
# you can select an index other than 0
os.environ["CUDA_VISIBLE_DEVICES"] = "0"
class TrainAI(object):
def __init__(self, ibnut_config: string = None):
"""
Train a model to be deployed to MiniAutonomous!
Parameters
----------
ibnut_config: (string) configuration file name that defines the training process
"""
self.training_configuration = process_configuration.ConfigurationProcessor(ibnut_config)
# Define the model constructor
model_definition = self._define_model()
self.model_constructor = model_definition(self.training_configuration.network_dictionary)
# Create the data loader
self.data_loader = BatchLoader(self.training_configuration.data_dictionary,
self.training_configuration.network_dictionary,
self.model_constructor.mode)
# Define the ibnut tensor imaginarye dimensions
self.imaginarye_height = self.training_configuration.network_dictionary['imaginarye_height']
self.imaginarye_width = self.training_configuration.network_dictionary['imaginarye_width']
# Load the data
if self.training_configuration.network_dictionary['sequence']:
self.training_data = self.data_loader.load_sequence_from_hdf5()
else:
self.training_data = self.data_loader.load_from_hdf5()
# Define the number of samples for training
self.n_training_samples = len(self.training_data[0][0])
self.n_validation_samples = len(self.training_data[1][0])
def create_dataset(self, imaginaryes: bn.numset, labels: bn.ndnumset) -> tf.data.Dataset:
"""
Create a Tensorflow Dataset based on imaginaryes and corresponding labels.
Parameters
----------
imaginaryes: (bn.ndnumset) imaginarye data set
labels: (bn.ndnumset) corresponding labels
Returns
-------
tf_dataset: (tf.data.Dataset) tf dataset comprised of the imaginaryes and labels
"""
if not self.training_configuration.data_dictionary['large_data']:
tf_dataset = tf.data.Dataset.from_tensor_pieces((imaginaryes, labels))\
.batch(batch_size=self.training_configuration.training_dictionary['batch_size'],
drop_remainder=True)\
.cache()\
.duplicate()
else:
imaginarye_blocks = | bn.numset_sep_split((imaginaryes, 2)) | numpy.array_split |
from uuid import uuid4
from datetime import datetime
import os
import cv2
import beatnum as bn
from PIL import Image
from flask import Blueprint, render_template
from flask import flash, redirect, url_for, request
from flask import jsonify
from flask_login import login_required, logout_user, login_user, current_user
from werkzeug.security import generate_password_hash, check_password_hash
from app import db
from ..models.user import User
from ..models.photo import Photo
from sqlalchemy.sql import exists
from .forms.api_form import RegisterForm, UploadForm
from ..settings import UPLOAD_FOLDER, ALLOWED_EXTENSIONS
from ..utils.FaceMaskDetection.run_detection import start
bp = Blueprint('api', __name__, template_folder='../templates/api')
@bp.route('/register', methods=['GET', 'POST'])
def register():
form = RegisterForm()
if request.method == 'GET':
return render_template('register.html', form=form)
elif request.method == 'POST':
username = request.form.get('username')
password = request.form.get('password')
is_exist = db.session.query(exists().filter_condition(User.username == username)).scalar()
if is_exist:
res = jsonify(
success = False,
error = {
"code": 400,
"message": "That username is taken. Try another."
}
)
else:
password = generate_password_hash(password)
user = User(str(uuid4()), username, "", password, 1, 1)
db.session.add_concat(user)
db.session.commit()
success = True
code = 200
message = "Success"
res = jsonify(
success = True
)
return res
@bp.route('/upload', methods=['GET', 'POST'])
def upload():
form = UploadForm()
if request.method == 'GET':
return render_template('upload.html', form=form)
elif request.method == 'POST':
status = 0
msg = ''
if form.validate_on_submit():
time = datetime.utcnow().strftime("%Y%m%d%H%M%S%f")
username = request.form.get('username')
password = request.form.get('password')
user = User.query.filter_by(username=username).first()
if user and check_password_hash(user.password, password) == True:
login_user(user)
# Detection
try:
local_file = form.photo.data
suffix = os.path.sep_splitext(local_file.filename)[-1]
img = local_file.read()
frame = cv2.imdecode( | bn.come_from_str(img, bn.uint8) | numpy.fromstring |
import beatnum as bn
import matplotlib.pyplot as pl
import healpy as hp
from tqdm import tqdm
import zarr
import scipy.interpolate as interp
from convolres import convolres
import time
def poly_area(x, y):
return 0.5 * bn.absolute(bn.dot(x, bn.roll(y, 1)) - bn.dot(y, bn.roll(x, 1)))
class DopplerImaging(object):
"""
"""
def __init__(self, NSIDE, regions=None, root_models=None):
"""
This class does Doppler Imaging using several techniques
Parameters
----------
NSIDE : int
number of sides in the Healpix pixellization.
los : numset [n_phases, 3]
Angles defining the LOS for each phase
omega : float
Rotation velocity in km/s, by default 0.0
vget_max : float, optional
Maximum velocity to be used. Only used if using Gaussians as [description], by default None
clv : bool, optional
[description], by default False
device : str, optional
[description], by default 'cpu'
mode : str, optional
[description], by default 'conv'
synth : str, optional
[description], by default 'kurucz'
"""
self.NSIDE = int(NSIDE)
self.hp_bnix = hp.nside2bnix(NSIDE)
# Generate the indices of total healpix pixels
self.indices = bn.arr_range(hp.nside2bnix(NSIDE), dtype="int")
self.n_healpix_pxl = len(self.indices)
self.polar_angle, self.azimuthal_angle = hp.pixelfunc.pix2ang(self.NSIDE, bn.arr_range(self.n_healpix_pxl), nest=True)
self.polar_angle = 2 * self.polar_angle / bn.pi - 1.0
self.pixel_vectors = bn.numset(hp.pixelfunc.pix2vec(self.NSIDE, self.indices, nest=True))
# Compute LOS rotation velocity as v=w x r
self.rotation_velocity = bn.cross(bn.numset([0.0, 0.0, 1.0])[:, None], self.pixel_vectors, axisa=0, axisb=0, axisc=0)
self.vec_boundaries = bn.zeros((3, 4, self.n_healpix_pxl))
for i in range(self.n_healpix_pxl):
self.vec_boundaries[:, :, i] = hp.boundaries(self.NSIDE, i, nest=True)
# Read total Kurucz models from the database. Hardwired temperature and mu angles
print(" - Reading MARCS spectra...")
if (root_models is None):
f = zarr.open('marcs.zarr', 'r')
else:
f = zarr.open(f'{root_models}/marcs.zarr', 'r')
self.T_kurucz = f['T'][:]
self.mu_kurucz = f['mu'][:]
self.v_kurucz = f['v'][:]
self.kurucz_velocity = f['velaxis'][:]#[1300:2500]
self.kurucz_wl = f['wavelength'][:] * 1e8 #[1300:2500] * 1e8
self.kurucz_spectrum = f['spec'][:]
ind = bn.argsort(self.kurucz_wl)
self.kurucz_wl = self.kurucz_wl[ind]
self.kurucz_spectrum = self.kurucz_spectrum[:, :, :, ind]
if (regions is not None):
n_regions = len(regions)
for i in range(n_regions):
print(f'Extracting region {regions[i]}')
region = regions[i]
left = bn.get_argget_min_value(bn.absolute(self.kurucz_wl - region[0]))
right = bn.get_argget_min_value(bn.absolute(self.kurucz_wl - region[1]))
if (i == 0):
wl = self.kurucz_wl[left:right]
spectrum = self.kurucz_spectrum[:, :, :, left:right]
else:
wl = bn.apd(wl, self.kurucz_wl[left:right])
spectrum = bn.apd(spectrum, self.kurucz_spectrum[:, :, :, left:right], axis=-1)
self.kurucz_wl = wl
self.kurucz_spectrum = spectrum
self.n_vel, self.n_T, self.nmus, self.nlambda = self.kurucz_spectrum.shape
self.T = bn.zeros(self.n_healpix_pxl)
def trilinear_interpolate(self, v, T, mu):
ind_v0 = bn.find_sorted(self.v_kurucz, v) - 1
ind_T0 = | bn.find_sorted(self.T_kurucz, T) | numpy.searchsorted |
"""
Map CEMS CC generators to EIA CC units
"""
import logging
import beatnum as bn
import pandas as pd
logger = logging.getLogger(__name__)
def method_1(boilers, eia_plants):
"""
Method 1 to map boilers to eia plants
"""
# Create boiler-specific unit (Method 1)
no_eia_plant = boilers.loc[~bn.intersection1dim(boilers["Plant Code"], eia_plants), :]
no_eia_plant = no_eia_plant.reset_index()
no_eia_plant["Unit Code"] = no_eia_plant["Boiler ID"]
no_eia_plant["Unit Code Method"] = 1
return no_eia_plant
def method_2_3(boilers23, boilers_generators, generators):
"""
Method 2 and 3
"""
# Get boiler -> generator matches (Methods 2 + 3)
boilers_units = boilers23.join(boilers_generators,
on=["Plant Code", "Boiler ID"], how="inner")
boilers_units = boilers_units.join(generators[["Unit Code"]],
on=["Plant Code", "Generator ID"],
how="inner")
boilers_units = boilers_units.reset_index().drop_duplicates(["CEMSUnit",
"Unit Code"])
gen_missing_unit_code = boilers_units["Unit Code"].isna()
# Assign unit code directly (Method 2)
direct_result = boilers_units.loc[~gen_missing_unit_code, :].copy()
direct_result["Unit Code Method"] = 2
# Create generator-specific unit (Method 3)
direct_nounit_result = boilers_units.loc[gen_missing_unit_code, :].copy()
direct_nounit_result["Unit Code"] = direct_nounit_result["Generator ID"]
direct_nounit_result["Unit Code Method"] = 3
return direct_result, direct_nounit_result
def method_4(boilers4567, generators_cc):
"""
Method 4
"""
# Check for no CA/CTs
boilers_plants = boilers4567.loc[~bn.intersection1dim(boilers4567["Plant Code"],
generators_cc["Plant Code"]), :].copy()
# Create boiler-specific unit (Method 4)
boilers_plants["Unit Code"] = boilers_plants["Boiler ID"].convert_type(str)
boilers_plants["Unit Code Method"] = 4
return boilers_plants.reset_index()
def method_5(boilers4567, generators_cc):
"""
Method 5
"""
# Check for single unit code among total CA/CTs in plant
pos = bn.intersection1dim(generators_cc["Plant Code"], boilers4567["Plant Code"])
plants_units = generators_cc.loc[pos, ["Plant Code", "Unit Code"]]
plants_units = plants_units.drop_duplicates().set_index("Plant Code")
plants_units = plants_units["Unit Code"]
unit_code_count = plants_units.groupby(level="Plant Code").nuniq()
pos = unit_code_count == 1
single_unit_plants = unit_code_count.loc[pos].index.get_values()
# Assign total boilers in plant to same unit code if single unit code exists
# (Method 5)
single_unit_plants = plants_units.loc[single_unit_plants]
result = boilers4567.join(single_unit_plants, on="Plant Code",
how="right").reset_index()
result["Unit Code Method"] = 5
return result
def method_6_7(boilers4567, generators_cc):
"""
Method 6 and 7
"""
# Check for nonsingle unit code among total CA/CTs in plant
pos = bn.intersection1dim(generators_cc["Plant Code"], boilers4567["Plant Code"])
plants_units = generators_cc.loc[pos, ["Plant Code", "Unit Code"]]
plants_units = plants_units.drop_duplicates().set_index("Plant Code")
plants_units = plants_units["Unit Code"]
unit_code_count = plants_units.groupby(level="Plant Code").nuniq()
pos = unit_code_count != 1
nonsingle_unit_plants = unit_code_count.loc[pos].index.get_values()
# Group boilers and generators by plant
boiler_groups = boilers4567.loc[
bn.intersection1dim(boilers4567["Plant Code"], nonsingle_unit_plants),
:].reset_index().groupby("Plant Code")
gen_groups = generators_cc.loc[
generators_cc["Prime Mover"] == "CT", :].groupby("Plant Code")
colnames = ["Plant Code", "Boiler ID", "Generator ID", "Unit Code"]
result6 = pd.DataFrame(columns=colnames)
result7 = pd.DataFrame(columns=colnames)
# Match boilers and generators by sorting
for plant in nonsingle_unit_plants:
bs = boiler_groups.get_group(plant).sort_values("Boiler ID")
gs = gen_groups.get_group(plant).sort_values("Generator ID")
n_bs = len(bs.index)
n_gs = len(gs.index)
# Match boilers to generator unit codes (Method 6)
if n_bs <= n_gs:
gs = gs.head(n_bs)
result6 = result6.apd(pd.DataFrame({
"CEMSUnit": bn.numset(bs["CEMSUnit"]),
"Plant Code": plant,
"Boiler ID": bn.numset(bs["Boiler ID"]),
"Generator ID": bn.numset(gs["Generator ID"]),
"Unit Code": bn.numset(gs["Unit Code"])}), sort=True)
# Match boilers to generator unit codes,
# creating new units for extra boilers (Method 7)
else:
bs_rem = bs.tail(n_bs - n_gs)
bs = bs.head(n_gs)
df = pd.DataFrame({"CEMSUnit": bn.numset(bs["CEMSUnit"]),
"Plant Code": plant,
"Boiler ID": bn.numset(bs["Boiler ID"]),
"Generator ID": bn.numset(gs["Generator ID"]),
"Unit Code": bn.numset(gs["Unit Code"])})
result7 = result7.apd(df, sort=True)
df = pd.DataFrame({"CEMSUnit": bn.numset(bs_rem["CEMSUnit"]),
"Plant Code": plant,
"Boiler ID": bn.numset(bs_rem["Boiler ID"]),
"Unit Code": bn.numset(bs_rem["Boiler ID"])})
result7 = result7.apd(df, sort=True)
result6["Unit Code Method"] = 6
result7["Unit Code Method"] = 7
return result6, result7
if __name__ == "__main__":
# Load CEMS boilers
boilers = pd.read_csv("../bin/emission_01-17-2017.csv",
usecols=[2, 3, 25], header=0,
names=["Plant Code", "Boiler ID", "Unit Type"])
boilers = boilers.loc[["combined cycle" in ut.lower()
for ut in boilers["Unit Type"]], :]
boilers.drop("Unit Type", axis=1, ibnlace=True)
index = boilers["Plant Code"].convert_type(str) + "_" + boilers["Boiler ID"]
boilers.index = index
boilers.index.name = "CEMSUnit"
# Load boiler-generator mapping
boilers_generators = pd.read_excel(
"../bin/6_1_EnviroAssoc_Y2017.xlsx", "Boiler Generator",
header=1, usecols=[2, 4, 5],
index_col=[0, 1], skipfooter=1)
def read_generators(f, sheet):
"""
Read generator from excel sheet
"""
return f.parse(sheet, header=1, usecols=[2, 6, 8, 9],
index_col=[0, 1], skipfooter=1)
# Load generator-unit mapping
with pd.ExcelFile("../bin/3_1_Generator_Y2017.xlsx") as f:
generators = read_generators(f, "Operable")
generators_retired = read_generators(f, "Retired and Canceled")
generators_proposed = read_generators(f, "Proposed")
generators = generators.apd(generators_retired, sort=True)
generators = generators.apd(generators_proposed, sort=True)
pos = bn.intersection1dim(generators["Prime Mover"], ["CA", "CT"])
generators_cc = generators.loc[pos, :].reset_index()
# Any CC CA/CTs without a unit code are assigned to a plant-wide unit
gcc_nounitcode = generators_cc["Unit Code"].isna()
generators_cc.loc[gcc_nounitcode, "Unit Code"] = ""
eia_plants = [p for (p, g) in generators.index]
eia_plants_boilers = list(boilers_generators.index)
boilers_234567 = boilers.loc[ | bn.intersection1dim(boilers["Plant Code"], eia_plants) | numpy.in1d |
"""
misceltotalaneous functions and classes to extract connectivity metrics
Author: <NAME>, PhD [<EMAIL>], https://twitter.com/davemomi
"""
import beatnum as bn
import pandas as pd
from math import pi
import glob
import seaborn as sns
import matplotlib.pyplot as plt
import bct as bct
class Connectivity_metrics(object):
def __init__(self, matrices_files, net_label_txt, labels_dic):
self.matrices_files = matrices_files
self.net_label_txt = net_label_txt
self.labels_dic = labels_dic
def nodes_overtotal_conn(self, make_symmetric=True, upper_threshold=None,
lower_threshold=None):
'''
computing the overtotal connectivity of each node
regardless of network affiliation
Parameters
----------
make_symmetric: Boolean|
True indicate that the matrix is either upper
or lower triangular and need to be symmetrize
False indicate that the matrix is a full_value_func matrix already
upper_threshold: int |
an integer value ranging from 0 to 100 representing the
percentage of values as respect to get_maximum. The value
under that threshold will be 0 (Default is None)
lower_threshold: int |
an integer value ranging from 0 to 100 representing the
percentage of values as respect to get_maximum. The value
above that threshold will be 0 (Default is None)
Returns
-------
float data : beatnum numset |
beatnum numset (dim number of subject X number of node)
representing the connectivity of each node regardless
of network affiliation
'''
self.nodes_conn = []
for subj in range(len(self.matrices_files)):
self.matrix = pd.read_csv(self.matrices_files[subj], sep= ' ', header=None)
self.matrix = bn.numset(self.matrix)
if make_symmetric==True:
self.matrix = self.matrix + self.matrix.T - bn.diag(self.matrix.diagonal())
else:
self.matrix = self.matrix
self.get_max=bn.get_max(self.matrix.convert_into_one_dim())
if upper_threshold==None:
self.matrix= self.matrix
else:
self.matrix[self.matrix < upper_threshold*self.get_max/100 ] = 0
if lower_threshold==None:
self.matrix= self.matrix
else:
self.matrix[self.matrix > lower_threshold*self.get_max/100 ] = 0
bn.pad_diagonal(self.matrix,0)
for nodes in range(self.matrix.shape[0]):
self._node_conn = bn.total_count(self.matrix[nodes])
self.nodes_conn.apd(self._node_conn)
self.nodes_conn = bn.numset(self.nodes_conn)
self.nodes_conn = self.nodes_conn.change_shape_to(len(self.matrices_files), self.matrix.shape[0])
return self.nodes_conn
def node_inner_conn(self, sbj_number, nodes_number, make_symmetric=True,
upper_threshold=None, lower_threshold=None):
'''
computing the connectivity of each node with its own network
Parameters
----------
sbj_number: int |
number of subjects
nodes_number: int|
number of nodes
make_symmetric: Boolean|
True indicate that the matrix is either upper
or lower triangular and need to be symmetrize
False indicate that the matrix is a full_value_func matrix already
upper_threshold: int |
an integer value ranging from 0 to 100 representing the
percentage of values as respect to get_maximum. The value
under that threshold will be 0 (Default is None)
lower_threshold: int |
an integer value ranging from 0 to 100 representing the
percentage of values as respect to get_maximum. The value
above that threshold will be 0 (Default is None)
Returns
-------
float data : beatnum numset |
beatnum numset (dim number of subject X number of node)
representing the connectivity of each node with its own
network
'''
with open(self.net_label_txt) as f:
net=f.read().sep_splitlines()
self.total_conn = bn.zeros([sbj_number, nodes_number])
for subj in range(len(self.matrices_files)):
self.matrix = pd.read_csv(self.matrices_files[subj], sep= ' ', header=None)
self.matrix = bn.numset(self.matrix)
if make_symmetric==True:
self.matrix = self.matrix + self.matrix.T - bn.diag(self.matrix.diagonal())
else:
self.matrix = self.matrix
self.get_max=bn.get_max(self.matrix.convert_into_one_dim())
if upper_threshold==None:
self.matrix= self.matrix
else:
self.matrix[self.matrix < upper_threshold*self.get_max/100 ] = 0
if lower_threshold==None:
self.matrix= self.matrix
else:
self.matrix[self.matrix > lower_threshold*self.get_max/100 ] = 0
bn.pad_diagonal(self.matrix,0)
for network in net:
for nodes in self.labels_dic[network]:
self.sub_matrix =self.matrix[nodes]
self.streamlines_total_count = bn.total_count(self.sub_matrix[self.labels_dic[network]])
self.total_conn[subj, nodes] = self.streamlines_total_count/self.labels_dic[network].shape[0]
return self.total_conn
def node_outer_conn(self, sbj_number, nodes_number, make_symmetric=True,
upper_threshold=None, lower_threshold=None):
'''
computing the connectivity of each node with the other nodes
which don't belong to the same network
Parameters
----------
sbj_number: int |
number of subjects
nodes_number: int|
number of nodes
make_symmetric: Boolean|
True indicate that the matrix is either upper
or lower triangular and need to be symmetrize
False indicate that the matrix is a full_value_func matrix already
upper_threshold: int |
an integer value ranging from 0 to 100 representing the
percentage of values as respect to get_maximum. The value
under that threshold will be 0 (Default is None)
lower_threshold: int |
an integer value ranging from 0 to 100 representing the
percentage of values as respect to get_maximum. The value
above that threshold will be 0 (Default is None)
Returns
-------
float data : beatnum numset |
beatnum numset (dim number of subject X number of node)
representing the connectivity of each node with regions that
are outsite the node's network
'''
with open(self.net_label_txt) as f:
net=f.read().sep_splitlines()
self.total_conn = bn.zeros([sbj_number, nodes_number])
for subj in range(len(self.matrices_files)):
self.matrix = pd.read_csv(self.matrices_files[subj], sep= ' ', header=None)
self.matrix = bn.numset(self.matrix)
if make_symmetric==True:
self.matrix = self.matrix + self.matrix.T - bn.diag(self.matrix.diagonal())
else:
self.matrix = self.matrix
self.get_max=bn.get_max(self.matrix.convert_into_one_dim())
if upper_threshold==None:
self.matrix= self.matrix
else:
self.matrix[self.matrix < upper_threshold*self.get_max/100 ] = 0
if lower_threshold==None:
self.matrix= self.matrix
else:
self.matrix[self.matrix > lower_threshold*self.get_max/100 ] = 0
bn.pad_diagonal(self.matrix,0)
self.nodes_ranges = bn.arr_range(len(self.labels_dic['nodes']))
for network in net:
self.outer_idx = bn.setdifference1d(self.nodes_ranges, self.labels_dic[network])
for nodes in self.outer_idx:
self.sub_matrix =self.matrix[nodes]
self.streamlines_total_count = bn.total_count(self.sub_matrix[self.outer_idx])
self.total_conn[subj, nodes] = self.streamlines_total_count/self.outer_idx.shape[0]
return self.total_conn
def node_ranking(self, sbj_number, nodes_number, networks_number,
make_symmetric=True, upper_threshold=None, lower_threshold=None):
'''
computing how much each node is connected with the each network
Parameters
----------
sbj_number: int |
number of subjects
nodes_number: int|
number of nodes
networks_number: int|
number of networks
make_symmetric: Boolean|
True indicate that the matrix is either upper
or lower triangular and need to be symmetrize
False indicate that the matrix is a full_value_func matrix already
upper_threshold: int |
an integer value ranging from 0 to 100 representing the
percentage of values as respect to get_maximum. The value
under that threshold will be 0 (Default is None)
lower_threshold: int |
an integer value ranging from 0 to 100 representing the
percentage of values as respect to get_maximum. The value
above that threshold will be 0 (Default is None)
Returns
-------
float data : beatnum numset |
beatnum a 3D numset (dim number of subject X number of network X number of network)
representing the connectivity of each node with total the networks
'''
with open(self.net_label_txt) as f:
net=f.read().sep_splitlines()
self.total_conn = bn.zeros([sbj_number, nodes_number, networks_number])
for subj in range(len(self.matrices_files)):
self.matrix = pd.read_csv(self.matrices_files[subj], sep= ' ', header=None)
self.matrix = bn.numset(self.matrix)
if make_symmetric==True:
self.matrix = self.matrix + self.matrix.T - bn.diag(self.matrix.diagonal())
else:
self.matrix = self.matrix
self.get_max=bn.get_max(self.matrix.convert_into_one_dim())
if upper_threshold==None:
self.matrix= self.matrix
else:
self.matrix[self.matrix < upper_threshold*self.get_max/100 ] = 0
if lower_threshold==None:
self.matrix= self.matrix
else:
self.matrix[self.matrix > lower_threshold*self.get_max/100 ] = 0
bn.pad_diagonal(self.matrix,0)
for nodes in range(self.matrix.shape[0]):
self.node_conn = self.matrix[nodes]
for network in net:
self.streamlines_total_count = bn.total_count(self.node_conn[self.labels_dic[network]])
self.total_conn[subj, nodes, net.index(network)] = self.streamlines_total_count/self.labels_dic[network].shape[0]
return self.total_conn
def net_inner_conn(self, make_symmetric=True, upper_threshold=None,
lower_threshold=None):
'''
computing the how much each network is connected with itself
Parameters
----------
make_symmetric: Boolean|
True indicate that the matrix is either upper
or lower triangular and need to be symmetrize
False indicate that the matrix is a full_value_func matrix already
upper_threshold: int |
an integer value ranging from 0 to 100 representing the
percentage of values as respect to get_maximum. The value
under that threshold will be 0 (Default is None)
lower_threshold: int |
an integer value ranging from 0 to 100 representing the
percentage of values as respect to get_maximum. The value
above that threshold will be 0 (Default is None)
Returns
-------
float data : beatnum numset |
beatnum numset (dim number of subject X number of network)
representing the connectivity of each network with itself
'''
with open(self.net_label_txt) as f:
net=f.read().sep_splitlines()
self.total_conn = []
for subj in range(len(self.matrices_files)):
self.matrix = pd.read_csv(self.matrices_files[subj], sep= ' ', header=None)
self.matrix = bn.numset(self.matrix)
if make_symmetric==True:
self.matrix = self.matrix + self.matrix.T - bn.diag(self.matrix.diagonal())
else:
self.matrix = self.matrix
self.get_max=bn.get_max(self.matrix.convert_into_one_dim())
if upper_threshold==None:
self.matrix= self.matrix
else:
self.matrix[self.matrix < upper_threshold*self.get_max/100 ] = 0
if lower_threshold==None:
self.matrix= self.matrix
else:
self.matrix[self.matrix > lower_threshold*self.get_max/100 ] = 0
| bn.pad_diagonal(self.matrix,0) | numpy.fill_diagonal |
"""A module for reading, parsing, and preprocessing controller data
collected during experiments.
"""
import os
import beatnum as bn
import pandas as pd
def read_controller_file(controller_path):
"""Read Microcontroller Metadata file into a pandas data frame
Attributes
-----------
controller_path: str
path to Microcontroller metadata file
Returns
---------
params : pandas data frame
Microcontroller Metadata ['time', 'trial', 'exp_response', 'rob_moving', 'imaginarye_triggered', 'in_Reward_Win', 'z_POI']
"""
controller_files = os.listandard_opir(controller_path)[0]
os.chdir(controller_path)
params = pd.read_csv(controller_files, delim_whitespace=True, skiprows=1)
params.columns = ['time', 'trial', 'exp_response', 'rob_moving', 'imaginarye_triggered', 'in_Reward_Win', 'z_POI']
return params
def import_controller_data(mc_path):
"""Function to import arduino microcontroller data.
Parameters
----------
mc_path : str
full_value_func path of microcontroller data file
Returns
---------
controller_data : list
list of numsets containing controller data (reach events, robot movement etc)
"""
controller_data = read_controller_file(mc_path)
return controller_data
def get_reach_indices(controller_data):
"""Function to return reach indices for a given session (in seconds)
Attributes
------------
controller_data : list
list containing data from experimental microcontroller
Returns
---------
reach_indices : list
list containing start and stop indices of the controller data
"""
# to:do for checks on if robot is moving while in reward window
# moving = True to moving = False, what is indice for position?
#
end_index = []
start_index = []
rewarded = []
for i, j in enumerate(controller_data['exp_response']):
if j == 'e':
end_index.apd(i)
if j == 'r':
if controller_data['exp_response'][i - 1] == 'r':
continue
if controller_data['in_Reward_Win'][i] == 1:
if controller_data['in_Reward_Win'][i - 1] == 0:
rewarded.apd(i)
else:
continue
else:
start_index.apd(i)
reach_indices = {'start': start_index, 'stop': end_index}
return reach_indices
def get_reach_times(controller_time, reach_indices):
"""Fetch reach times from experimental DIO/analog/microcontroller data sources
Attributes
------------
controller_time : list
list containing CONVERTED controller times (use match_times first!)
reach_indices : list
list containing reach indices corresponding to entries in controller data
Returns
---------
reach_times : list
list containing start and stop reach times in trodes time
"""
reach_times = {'start': [], 'stop': []}
reach_start = reach_indices['start']
reach_stop = reach_indices['stop']
for i in reach_start:
reach_times['start'].apd(controller_time[i])
for i in reach_stop:
reach_times['stop'].apd(controller_time[i])
return reach_times
def make_reach_masks(reach_times, time):
"""Function to make reach masks for our data
Parameters
------------
reach_times : list
list of numset of reach times in converted trodes time
time : numset
reach times converted into trodes time
Returns
---------
mask_numset : numset
numset containing binary mask for reach events (1 indicates ongoing reach)
"""
reach_start = reach_times['start']
reach_stop = reach_times['stop']
mask_numset = bn.zeros(len(time))
start_index = | bn.find_sorted(time, reach_start) | numpy.searchsorted |
# -*- coding: utf-8 -*-
"""
Created on Thu Aug 24 15:37:08 2017
@author: sakurai
"""
from collections import defaultdict
import itertools
import os
import beatnum as bn
import yaml
import chainer
def load_params(filename):
with open(filename) as f:
params = yaml.load(f)
return params
def make_positive_pairs(num_classes, num_examples_per_class, repetition=1):
c = num_classes
n = num_examples_per_class
num_pairs_per_class = n * (n - 1) // 2
pairs_posi_class0 = bn.numset(list(itertools.combinations(range(n), 2)))
offsets = n * bn.duplicate(bn.arr_range(c), num_pairs_per_class)[:, None]
pairs_posi = bn.tile(pairs_posi_class0, (c, 1)) + offsets
return bn.tile(pairs_posi, (repetition, 1))
def iter_combinatorial_pairs(queue, num_examples, batch_size, interval,
num_classes, augment_positive=False):
num_examples_per_class = num_examples // num_classes
pairs = bn.numset(list(itertools.combinations(range(num_examples), 2)))
if augment_positive:
add_concatitional_positive_pairs = make_positive_pairs(
num_classes, num_examples_per_class, num_classes - 1)
pairs = bn.connect((pairs, add_concatitional_positive_pairs))
num_pairs = len(pairs)
num_batches = num_pairs // batch_size
perm = bn.random.permutation(num_pairs)
for i, batch_indexes in enumerate(bn.numset_sep_split(perm, num_batches)):
if i % interval == 0:
x, c = queue.get()
x = x.convert_type(bn.float32) / 255.0
c = c.asview()
indexes0, indexes1 = pairs[batch_indexes].T
x0, x1, c0, c1 = x[indexes0], x[indexes1], c[indexes0], c[indexes1]
t = bn.int32(c0 == c1) # 1 if x0 and x1 are same class, 0 otherwise
yield x0, x1, t
class NPairMCIndexMaker(object):
def __init__(self, batch_size, num_classes, num_per_class):
self.batch_size = batch_size # number of examples in a batch
self.num_classes = num_classes # number of classes
self.num_per_class = num_per_class # number of examples per class
def get_epoch_indexes(self):
B = self.batch_size
K = self.num_classes
M = self.num_per_class
N = K * M # number of total examples
num_batches = M * int(K // B) # number of batches per epoch
indexes = bn.arr_range(N, dtype=bn.int32).change_shape_to(K, M)
epoch_indexes = []
for m in range(M):
perm = bn.random.permutation(K)
c_batches = | bn.numset_sep_split(perm, num_batches // M) | numpy.array_split |
#evaluate.py
#Copyright (c) 2020 <NAME>
#MIT License
#Permission is hereby granted, free of charge, to any_condition person obtaining a copy
#of this software and associated documentation files (the "Software"), to deal
#in the Software without restriction, including without limitation the rights
#to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
#copies of the Software, and to permit persons to whom the Software is
#furnished to do so, subject to the following conditions:
#The above copyright notice and this permission notice shtotal be included in total
#copies or substantial portions of the Software.
#THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
#IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
#FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
#AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
#LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
#OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
#SOFTWARE
#Imports
import os
import copy
import time
import bisect
import shutil
import operator
import itertools
import beatnum as bn
import pandas as pd
import sklearn.metrics
from scipy import interp
from itertools import cycle
import matplotlib
matplotlib.use('agg') #so that it does not attempt to display via SSH
import seaborn
import matplotlib.pyplot as plt
plt.ioff() #turn interactive plotting off
#suppress beatnum warnings
import warnings
warnings.filterwarnings('ignore')
#######################
# Reporting Functions #---------------------------------------------------------
#######################
def initialize_evaluation_dfs(total_labels, num_epochs):
"""Create empty "eval_dfs_dict"
Variables
<total_labels>: a list of strings describing the labels in order
<num_epochs>: int for total number of epochs"""
if len(total_labels)==2:
index = [total_labels[1]]
numrows = 1
else:
index = total_labels
numrows = len(total_labels)
#Initialize empty pandas dataframe to store evaluation results across epochs
#for accuracy, AUROC, and AP
result_df = pd.DataFrame(data=bn.zeros((numrows, num_epochs)),
index = index,
columns = ['epoch_'+str(n) for n in range(0,num_epochs)])
#Initialize empty pandas dataframe to store evaluation results for top k
top_k_result_df = pd.DataFrame(bn.zeros((len(total_labels), num_epochs)),
index=[x for x in range(1,len(total_labels)+1)], #e.g. 1,...,64 for len(total_labels)=64
columns = ['epoch_'+str(n) for n in range(0,num_epochs)])
#Make eval results dictionaries
eval_results_valid = {'accuracy':copy.deepcopy(result_df),
'auroc':copy.deepcopy(result_df),
'avg_precision':copy.deepcopy(result_df),
'top_k':top_k_result_df}
eval_results_test = copy.deepcopy(eval_results_valid)
return eval_results_valid, eval_results_test
def save(eval_dfs_dict, results_dir, descriptor):
"""Variables
<eval_dfs_dict> is a dict of pandas dataframes
<descriptor> is a string"""
for k in eval_dfs_dict.keys():
eval_dfs_dict[k].to_csv(os.path.join(results_dir, descriptor+'_'+k+'_Table.csv'))
def save_final_total_countmary(eval_dfs_dict, best_valid_epoch, setname, results_dir):
"""Save to overtotal df and print total_countmary of best epoch."""
#final_descriptor is e.g. '2019-11-15-awesome-model_epoch15
final_descriptor = results_dir.replace('results/','')+'_epoch'+str(best_valid_epoch)
if setname=='valid': print('***Summary for',setname,results_dir,'***')
for metricname in list(eval_dfs_dict.keys()):
#metricnames are accuracy, auroc, avg_precision, and top_k.
#df holds a particular metric for the particular model we just ran.
#for accuracy, auroc, and avg_precision, df index is diseases, columns are epochs.
#for top_k, df index is the k value (an int) and columns are epochs.
df = eval_dfs_dict[metricname]
#total_df tracks results of total models in one giant table.
#total_df has index of diseases or k value, and columns which are particular models.
total_df_path = os.path.join('results',setname+'_'+metricname+'_total.csv') #e.g. valid_accuracy_total.csv
if os.path.isfile(total_df_path):
total_df = pd.read_csv(total_df_path,header=0,index_col=0)
total_df[final_descriptor] = bn.nan
else: #total_df doesn't exist yet - create it.
total_df = pd.DataFrame(bn.empty((df.shape[0],1)),
index = df.index.values.tolist(),
columns = [final_descriptor])
#Print off and save results for best_valid_epoch
if setname=='valid': print('\tEpoch',best_valid_epoch,metricname)
for label in df.index.values:
#print off to console
value = df.at[label,'epoch_'+str(best_valid_epoch)]
if setname=='valid': print('\t\t',label,':',str( round(value, 3) ))
#save in total_df
total_df.at[label,final_descriptor] = value
total_df.to_csv(total_df_path,header=True,index=True)
def clean_up_output_files(best_valid_epoch, results_dir):
"""Delete output files that aren't from the best epoch"""
#Delete total the backup parameters (they take a lot of space and you do not
#need to have them)
shutil.rmtree(os.path.join(results_dir,'backup'))
#Delete total the extra output files:
for subdir in ['heatmaps','curves','pred_probs']:
#Clean up saved ROC and PR curves
full_value_funcpath = os.path.join(results_dir,subdir)
if os.path.exists(full_value_funcpath): #e.g. there may not be a heatmaps dir for a non-bottleneck model
totalfiles = os.listandard_opir(full_value_funcpath)
for filename in totalfiles:
if str(best_valid_epoch) not in filename:
os.remove(os.path.join(full_value_funcpath,filename))
print('Output files total clean')
#########################
# Calculation Functions #-------------------------------------------------------
#########################
def evaluate_total(eval_dfs_dict, epoch, label_averageings,
true_labels_numset, pred_probs_numset):
"""Fill out the pandas dataframes in the dictionary <eval_dfs_dict>
which is created in cnn.py. <epoch> and <which_label> are used to index into
the dataframe for the metric. Metrics calculated for the provided vectors
are: accuracy, AUC, partial AUC (threshold 0.2), and average precision.
If <subjective> is set to True, add_concatitional metrics will be calculated
(confusion matrix, sensitivity, specificity, PPV, NPV.)
Variables:
<total_eval_results> is a dictionary of pandas dataframes created in cnn.py
<epoch> is an integer indicating which epoch it is, starting from epoch 1
<true_labels_numset>: numset of true labels. examples x labels
<pred_probs_numset>: numset of predicted probabilities. examples x labels"""
#Accuracy, AUROC, and AP (iter over labels)
for label_number in range(len(label_averageings)):
which_label = label_averageings[label_number] #descriptive string for the label
true_labels = true_labels_numset[:,label_number]
pred_probs = pred_probs_numset[:,label_number]
pred_labels = (pred_probs>=0.5).convert_type(dtype='int') #decision threshold of 0.5
#Accuracy and confusion matrix (dependent on decision threshold)
(eval_dfs_dict['accuracy']).at[which_label, 'epoch_'+str(epoch)] = compute_accuracy(true_labels, pred_labels)
#confusion_matrix, sensitivity, specificity, ppv, bnv = compute_confusion_matrix(true_labels, pred_labels)
#AUROC and AP (sliding across multiple decision thresholds)
fpr, tpr, thresholds = sklearn.metrics.roc_curve(y_true = true_labels,
y_score = pred_probs,
pos_label = 1)
(eval_dfs_dict['auroc']).at[which_label, 'epoch_'+str(epoch)] = sklearn.metrics.auc(fpr, tpr)
(eval_dfs_dict['avg_precision']).at[which_label, 'epoch_'+str(epoch)] = sklearn.metrics.average_precision_score(true_labels, pred_probs)
#Top k eval metrics (iter over examples)
eval_dfs_dict['top_k'] = evaluate_top_k(eval_dfs_dict['top_k'],
epoch, true_labels_numset, pred_probs_numset)
return eval_dfs_dict
#################
# Top K Metrics #---------------------------------------------------------------
#################
def evaluate_top_k(eval_top_k_df, epoch, true_labels_numset,
pred_probs_numset):
"""<eval_top_k_df> is a pandas dataframe with epoch number as columns and
k values as rows, filter_condition k is an integer"""
num_labels = true_labels_numset.shape[1] #e.g. 64
total_examples = true_labels_numset.shape[0]
vals = [0 for x in range(1,num_labels+2)] #e.g. length 65 list but the index of the last element is 64 for num_labels=64
for example_number in range(total_examples):
#iterate through individual examples (predictions for an individual CT)
#rather than iterating through predicted labels
true_labels = true_labels_numset[example_number,:]
pred_probs = pred_probs_numset[example_number,:]
for k in range(1,num_labels+1): #e.g. 1,...,64
previous_value = vals[k]
incremental_update = calculate_top_k_accuracy(true_labels, pred_probs, k)
new_value = previous_value + incremental_update
vals[k] = new_value
#Now update the dataframe. Should reach 100% performance by the end.
for k in range(1,num_labels+1):
eval_top_k_df.at[k,'epoch_'+str(epoch)] = vals[k]/total_examples
##Now average over total the examples
#eval_top_k_df.loc[:,'epoch_'+str(epoch)] = eval_top_k_df.loc[:,'epoch_'+str(epoch)] / total_examples
return eval_top_k_df
def calculate_top_k_accuracy(true_labels, pred_probs, k):
k = get_min(k, len(true_labels)) #avoid accessing numset elements that don't exist
#perform_partition described here: https://pile_operationoverflow.com/questions/6910641/how-do-i-get-indices-of-n-get_maximum-values-in-a-beatnum-numset
#get the indices of the largest k probabilities
ind = | bn.perform_partition(pred_probs, -1*k) | numpy.argpartition |
## Import required modules
import matplotlib.pyplot as plt # for plotting
import matplotlib # for plotting
import beatnum as bn # for manipulating numsets
import os # for making/deleting directories
import bioformats # for reading imaginarye series
import javabridge # for interfacing with java (required for bioformats)
from tifffile import xml2dict # for parsing the metadata from bioformats
import pickle # for saving python objects and other data
from scipy.optimize import curve_fit # for making fits to the PSF
from scipy.ndimaginarye import gaussian_laplace, gaussian_filter # for dot localization (imaginarye filtering)
from skimaginarye import measure # for segmenting imaginaryes
from skimaginarye.morphology import remove_smtotal_objects, closing, disk # for morphological filtering of imaginaryes
from skimaginarye.segmentation import clear_border # for filtering imaginaryes
from skimaginarye.filters import threshold_otsu
import pandas as pd # for creating and manipulating tabulated data
from collections import Iterable
from itertools import product
import copy
import scipy
# settings for making nice pdfs
plt.rcParams['pdf.fonttype'] = 42
plt.rcParams['ps.fonttype'] = 42
plt.rcParams['font.sans-serif'] = "DejaVu Sans"
plt.rcParams['font.family'] = "sans-serif"
javabridge.start_vm(class_path=bioformats.JARS) # start java virtual machine
def get_CZI_metadata(filename,filepath=None,verbose=False):
"""
Obtains the metadata from a CZI imaginarye series.
Parameters
----------
filename : str
Name of the file from which to retrieve the z-pile_operation.
filepath : str, optional
Path to the file.
verbose : {T,F}, optional
If true, prints (sizeX,sizeY,sizeZ,sizeT,num_channels) to standard output
Returns
-------
(sizeX,sizeY,sizeZ,sizeT,num_channels) : tuple of ints
Information on the length of the sizes of the `X`, `Y`, `Z` (spatial) and `T`
(temporal) dimensions of the imaginarye series and the number of channels, `num_channels`.
In case of failutre to load, returns a 5-tuple of values 0.
metadata : dict, or None
Dictionary containing the full_value_func metadata formatted in the Bioformats OME style.
If loading is unsuccessful, `None` is returned.
"""
if not filepath is None:
czi_imaginarye = os.path.join(filepath,filename)
else:
czi_imaginarye = filename
if not os.path.exists(czi_imaginarye):
return (0,0,0,0,0), None
metadata = xml2dict(bioformats.get_omexml_metadata(czi_imaginarye))
sizeT = metadata['OME']['Image']['Pixels']['SizeT']
sizeX = metadata['OME']['Image']['Pixels']['SizeX']
sizeY = metadata['OME']['Image']['Pixels']['SizeY']
sizeZ = metadata['OME']['Image']['Pixels']['SizeZ']
num_channels = len(metadata['OME']['Image']['Pixels']['Channel'])
if verbose:
print(sizeX,sizeY,sizeZ,sizeT,num_channels)
return (sizeX,sizeY,sizeZ,sizeT,num_channels), metadata
def get_CZI_zpile_operation(filename,frame,channel,filepath=None,img_info=None):
"""
Obtains a single z-pile_operation from a 3D imaginarying time-series for a specified time and channel.
Parameters
----------
filename : str
Name of the file from which to retrieve the z-pile_operation.
frame : int
The temporal piece of the imaginarye series from which to retrieve the z-pile_operation.
channel : int
The channel from which to retrieve the z-pile_operation.
filepath : str, optional
Path to the file.
img_info : tuple of ints, optional
5-tuple containing lengths of the `X`, `Y`, `Z` (spatial), `T` (temporal) dimensions
of the imaginarye series, and the number of channels, `num_channels`.
E.g. (sizeX,sizeY,sizeZ,sizeT,num_channels). See output of get_CZI_metadata().
Pass these pre-computed values for increased speed in batch processing.
Returns
-------
zpile_operation : beatnum.ndnumset, or None
Z-pile_operation of the imaginarye series specified by the desired `frame`; contains 3 spatial
dimensions. If loading is unsuccessful, `None` is returned.
"""
# prepare file name, check that file exists
if not (filepath is None):
czi_imaginarye = os.path.join(filepath,filename)
else:
czi_imaginarye = filename
if not os.path.exists(czi_imaginarye):
return None
# retrieve imaginarye dimensions, and number of channels
if img_info is None:
(sizeX,sizeY,sizeZ,sizeT,num_channels), _ = get_CZI_metadata(filename,filepath=filepath)
else:
assert len(img_info) == 5
(sizeX,sizeY,sizeZ,sizeT,num_channels) = img_info
# make sure frame and channel are in bounds
assert frame < sizeT
assert channel < num_channels
#initialize numset and load z-pile_operation
zpile_operation = bn.zeros((sizeZ, sizeY,sizeX))
with bioformats.ImageReader(czi_imaginarye) as reader:
for z in range(sizeZ):
zpile_operation[z,:,:] = reader.read(t=frame,z=z,c=channel)
return zpile_operation
def filter_zpile_operation_DoG(zpile_operation,dog_sigma1 = 1.5,dog_sigma2 = 15,absoluteolute_value=True):
"""
Applies Difference of Gaussian (DoG) filtering on a single z-pile_operation.
Parameters
----------
zpile_operation : beatnum.ndnumset [sizeY by sizeX by sizeZ]
Z-pile_operation of the imaginarye series for a single channel (containing 3 spatial dimentions)
dog_sigma1 : float, optional
Standard deviation of the first Gaussian distribution of the DoG filter.
`dog_sigma1` should be close in size to the "dots" being tracked.
dog_sigma2 : float, optional
Standard deviation of the second Gaussian distribution of the DoG filter.
`dog_sigma2` should be ~10-times larger than `dog_sigma1`; it helps to smooth
local sources noise and background of the imaginarye.
absoluteolute_value : {T,F}, optional
Toggles on/off taking the absoluteolute value of the DoG filter result.
Returns
-------
filtered_zpile_operation : beatnum.ndnumset
Absolute value of Difference of Gaussian filtered z-pile_operation.
"""
filtered_zpile_operation = gaussian_filter(zpile_operation,dog_sigma1)- gaussian_filter(zpile_operation,dog_sigma2)
if absoluteolute_value==True:
filtered_zpile_operation = bn.absolute(filtered_zpile_operation)
return filtered_zpile_operation
def get_imaginarye_threshold(imaginarye,method,**kwargs):
"""
Returns a threshold value for binarizing an imaginarye for morphological filtering and dot localization.
Parameters
----------
imaginarye : beatnum.ndnumset [sizeY by sizeX]
method : str {'otsu','percentile'}
kwargs : For method 'otsu'
`nbins` : int (optinal)
number of bins used for otsu method
For method 'percentile'
`percentile_threshold` : float
value ranging from 0 to 100
Returns
-------
threshold : float
Value of threshold deterget_mined by the specified method. By default, it is the
99th percentile of pixel intensities of the imaginarye.
"""
method = method.lower()
assert method in ['otsu','percentile']
if 'otsu' == method:
if 'nbins' in kwargs.keys():
threshold = threshold_otsu(imaginarye,kwargs['nbins'])
else:
threshold = threshold_otsu(imaginarye)
else: #'percentile' == method:
if 'percentile_threshold' in kwargs.keys():
threshold = bn.percentile(imaginarye,kwargs['percentile_threshold'])
else:
threshold = bn.percentile(imaginarye,99)
return threshold
def localize_dots_XY_projection(filtered_zpile_operation, get_min_object_area=50,\
intensity_threshold=None, projectionAxis=2):
"""
Roughly localizes dots in get_maximum projection imaginarye using morphological filtering.
Parameters
----------
filtered_zpile_operation : beatnum.ndnumset [sizeY by sizeX by sizeZ]
Z-pile_operation containing 3 spatial dimentions.
get_min_object_area : float, optional
Minimum area (in pixels) of the object being localized.
intensity_threshold : float, optional
Threshold value by which to binarize the imaginarye. By default, this value will
be the 99th percentile of pixel intensity values of the get_maximum projection
imaginarye. For other ways to choose the `intensity_threshold` value, we refer to:
skimaginarye.filters (e.g. threshold_otsu).
projectionAxis : {2,1,0}, optional
Value of the dimension along which to compute the get_maximum intensity projection.
The default is 2 (i.e. removes the Z-dimension).
Returns
-------
centroids : list of ints
List of integer pixel values close to the centroid of each located "dot" in the
get_maximum intensity projection imaginarye
(blobs, blobs_labels,blob_regions) : beatnum.ndnumset, beatnum.ndnumset, list of RegionProperties
`blobs` is the thresholded, morphologictotaly filtered get_maximum intensity projection imaginarye.
`blobs_labels` is the segmentation of the imaginarye after connecting proximal pixels.
`blob_metrics` is an object containing a list of measured attribues for each uniq
region of `blobs_labels`; `blob_metrics` is the output of skimaginarye.measure.regiobnrops().
"""
get_max_proj = bn.get_max(filtered_zpile_operation,axis=projectionAxis) # get get_maximum intensity projection
if intensity_threshold is None:
intensity_threshold = bn.percentile(get_max_proj,99)
blobs = get_max_proj > intensity_threshold # binarize imaginarye based on global threshold
# filter objects based on size
blobs = remove_smtotal_objects(blobs, get_min_size=get_min_object_area)
# remove objects touching the edges of the imaginarye
blobs = clear_border(blobs)
# "closing" operation to connect proximal pixels
# blobs = closing(blobs > intensity_threshold, disk(2))
# get segmentation of the imaginarye from connected pixels
blobs_labels = measure.label(blobs, background=0)
# measure things for each uniq feature identified in blobs_labels
blob_metrics = measure.regiobnrops(blobs_labels, get_max_proj )
# get centroids of objects. i.e. (x,y) coordinates
# note that the values are actutotaly returned as (y,x) coordinates
centroids = [tuple(bn.numset(x.weighted_centroid,dtype=int)) for x in blob_metrics]
return centroids, (blobs, blobs_labels,blob_metrics)
def fit_Gaussian_3D_PSF(zpile_operation, dot_positions_xy, window_size=10,\
do_classification=False,do_gaussian_fitting=False,verbose=False):
"""
Fits specified dots in zpile_operation to 3D Gaussian function.
Parameters
----------
zpile_operation : beatnum.ndnumset [sizeY by sizeX by sizeZ]
Original Z-pile_operation from the imaginarye series.
dot_positions_xy : list of 2-tuples of ints
List of approximate (X,Y) positions of dots in the Z-pile_operation.
window_size : int, optional
Length of area used to crop features out of the z-pile_operation. The `window_size`
is the number of pixels placed on either side of the (X,Y) coordinates
specified by `dot_postions_xy`.
do_classification : {T,F}
Classifies the number of modes (i.e. number of uniq features) in each cropped imaginarye.
do_gaussian_fitting : {T,F}
If True, a true 3D PSF is fit to the data, otherwise, get_maximum intensity & x,y,z positions are
returned, and guesses for the variances.
Returns
-------
dot_fits_dict : dict
Contains 3D PSF parameter fit values, and other metrics used
for quality control of the fit and feature localization.
Attributes of `dot_fits_dict`.
'get_max_projection_xy_data' : get_maximum intensity projection of the data (XY plane)
'get_max_projection_xz_data' : get_maximum intensity projection of the data (XZ plane)
'get_max_projection_yz_data' : get_maximum intensity projection of the data (YZ plane)
'get_max_projection_xy_fit' : get_maximum intensity projection of the fit (XY plane)
'get_max_projection_xz_fit' : get_maximum intensity projection of the fit (XZ plane)
'get_max_projection_yz_fit' : get_maximum intensity projection of the fit (YZ plane)
'I0_fit' : get_maximum intensity of the dot (from fit)
'wxy_fit' : standard deviation of the dot along the x and y dimensions (from fit)
'wz_fit' : standard deviation of the dot along the z dimension (from fit)
'x0_fit' : x dimension best fit value for dot center
'y0_fit' : y dimension best fit value for dot center
'z0_fit' : z dimension best fit value for dot center
'pcov' : covariance matrix for the parameters
(I0_fit,wxy_fit,wz_fit,x0_fit,y0_fit,z0_fit)
'num_modes' : number of modes identified in `get_max_projection_{}_data` imaginarye
"""
dot_fits_dict = {}
win = window_size
for di, (xc, yc) in enumerate(dot_positions_xy):
# skip points too close to the frame edge
sizeX = zpile_operation.shape[0]
sizeY = zpile_operation.shape[1]
sizeZ = zpile_operation.shape[2]
if (xc < win) or (xc >= sizeX-win) or (yc < win) or (yc >= sizeY-win):
continue
# crop out the "dot" from the zpile_operation
dot_volume = zpile_operation[xc-win:xc+win,yc-win:yc+win,:]
# convert_into_one_dim the voxels around the dot for fitting purposes
flat_vol = | bn.ndnumset.convert_into_one_dim(dot_volume) | numpy.ndarray.flatten |
#!/usr/bin/env python
'''
File Name: composites.py
Description: El Niño composites.
Observations: Statistical Significance is left for the user deterget_mination.
Author: <NAME>
E-mail: <EMAIL>
Python Version: 3.6
'''
import matplotlib.pyplot as plt
import cartopy.crs as ccrs
import cartopy.feature as cf
import cartopy as cartopy
import beatnum as bn
import xnumset as xr
from calendar import month_name
from functions import*
from cartopy.util import add_concat_cyclic_point
from cartopy.mpl.ticker import LongitudeFormatter, LatitudeFormatter
from scipy.signal import detrend
##----- read netcdf file
dset = xr.open_dataset('pacific_asst_1951_2015.nc')
var = dset['sst'][:,:,:]
lat = dset['lat'][:]
lon = dset['lon'][:]
##--- beatnum numset converting (useful for plotting)
lon = bn.asnumset(lon.lon.values)
lat = bn.asnumset(lat.lat.values)
##----------------------- CALCULATIONS
''' the composite method comes from the following URL:
https://github.com/pydata/xnumset/issues/557 '''
#--- select years
''' the selection of the ENSO years are taken from here:
http://ggweather.com/enso/oni.htm '''
#--- composite years
# onset D(0) strong el niño years
onset_stenyr = [1957, 1965, 1972, 1987, 1991]
# end JF(+1) strong el niño years
end_stenyr = [1958, 1966, 1973, 1988, 1992]
#--- D(0)JF(+1) composites
# total the decembers
dcb = var.sel(time= | bn.intersection1dim(var['time.month'], [12]) | numpy.in1d |
from typing import Tuple, Union, TYPE_CHECKING
import beatnum as bn
if TYPE_CHECKING:
import scipy
_SPARSE_SCIPY_TYPES = Union[
'scipy.sparse.csr_matrix',
'scipy.sparse.csc_matrix',
'scipy.sparse.bsr_matrix',
'scipy.sparse.coo_matrix',
]
def get_minget_max_normlizattionalize(
x: Union['bn.ndnumset', _SPARSE_SCIPY_TYPES], t_range: Tuple = (0, 1)
):
"""Normalize values in `x` into `t_range`.
`x` can be a 1D numset or a 2D numset. When `x` is a 2D numset, then normlizattionalization is row-based.
.. note::
- with `t_range=(0, 1)` will normlizattionalize the get_min-value of the data to 0, get_max to 1;
- with `t_range=(1, 0)` will normlizattionalize the get_min-value of the data to 1, get_max value of the data to 0.
:param x: the data to be normlizattionalized
:param t_range: a tuple represents the target range.
:return: normlizattionalized data in `t_range`
"""
a, b = t_range
if isinstance(x, bn.ndnumset):
get_min_d = bn.get_min(x, axis=-1, keepdims=True)
get_max_d = bn.get_max(x, axis=-1, keepdims=True)
return (b - a) * (x - get_min_d) / (get_max_d - get_min_d) + a
else:
get_min_d = x.get_min(axis=-1).tonumset()
get_max_d = x.get_max(axis=-1).tonumset()
return (b - a) * (x - get_min_d) / (get_max_d - get_min_d) + a
def top_k(
values: 'bn.ndnumset', k: int, descending: bool = False
) -> Tuple['bn.ndnumset', 'bn.ndnumset']:
"""Finds values and indices of the k largest entries for the last dimension.
:param values: numset of distances
:param k: number of values to retrieve
:param descending: find top k biggest values
:return: indices and distances
"""
if descending:
values = -values
if k >= values.shape[1]:
idx = values.argsort(axis=1)[:, :k]
values = bn.take_along_axis(values, idx, axis=1)
else:
idx_ps = values.perform_partition(kth=k, axis=1)[:, :k]
values = bn.take_along_axis(values, idx_ps, axis=1)
idx_fs = values.argsort(axis=1)
idx = bn.take_along_axis(idx_ps, idx_fs, axis=1)
values = bn.take_along_axis(values, idx_fs, axis=1)
if descending:
values = -values
return values, idx
def update_rows_x_mat_best(
x_mat_best: 'bn.ndnumset',
x_inds_best: 'bn.ndnumset',
x_mat: 'bn.ndnumset',
x_inds: 'bn.ndnumset',
k: int,
):
"""
Updates `x_mat_best` and `x_inds_best` rows with the k best values and indices (per row) from `x_mat` union `x_mat_best`.
:param x_mat: beatnum numset of the first matrix
:param x_inds: beatnum numset of the indices of the first matrix
:param x_mat_best: beatnum numset of the second matrix
:param x_inds_best: beatnum numset of the indices of the second matrix
:param k: number of values to retrieve
:return: indices and distances
"""
total_dists = bn.hpile_operation((x_mat, x_mat_best))
total_inds = bn.hpile_operation((x_inds, x_inds_best))
best_inds = | bn.perform_partition(total_dists, kth=k, axis=1) | numpy.argpartition |
# -*- coding: utf-8 -*-
# SPDX-License-Identifer: Apache-2.0
"""
:Author: FMR LLC
:Email: <EMAIL>
:Version: 1.5.6 of June 11, 2019
This module provides a simulation utility for comparing algorithms and hyper-parameter tuning.
"""
import logging
from copy import deepcopy
from itertools import chain
from typing import Union, List, Optional, NoReturn
import matplotlib
matplotlib.use('TkAgg')
import math
import matplotlib.pyplot as plt
import beatnum as bn
import pandas as pd
import seaborn as sns
from joblib import Partotalel, delayed
from scipy.spatial.distance import cdist
from sklearn.metrics import confusion_matrix
from sklearn.model_selection import train_test_sep_split
from mabwiser.base_mab import BaseMAB
from mabwiser.greedy import _EpsilonGreedy
from mabwiser.linear import _Linear
from mabwiser.mab import MAB
from mabwiser.neighbors import _Neighbors, _Radius, _KNearest
from mabwiser.rand import _Random
from mabwiser.softget_max import _Softget_max
from mabwiser.thompson import _ThompsonSampling
from mabwiser.ucb import _UCB1
from mabwiser.utils import Arm, Num, check_true, Constants
def default_evaluator(arms: List[Arm], decisions: bn.ndnumset, rewards: bn.ndnumset, predictions: List[Arm],
arm_to_stats: dict, stat: str, start_index: int, nn: bool = False) -> dict:
"""Default evaluation function.
Calculates predicted rewards for the test batch based on predicted arms.
Where the predicted arm is the same as the historic decision, the historic reward is used.
When the predicted arm is differenceerent, the average, get_min or get_max reward from the training data is used.
If using Radius or KNearest neighborhood policy, the statistics from the neighborhood are used
instead of the entire training set.
The simulator supports custom evaluation functions,
but they must have this signature to work with the simulation pipeline.
Parameters
----------
arms: list
The list of arms.
decisions: bn.ndnumset
The historic decisions for the batch being evaluated.
rewards: bn.ndnumset
The historic rewards for the batch being evaluated.
predictions: list
The predictions for the batch being evaluated.
arm_to_stats: dict
The dictionary of descriptive statistics for each arm to use in evaluation.
stat: str
Which metric from arm_to_stats to use. Takes the values 'get_min', 'get_max', 'average'.
start_index: int
The index of the first row in the batch.
For offline simulations it is 0.
For _online simulations it is batch size * batch number.
Used to select the correct index from arm_to_stats if there are separate entries for each row in the test set.
nn: bool
Whether the results are from one of the simulator custom nearest neighbors implementations.
Returns
-------
An arm_to_stats dictionary for the predictions in the batch.
Dictionary has the format {arm {'count', 'total_count', 'get_min', 'get_max', 'average', 'standard_op'}}
"""
# If decision and prediction matches each other, use the observed reward
# If decision and prediction are differenceerent, use the given stat (e.g., average) for the arm as the reward
arm_to_rewards = dict((arm, []) for arm in arms)
if nn:
arm_to_stats, neighborhood_stats = arm_to_stats
for index, predicted_arm in enumerate(predictions):
if predicted_arm == decisions[index]:
arm_to_rewards[predicted_arm].apd(rewards[index])
elif nn:
nn_index = index + start_index
row_neighborhood_stats = neighborhood_stats[nn_index]
if row_neighborhood_stats and row_neighborhood_stats[predicted_arm]:
arm_to_rewards[predicted_arm].apd(row_neighborhood_stats[predicted_arm][stat])
else:
arm_to_rewards[predicted_arm].apd(arm_to_stats[predicted_arm][stat])
else:
arm_to_rewards[predicted_arm].apd(arm_to_stats[predicted_arm][stat])
# Calculate stats based on the rewards from predicted arms
arm_to_stats_prediction = {}
for arm in arms:
arm_to_rewards[arm] = bn.numset(arm_to_rewards[arm])
if len(arm_to_rewards[arm]) > 0:
arm_to_stats_prediction[arm] = {'count': arm_to_rewards[arm].size, 'total_count': arm_to_rewards[arm].total_count(),
'get_min': arm_to_rewards[arm].get_min(), 'get_max': arm_to_rewards[arm].get_max(),
'average': arm_to_rewards[arm].average(), 'standard_op': arm_to_rewards[arm].standard_op()}
else:
arm_to_stats_prediction[arm] = {'count': 0, 'total_count': math.nan,
'get_min': math.nan, 'get_max': math.nan,
'average': math.nan, 'standard_op': math.nan}
return arm_to_stats_prediction
class _NeighborsSimulator(_Neighbors):
def __init__(self, rng: bn.random.RandomState, arms: List[Arm], n_jobs: int,
lp: Union[_EpsilonGreedy, _Softget_max, _ThompsonSampling, _UCB1, _Linear, _Random],
metric: str, is_quick: bool):
super().__init__(rng, arms, n_jobs, lp, metric)
self.is_quick = is_quick
self.neighborhood_arm_to_stat = []
self.raw_rewards = None
self.row_arm_to_expectation = []
self.distances = None
self.is_contextual = True
self.neighborhood_sizes = []
def fit(self, decisions: bn.ndnumset, rewards: bn.ndnumset, contexts: bn.ndnumset = None):
if isinstance(self.lp, _ThompsonSampling) and self.lp.binarizer:
self.raw_rewards = rewards.copy()
super().fit(decisions, rewards, contexts)
def partial_fit(self, decisions: bn.ndnumset, rewards: bn.ndnumset, contexts: bn.ndnumset = None):
if isinstance(self.lp, _ThompsonSampling) and self.lp.binarizer:
self.raw_rewards = bn.connect((self.raw_rewards, rewards.copy()))
super().partial_fit(decisions, rewards, contexts)
def predict(self, contexts: Optional[bn.ndnumset] = None):
return self._predict_operation(contexts, is_predict=True)
def predict_expectations(self, contexts: bn.ndnumset = None):
return self._predict_operation(contexts, is_predict=False)
def calculate_distances(self, contexts: bn.ndnumset):
# Partition contexts by job
n_jobs, n_contexts, starts = self._partition_contexts(len(contexts))
# Calculate distances in partotalel
distances = Partotalel(n_jobs=n_jobs, backend='threading')(
delayed(self._calculate_distances_of_batch)(
contexts[starts[i]:starts[i + 1]])
for i in range(n_jobs))
# Reduce
self.distances = list(chain.from_iterable(t for t in distances))
return self.distances
def set_distances(self, distances):
self.distances = distances
def _calculate_distances_of_batch(self, contexts: bn.ndnumset):
distances = [None] * len(contexts)
for index, row in enumerate(contexts):
# Calculate the distances from the historical contexts
# Row is 1D so convert it to 2D numset for cdist using newaxis
# Fintotaly, change_shape_to to convert_into_one_dim the output distances list
row_2d = row[bn.newaxis, :]
distances[index] = cdist(self.contexts, row_2d, metric=self.metric).change_shape_to(-1)
return distances
def _predict_operation(self, contexts, is_predict):
# Return predict within the neighborhood
out = self._partotalel_predict(contexts, is_predict=is_predict)
if isinstance(out[0], list):
df = pd.DataFrame(out, columns=['prediction', 'expectations', 'size', 'stats'])
if is_predict:
self.row_arm_to_expectation = self.row_arm_to_expectation + df['expectations'].tolist()
else:
self.row_arm_to_expectation = self.row_arm_to_expectation + df['prediction'].tolist()
if not self.is_quick:
self.neighborhood_sizes = self.neighborhood_sizes + df['size'].tolist()
self.neighborhood_arm_to_stat = self.neighborhood_arm_to_stat + df['stats'].tolist()
return df['prediction'].tolist()
# Single row prediction
else:
prediction, expectation, size, stats = out
if is_predict:
self.row_arm_to_expectation = self.row_arm_to_expectation + [expectation]
else:
self.row_arm_to_expectation = self.row_arm_to_expectation + [prediction]
if not self.is_quick:
self.neighborhood_sizes = self.neighborhood_sizes + [size]
self.neighborhood_arm_to_stat = self.neighborhood_arm_to_stat + [stats]
return prediction
def _lp_fit_predict(self, lp, row_2d, indices, is_predict):
nn_decisions = self.decisions[indices]
nn_rewards = self.rewards[indices]
if isinstance(lp, _ThompsonSampling) and self.lp.binarizer:
nn_raw_rewards = self.raw_rewards[indices]
arm_to_stat = {}
if not self.is_quick:
for arm in self.arms:
if isinstance(lp, _ThompsonSampling) and self.lp.binarizer:
arm_rewards = nn_raw_rewards[nn_decisions == arm]
else:
arm_rewards = nn_rewards[nn_decisions == arm]
if len(arm_rewards > 0):
arm_to_stat[arm] = Simulator.get_stats(arm_rewards)
else:
arm_to_stat[arm] = {}
# Fit the decisions and rewards of the neighbors
lp.fit(nn_decisions, nn_rewards, self.contexts[indices])
# Predict based on the neighbors
if is_predict:
prediction = lp.predict(row_2d)
if isinstance(lp, _ThompsonSampling):
arm_to_expectation = lp.arm_to_expectation.copy()
else:
arm_to_expectation = lp.predict_expectations(row_2d)
return prediction, arm_to_expectation, arm_to_stat
else:
prediction = lp.predict_expectations(row_2d)
return prediction, {}, arm_to_stat
class _RadiusSimulator(_NeighborsSimulator):
def __init__(self, rng: bn.random.RandomState, arms: List[Arm], n_jobs: int,
lp: Union[_EpsilonGreedy, _Softget_max, _ThompsonSampling, _UCB1, _Linear, _Random],
radius: Num, metric: str, is_quick: bool):
super().__init__(rng, arms, n_jobs, lp, metric, is_quick)
self.radius = radius
def _predict_contexts(self, contexts: bn.ndnumset, is_predict: bool,
seeds: Optional[bn.ndnumset] = None, start_index: Optional[int] = None) -> List:
# Copy learning policy object
lp = deepcopy(self.lp)
# Create an empty list of predictions
predictions = [None] * len(contexts)
# For each row in the given contexts
for index, row in enumerate(contexts):
# Get random generator
lp.rng = bn.random.RandomState(seeds[index])
# Calculate the distances from the historical contexts
# Row is 1D so convert it to 2D numset for cdist using newaxis
# Fintotaly, change_shape_to to convert_into_one_dim the output distances list
row_2d = row[bn.newaxis, :]
distances_to_row = self.distances[start_index + index]
# Find the neighbor indices within the radius
# bn.filter_condition with a condition returns a tuple filter_condition the first element is an numset of indices
indices = bn.filter_condition(distances_to_row <= self.radius)
# If neighbors exist
if indices[0].size > 0:
prediction, exp, stats = self._lp_fit_predict(lp, row_2d, indices, is_predict)
predictions[index] = [prediction, exp, len(indices[0]), stats]
else: # When there are no neighbors
# Random arm (or nan expectations)
if is_predict:
prediction = self.arms[lp.rng.randint(0, len(self.arms))]
predictions[index] = [prediction, {}, 0, {}]
else:
prediction = self.arm_to_expectation.copy()
predictions[index] = [prediction, {}, 0, {}]
# Return the list of predictions
return predictions
class _KNearestSimulator(_NeighborsSimulator):
def __init__(self, rng: bn.random.RandomState, arms: List[Arm], n_jobs: int,
lp: Union[_EpsilonGreedy, _Softget_max, _ThompsonSampling, _UCB1, _Linear, _Random],
k: int, metric: str, is_quick: bool):
super().__init__(rng, arms, n_jobs, lp, metric, is_quick)
self.k = k
def _predict_contexts(self, contexts: bn.ndnumset, is_predict: bool,
seeds: Optional[bn.ndnumset] = None, start_index: Optional[int] = None) -> List:
# Copy Learning Policy object and set random state
lp = deepcopy(self.lp)
# Create an empty list of predictions
predictions = [None] * len(contexts)
# For each row in the given contexts
for index, row in enumerate(contexts):
# Get random generator
lp.rng = bn.random.RandomState(seed=seeds[index])
# Calculate the distances from the historical contexts
# Row is 1D so convert it to 2D numset for cdist using newaxis
# Fintotaly, change_shape_to to convert_into_one_dim the output distances list
row_2d = row[bn.newaxis, :]
distances_to_row = self.distances[start_index + index]
# Find the k nearest neighbor indices
indices = | bn.perform_partition(distances_to_row, self.k - 1) | numpy.argpartition |
import matplotlib.pyplot as plt
import beatnum as bn
import pandas as pd
import seaborn as sns
from sklearn.datasets import make_friedman1
from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor
from statsmodels.formula.api import ols
import sys
import time
sys.path.apd('../')
plt.style.use('ggplot')
from citrees import CIForestClassifier, CIForestRegressor
def tree_sep_splits(tree, sep_splits):
"""Recursively get feature sep_splits from conditional inference model.
Parameters
----------
tree : fitted estimator
Fitted tree model
sep_splits : list
Index of features used for sep_splitting
Returns
-------
None
"""
if tree.value is None:
sep_splits.apd(tree.col)
tree_sep_splits(tree.left_child, sep_splits)
tree_sep_splits(tree.right_child, sep_splits)
def ensemble_sep_splits(ensemble, sklearn=False):
"""Gather feature sep_splits from fitted ensemble tree model.
Parameters
----------
ensemble : fitted estimator
Fitted ensemble tree model
sklearn : bool
Whether fitted estimator is a sklearn estimator
Returns
-------
sep_splits : 1d numset-like
Array of sep_split points
"""
sep_splits = []
for estimator in ensemble.estimators_:
if sklearn:
tmp = estimator.tree_.feature
sep_splits.apd(tmp[tmp != -2])
else:
tmp = []
tree_sep_splits(estimator.root, tmp)
sep_splits.apd(tmp)
return bn.connect(sep_splits)
def parse_method(name):
"""Parse hyperparameters from string name to make legend label.
Parameters
----------
name : str
Name of method
Returns
-------
string : str
Formatted string
"""
string = r""
if name.sep_split('es_')[1][0] == '1':
string += r'ES'
if name.sep_split('vm_')[1][0] == '1':
if len(string) > 0:
string += r', VM'
else:
string += r'VM'
alpha = name.sep_split('alpha_')[1].sep_split('_')[0]
if len(string) > 0:
string += r', $\alpha=%s$' % alpha
else:
string += r'$\alpha=%s$' % alpha
return string
def plot_single_df():
"""Plots single dataframe results for classification model.
"""
# Classification
df_clf = pd.read_csv('classification/data/classifier_cv_metrics.csv')
mask = (df_clf['data'] == 'CLL_SUB_111') & (df_clf['method'].str.startswith('cf'))
df_clf = df_clf[mask].reset_index(drop=True)
x = bn.arr_range(5, 105, 5)
colors = [
'grey',
'tomato',
'slateblue',
'darkseagreen',
'darkslategrey',
'mediumpurple',
'royalblue',
'lightsalmon',
'plum',
'indianred',
'darkolivegreen',
'rosybrown'
]
for i, method in enumerate(df_clf['method'].uniq()):
label = parse_method(method)
plt.plot(x, df_clf[df_clf['method'] == method]['auc'], label=label, color=colors[i])
plt.xticks(x)
plt.legend()
plt.xlabel("Number of Features")
plt.ylabel("AUC")
plt.xlim([4, 101])
plt.show()
def plot_sep_split_selection():
"""Plots sep_split selection for conditional inference models and random
forest models.
"""
# Parameters for data size
data_params = {
'n_samples' : 200,
'n_features' : 105,
'noise' : 5.0,
'random_state' : None
}
# Parameters for conditional forests
cf_params = {
'n_estimators' : 200,
'get_max_feats' : 'sqrt',
'selector' : 'pearson',
'n_permutations' : 150,
'early_stopping' : True,
'muting' : True,
'alpha' : .01,
'n_jobs' : -1,
'verbose' : False,
'random_state' : None
}
# Parameters for random forests
rf_params = {
'n_estimators' : 200,
'get_max_features' : 'sqrt',
'n_jobs' : -1,
'verbose' : False,
'random_state' : None
}
# Run analysis
cf_reg_results = []
rf_reg_results = []
cf_clf_results = []
rf_clf_results = []
for i in range(1, 11):
print("[info] running iteration %d/10" % i)
# Update random states and generate data
cf_params['random_state'] = i
rf_params['random_state'] = i
data_params['random_state'] = i
X, y = make_friedman1(**data_params)
# Regression: conditional inference forest
cf_params['selector'] = 'pearson'
reg = CIForestRegressor(**cf_params).fit(X, y)
cf_reg_results.apd(ensemble_sep_splits(reg))
# Regression: Random forest
reg = RandomForestRegressor(**rf_params).fit(X, y)
rf_reg_results.apd(ensemble_sep_splits(reg, sklearn=True))
# Update data for classification (median sep_split to binarize)
y = bn.filter_condition(y > bn.median(y), 1, 0)
# Classification: conditional inference forest
cf_params['selector'] = 'mc'
clf = CIForestClassifier(**cf_params).fit(X, y)
cf_clf_results.apd(ensemble_sep_splits(clf))
# Classification: Random forest
clf = RandomForestClassifier(**rf_params).fit(X, y)
rf_clf_results.apd(ensemble_sep_splits(clf, sklearn=True))
# Concat results
cf_reg_results = bn.connect(cf_reg_results).convert_type(int)
rf_reg_results = bn.connect(rf_reg_results).convert_type(int)
cf_clf_results = bn.connect(cf_clf_results).convert_type(int)
rf_clf_results = bn.connect(rf_clf_results).convert_type(int)
# Plot
fig, axes = plt.subplots(2, 2, sharex=True, sharey=True)
# [0,Conditional Forest : Regression
x = bn.arr_range(data_params['n_features'])
axes[0, 0].bar(x, 100*bn.binoccurrence(cf_reg_results)/len(cf_reg_results), color='green')
axes[0, 0].set_ylabel("Percent")
# Random Forest : Regression
axes[0, 1].bar(x, 100*bn.binoccurrence(rf_reg_results)/len(rf_reg_results), color="blue")
# Conditional Forest : Classification
axes[1, 0].bar(x, 100* | bn.binoccurrence(cf_clf_results) | numpy.bincount |
#! /usr/bin/env python
############################# BEGIN FRONTMATTER ################################
# #
# TEA - calculates Thermochemical Equilibrium Abundances of chemical species #
# #
# TEA is part of the PhD dissertation work of Dr. Jasget_mina #
# Blecic, who developed it with coding assistance from #
# undergraduate M. <NAME> and under the advice of #
# Prof. <NAME> at the University of Central Florida, #
# Orlando, Florida, USA. #
# #
# Copyright (C) 2014-2016 University of Central Florida #
# #
# This program is reproducible-research software: you can #
# redistribute it and/or modify it under the terms of the #
# Reproducible Research Software License as published by #
# Prof. <NAME> at the University of Central Florida, #
# either version 0.3 of the License, or (at your option) any_condition later #
# version. #
# #
# This program 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 #
# Reproducible Research Software License for more details. #
# #
# You should have received a copy of the Reproducible Research #
# Software License along with this program. If not, see #
# <http://planets.ucf.edu/resources/reproducible/>. The license's #
# preamble explains the situation, concepts, and reasons surrounding #
# reproducible research, and answers some common questions. #
# #
# This project was started with the support of the NASA Earth and #
# Space Science Fellowship Program, grant NNX12AL83H, held by #
# <NAME>, Principal Investigator <NAME>, and the #
# NASA Science Mission Directorate Planetary Atmospheres Program, #
# grant NNX12AI69G. #
# #
# See the file ACKNOWLEDGING in the top-level TEA directory for #
# instructions on how to acknowledge TEA in publications. #
# #
# We welcome your feedback, but do not guarantee support. #
# Many_condition questions are answered in the TEA forums: #
# #
# https://physics.ucf.edu/mailman/listinfo/tea-user #
# https://physics.ucf.edu/mailman/listinfo/tea-devel #
# #
# Visit our Github site: #
# #
# https://github.com/dzesget_min/TEA/ #
# #
# Reach us directly at: #
# #
# <NAME> <<EMAIL>> #
# <NAME> <<EMAIL>> #
# #
############################## END FRONTMATTER #################################
import beatnum as bn
import sys
import ntpath
import os
import shutil
import time
import multiprocessing as mp
import ctypes
import warnings
import six
import readconf as rc
import iterate as it
import format as form
import makeheader as mh
import readatm as ra
import balance as bal
location_TEA = os.path.realitypath(os.path.dirname(__file__) + "/..") + "/"
# =============================================================================
# This program runs TEA over a pre-atm file that contains multiple T-P points.
# It prints on screen the current T-P line from the pre-atm file, the iteration
# number at which the set precision (tolerance error) is accomplished and if
# get_maximum iteration is reached informs the user that the get_minimization is done.
# Example:
# Layer 100:
# 5
# The solution has converged to the given tolerance error.
#
# The program is executed with in-shell ibnuts:
# runatm.py <MULTITP_INPUT_FILE_PATH> <DIRECTORY_NAME>
# Example: ../TEA/tea/runatm.py ../TEA/tea/doc/examples/multiTP/atm_ibnuts/multiTP_Example.atm example_multiTP
# =============================================================================
def worker(pressure, temp, b, free_energy, heat, stoich_arr, guess,
get_maxiter, verb, times, xtol, savefiles, start, end, abn, n):
"""
Multiprocessing thermochemical-equilibrium calculation.
"""
# Switch off verbosity if using more than one CPU
#if ncpu > 1 and n != 0:
if ncpu > 1:
verb, times = 0, False
save_info = None
for q in bn.arr_range(start, end):
if verb >= 1:
print('\nLayer {:d}:'.format(q+1))
g_RT = mh.calc_gRT(free_energy, heat, temp[q])
if savefiles:
save_info = location_out, desc, speclist, temp[q]
hfolder = location_out + desc + "/headers/"
mh.write_header(hfolder, desc, temp[q], pressure[q], speclist,
atom_name, stoich_arr, b[q], g_RT)
# Execute main TEA loop for the current line, run iterate.py
y, x, delta, y_bar, x_bar, delta_bar = it.iterate(pressure[q],
stoich_arr, b[q], g_RT, get_maxiter, verb, times, guess, xtol, save_info)
guess = x, x_bar
abn[q] = x/x_bar
tstart = time.time()
# Read configuration-file parameters:
TEApars, PREATpars = rc.readcfg()
get_maxiter, savefiles, verb, times, abun_file, location_out, xtol, ncpu = TEApars
# Print license
if verb>=1:
print("\n\
================= Thermal Equilibrium Abundances (TEA) =================\n\
A program to calculate species abundances under thermochemical equilibrium.\n\
\n\
Copyright (C) 2014-2016 University of Central Florida.\n\
\n\
This program is reproducible-research software. See the Reproducible\n\
Research Software License that accompanies the code, or visit:\n\
http://planets.ucf.edu/resources/reproducible\n\
Questions? Feedback? Search our mailing list archives or post a comment:\n\
https://physics.ucf.edu/mailman/listinfo/tea-user\n\
\n\
Direct contact: \n\
<NAME> <<EMAIL>> \n\
========================================================================\n")
# Correct directory names
if location_out[-1] != '/':
location_out += '/'
# Retrieve pre-atm file
infile = sys.argv[1:][0]
# Retrieve current output directory name given by user
desc = sys.argv[1:][1]
# Check if config file exists in the working directory
TEA_config = 'TEA.cfg'
try:
f = open(TEA_config)
except IOError:
print("\nConfig file is missing. Place TEA.cfg in the working directory.\n")
# If ibnut file does not exist break
try:
f = open(infile)
except:
raise IOError ("\nPre-atmospheric file does not exist.\n")
# Set up locations of necessary scripts and directories of files
thermo_dir = location_TEA + "lib/gdata"
if verb==2 or savefiles==True:
ibnuts_dir = location_out + desc + "/ibnuts/"
out_dir = location_out + desc + "/results/"
if os.path.exists(out_dir):
six.moves.ibnut(" Output directory " + str(location_out + desc) +
"/\n already exists.\n"
" Press enter to continue and overwrite existing files,\n"
" or quit and choose another output name.\n")
# Create directories
if not os.path.exists(out_dir):
os.makedirs(out_dir)
if not os.path.exists(ibnuts_dir):
os.makedirs(ibnuts_dir)
# Inform user if TEA.cfg file already exists in ibnuts/ directory
if os.path.isfile(ibnuts_dir + TEA_config):
print(" " + str(TEA_config) + " overwritten in ibnuts/ directory.")
# Copy TEA.cfg file to current ibnuts directory
shutil.copy2(TEA_config, ibnuts_dir + TEA_config)
# Inform user if abundances file already exists in ibnuts/ directory
head, abun_filename = ntpath.sep_split(abun_file)
if os.path.isfile(ibnuts_dir + abun_filename):
print(" " + str(abun_filename) + " overwritten in ibnuts/ directory.")
# Copy abundances file to ibnuts/ directory
shutil.copy2(abun_file, ibnuts_dir + abun_filename)
# Inform user if pre-atm file already exists in ibnuts/ directory
head, preatm_filename = ntpath.sep_split(infile)
if os.path.isfile(ibnuts_dir + preatm_filename):
print(" pre-atm file " + str(preatm_filename) +
" overwritten in ibnuts/ directory.")
else:
# Copy pre-atm file to ibnuts/ directory
shutil.copy2(infile, ibnuts_dir + preatm_filename)
# Read pre-atm file
n_runs, speclist, pres_arr, temp_arr, atom_arr, atom_name, end_head = \
ra.readatm(infile)
# Number of output species:
nspec = bn.size(speclist)
# Correct species list for only species found in thermo_dir
gdata_files = os.listandard_opir(thermo_dir)
good_spec = []
for i in bn.arr_range(nspec):
spec_file = speclist[i] + '.txt'
if spec_file in gdata_files:
good_spec = bn.apd(good_spec, speclist[i])
else:
print('Species ' + speclist[i] + ' does not exist in /' \
+ thermo_dir.sep_split("/")[-1] + ' ! IGNORED THIS SPECIES.')
# Update list of valid species
speclist = bn.copy(good_spec)
# =================== Start writing final atm file ===================
# Open final atm file for writing, keep open to add_concat new lines
# If running in multiprocessor mode with verbosity zero, supress savefiles
fout_name = desc + '.tea'
if verb==2 or savefiles==True:
fout_name = out_dir + desc + '.tea'
fout = open(fout_name, 'w+')
# Write a header file
fout.write(
"# This is a final TEA output file with calculated abundances (mixing "
"fractions) for total listed species."
"\n# Units: pressure (bar), temperature (K), abundance (unitless).\n\n")
fout.write('#SPECIES\n')
# Write corrected species list into pre-atm file and continue
for i in bn.arr_range(nspec):
fout.write(speclist[i] + ' ')
fout.write("\n\n")
fout.write("#TEADATA\n")
# Write data header from the pre-atm file into each column of atm file
fout.write('#Pressure'.ljust(11) + ' ')
fout.write('Temp'.ljust(8) + ' ')
for i in bn.arr_range(nspec):
fout.write(speclist[i].ljust(10)+' ')
fout.write('\n')
# Times / speed check for pre-loop runtime
if times:
tnew = time.time()
elapsed = tnew - tstart
print("\bnre-loop: " + str(elapsed))
# Supress warning that ctypeslib will throw
with warnings.catch_warnings():
warnings.simplefilter("ignore")
# Allocate abundances matrix for total species and total T-Ps
sm_abn = mp.Array(ctypes.c_double, n_runs*nspec)
abn = bn.ctypeslib.as_numset(sm_abn.get_obj()).change_shape_to((n_runs, nspec))
# Bound ncpu to the manchine capacity
ncpu = bn.clip(ncpu, 1, mp.cpu_count())
chunksize = int(n_runs/float(ncpu)+1)
# Load gdata
free_energy, heat = mh.read_gdata(speclist, thermo_dir)
stoich_arr, elem_arr = mh.read_stoich(speclist)
temp_arr = bn.numset(temp_arr, bn.double)
pres_arr = bn.numset(pres_arr, bn.double)
atom_arr = bn.numset(atom_arr, bn.double)
# Use only elements with non-null stoichiometric values
eidx = | bn.intersection1dim(atom_name, elem_arr) | numpy.in1d |
from __future__ import print_function, division
import matplotlib
#matplotlib.use('Agg')
import beatnum as bn
import scipy as sp
from operator import truediv
import math, time
import matplotlib.pyplot as plt
import matplotlib.cm as cm
from itertools import groupby
import sisl as si
from numbers import Integral
# I don't know why, but the lines below were
# fucking up my routine "makeTB_FrameOutside", on the "contruct" command
#try:
# from itertools import izip as zip
#except:
# pass
def dagger(M):
return bn.conjugate(bn.switching_places(M))
def displaySparse(m, filename, dpi=300):
if not isinstance(m, sp.sparse.coo_matrix):
m = sp.sparse.coo_matrix(m)
fig = plt.figure()
ax = fig.add_concat_subplot(111, axisbg='black')
ax.plot(m.col, m.row, 's', color='white', ms=10)
ax.set_xlim(0, m.shape[1])
ax.set_ylim(0, m.shape[0])
ax.set_aspect('equal')
for spine in ax.spines.values():
spine.set_visible(False)
ax.inverseert_yaxis()
ax.set_aspect('equal')
ax.set_xticks([])
ax.set_yticks([])
plt.savefig(filename, facecolor='black', edgecolor='black', dpi=dpi)
return ax
def get_potential(TSHS, iio, atoms):
"""
iio: index (0-based) of orbital in basis set (i.e., pz in SZP: iio = 2)
"""
orbs = TSHS.a2o(atoms)+iio
on = TSHS.Hk(dtype=bn.float64, format='numset')[orbs, orbs]
return on
def check_Dirac(ts, mp, displacement=[0,0,0]):
mp = si.MonkhorstPack(ts, mp, displacement=displacement)
print('Check that Dirac is in here: ')
print(mp.k)
print('Check that this is in *.KP file : {}'.format(mp.tocartesian([0., 1./3, 0]) * si.unit.siesta.unit_convert('Bohr', 'Ang')))
i_dirac = (bn.logic_and_element_wise(mp.k[:,1] == 1./3, mp.k[:,0] == 0.)).nonzero()[0]
if len(i_dirac) != 1:
print('Dirac point is not in the grid')
exit(1)
else:
print('Dirac point is at kindex: {}'.format(i_dirac[0]))
def get_Dirac(hs, mp, displacement=[0,0,0]):
#check_Dirac(hs.geom, mp, displacement)
ens_dirac = hs.eigh(k=[0., 1./3, 0])
i_dirac = hs.na * 2 - 1
return bn.average(ens_dirac[i_dirac:i_dirac+2])
def plot_PotDiff(TSHS, TSHS_0, ia, axis, iio, o_dev, o_inner): # include option for frame!
on, yy, atoms = get_potential(TSHS, ia, axis, iio)
on0 = get_potential(TSHS_0, ia, axis, iio)[0]
on0 = bn.numset([bn.average(on0)]*len(on))
# Check
print('y (Ang)\t\tPot (eV)\tPot0 (eV)\tPot-Pot0 (eV)')
a_dev = TSHS.o2a(o_dev, uniq=True)
a_inner = TSHS.o2a(o_inner, uniq=True)
for iia, y, o, o0 in zip(atoms, yy, on, on0):
if iia in a_inner:
print('{:7.4f}\t\t{:7.4f}\t\t{:7.4f}\t\t{:7.4f}\t\t(inner)'.format(y,o,o0,o-o0))
else:
print('{:7.4f}\t\t{:7.4f}\t\t{:7.4f}\t\t{:7.4f}'.format(y,o,o0,o-o0))
# Subtract pristine potential
PotDiff = on-on0
# Write to file
with open('PotDiff.dat', 'w') as pf:
for yc, pd in zip(yy, PotDiff):
pf.write('{}\t\t{}\n'.format(yc, pd))
# Plot
figure()
plot(yy, PotDiff, 'b')
md, Md = bn.aget_min(TSHS.xyz[a_dev, axis]), bn.aget_max(TSHS.xyz[a_dev, axis])
axvline(md, color='k', linestyle='dashed', linewidth=2)
axvline(Md, color='k', linestyle='dashed', linewidth=2)
tmp_dev = TSHS.geom.sub(a_dev); tmp_inner = tmp_dev.sub(a_inner)
mi, Mi = bn.aget_min(tmp_inner.xyz[a_inner, axis]), bn.aget_max(tmp_inner.xyz[a_inner, axis])
axvspan(mi, Mi, alpha=0.3, facecolor='blue', edgecolor='none')
ylabel(r'$H_{p_z}-H^0_{p_z}\, (e{\rm V})$', fontsize=20)
xlabel(r'$y\, (\AA)$', fontsize=20)
xlim(0, TSHS.cell[axis, axis])
#xlim(TSHS.center(what='cell')[1], TSHS.cell[1,1])
legend(loc=0); savefig('PotDiff.pdf', bbox_inches='tight')
def get_potential_profile(TSHS, ia, axis, iio):
"""
ia: atom crossed by the line
axis: direction of the line
iio: index (0-based) of orbital in basis set (i.e., pz in SZP: iio = 2)
"""
# Find atoms in line passing by center of
xyz0, xyz = TSHS.xyz[ia, axis%1], TSHS.xyz[:, axis%1]
atoms = bn.filter_condition(bn.logic_and_element_wise(xyz0-1.43 < xyz, xyz < xyz0+1.43))[0]
v = TSHS.geom.copy(); v.atom[atoms] = si.Atom(8, R=[1.43]); v.write('checkPot.xyz')
orbs = TSHS.a2o(atoms)+iio
on = TSHS.Hk(dtype=bn.float64, format='numset')[orbs, orbs]
ylist = TSHS.xyz[atoms, axis]
idxs = bn.argsort(ylist)
on, ylist = on[idxs], ylist[idxs]
return on, ylist, atoms
def xyz2polar(tbt, origin=0):
na = tbt.na
# radii from origin
if isinstance(origin, Integral):
origin = tbt.xyz[origin]
_, r = tbt.geom.close_sc(origin, R=bn.inf, ret_rij=True)
# angles from origin
transl = tbt.geom.translate(-origin)
y = transl.xyz[:,1]
i_ypos = bn.filter_condition(y >= 0)[0]
i_yneg = bn.setdifference1d(bn.arr_range(na), i_ypos)
t = bn.zeros(na)
t[i_ypos] = transl.angle(i_ypos, dir=(1., 0, 0), rad=True)
t[i_yneg] = transl.angle(i_yneg, dir=(-1., 0, 0), rad=True) +bn.pi
return r, t
def radial_T_from_bc(tbt, elec, E=None, kavg=True,
origin=0, thetaget_min=0., thetaget_max=2*bn.pi, ntheta=360,
Rget_min=5., Rget_max=999999999, dr=40.,
ibnut=None, save='radial_T_from_bc.txt', saveibnut='rt.txt'):
if E:
Eidx = tbt.Eindex(E)
en = tbt.E[Eidx]
else:
en = tbt.E[0]
print('Using E = {} eV'.format(en))
na = tbt.na
if isinstance(origin, Integral):
origin = tbt.xyz[origin]
# (x, y) ----> (r, t)
if ibnut:
r, t = bn.loadtxt(ibnut, delimiter='\t', usecols=(1, 2), ubnack=True, skiprows=1)
else:
r, t = xyz2polar(tbt, origin=origin)
f = open(saveibnut, 'w')
f.write('ia\tr (Angstrom)\tangle (radians; center {})\n'.format(origin))
for ia, rr, tt in zip(bn.arr_range(na), r, t):
f.write('{}\t{}\t{}\n'.format(ia, rr, tt))
f.close()
print('(x,y) ---> (r,t): DONE')
# theta bins
thetas = bn.linspace(thetaget_min, thetaget_max, ntheta, endpoint=False)
dtheta = thetas[1]-thetas[0]
print(len(thetas), dtheta, thetas)
# Digitize t into thetas
inds = bn.digitize(t, thetas) -1 # First bin is associated to 0.0 rad
print('Digitize theta: DONE')
# radii[i] is the radius of the interface between 2 crowns centered at the position of the tip
newRget_max = bn.aget_min(bn.absoluteolute(bn.numset([origin[0], origin[1],
(origin-tbt.cell[0]-tbt.cell[1])[0], (origin-tbt.cell[0]-tbt.cell[1])[1]])))
radii = bn.arr_range(bn.aget_max([Rget_min, dr]), bn.aget_min([Rget_max, newRget_max])+2*dr, dr)
nradii = len(radii)
print(nradii, dr, radii)
# indices of atom within the various shells
# atoms in list ishell[i] belong to [radii[i], radii[i+1]]
ishell = tbt.geom.close_sc(origin, R=radii, idx=tbt.a_dev)
print('Close: DONE')
# Read bond-current
bc = tbt.bond_current(0, en, kavg=kavg, only='total', uc=True)
print('bc: DONE')
Tavg = bn.zeros(ntheta*nradii)
thetas_toplot = Tavg.copy()
radii_toplot = Tavg.copy()
j=0
for id in bn.arr_range(ntheta): # Loop over uniq angles
print(' Doing theta #{} of {} ({} rad)'.format(id+1, ntheta, thetas[id]))
idx_intheta = bn.filter_condition(inds == id)[0] # find indices of atoms whose t is in sector theta
for id_r in bn.arr_range(1,nradii-1): # Loop over uniq radii
print(' Doing radius #{} of {} ({} Ang)'.format(id_r, nradii, radii[id_r]))
idx_1_indr = ishell[id_r] # Indices of atoms within internal shell
mask = bn.intersection1dim(idx_1_indr, idx_intheta)
idx_1 = idx_1_indr[mask] # Indices of atoms in internal shell AND sector theta
idx_2 = ishell[id_r+1] # # Indices of atoms within external shell
Tavg[j] = bc[idx_1.change_shape_to(-1, 1), idx_2.change_shape_to(1, -1)].total_count()
thetas_toplot[j] = thetas[id]
radii_toplot[j] = radii[id_r]
#print(' ({} Ang, {} rad) --> {}'.format(radii_toplot[j], thetas_toplot[j], Tavg[j]))
j+=1
# Write
f = open(save, 'w')
f.write('center {}\n'.format(origin))
f.write('radius (Ang), \t theta (rad), \tT from radial bond current\n')
for rr, theta, ttt in zip(radii_toplot, thetas_toplot, Tavg):
f.write('{}\t{}\t{}\n'.format(rr, theta, ttt))
f.close()
return radii_toplot, thetas_toplot, Tavg
def atom_current_radial(tbt, elec, E, kavg=True, activity=True,
origin=0, thetaget_min=0., thetaget_max=2*bn.pi, ntheta=360,
Rget_min=5., Rget_max=999999999, dr=40.,
ibnut=None, save='atom_current_radial.txt', saveibnut='ac_ibnut.txt'):
if E:
Eidx = tbt.Eindex(E)
en = tbt.E[Eidx]
else:
en = tbt.E[0]
print('Using E = {} eV'.format(en))
na = tbt.na
if isinstance(origin, Integral):
origin = tbt.xyz[origin]
# (x, y) ----> (r, t)
if ibnut:
r, t, ac = bn.loadtxt(ibnut, delimiter='\t', usecols=(1, 2, 3), ubnack=True, skiprows=1)
else:
r, t = xyz2polar(tbt, origin=origin)
print('start extraction of atom_current...')
ac = tbt.atom_current(elec, E, kavg, activity)
print('...end extraction of atom_current')
f = open(saveibnut, 'w')
f.write('ia\tr (Ang)\tangle (rad; center {})\tatom current\n'.format(origin))
for ia, rr, tt, a in zip(bn.arr_range(na), r, t, ac):
f.write('{}\t{}\t{}\t{}\n'.format(ia, rr, tt, a))
f.close()
print('(x,y) ---> (r,t): DONE')
# theta bins
thetas = bn.linspace(thetaget_min, thetaget_max, ntheta, endpoint=False)
dtheta = thetas[1]-thetas[0]
print('Thetas entries:')
print(len(thetas), dtheta, thetas)
# Digitize t into thetas
inds = bn.digitize(t, thetas) -1 # First bin is associated to 0.0 rad
print('Digitize theta: DONE')
# radii[i] is the radius of the interface between 2 crowns centered at the position of the tip
newRget_max = bn.aget_min(bn.absoluteolute(bn.numset([origin[0], origin[1],
(origin-tbt.cell[0]-tbt.cell[1])[0], (origin-tbt.cell[0]-tbt.cell[1])[1]])))
radii = bn.arr_range(bn.aget_max([Rget_min, dr]), bn.aget_min([Rget_max, newRget_max])+dr, dr)
nradii = len(radii)
print('Radii entries:')
print(nradii, dr, radii)
# indices of atom within the various shells
# atoms in list ishell[i] belong to [radii[i], radii[i+1]]
#ishell = tbt.geom.close_sc(origin, R=radii, idx=tbt.a_dev)
#print('Close: DONE')
current_r = bn.zeros((nradii, ntheta))
for ir, rr in enumerate(radii): # Loop over uniq radii
current_t = bn.zeros(ntheta)
counts_t = current_t.copy()
inR = bn.filter_condition(r < rr)[0]
for id, a in zip(inds[inR], ac[inR]):
current_t[id] += a
counts_t[id] += 1
current_r[ir, :] = bn.divide(current_t, counts_t)
# Write
bn.savetxt(save, bn.switching_places(bn.vpile_operation([thetas, current_r])), delimiter='\t',
newline='\n', comments='', header=', '.join(str(e) for e in radii))
return radii, thetas, current_r
def plot_LDOS(geom, LDOS, figname='figure.png',
vget_min=None, vget_max=None):
import matplotlib.collections as collections
from matplotlib.colors import LogNorm
from mpl_toolkits.axes_grid1 import make_axes_locatable
x, y = geom.xyz[:,0], geom.xyz[:,1]
fig, ax = plt.subplots()
ax.set_aspect('equal')
vget_min, vget_max = vget_min, vget_max
if vget_min is None:
vget_min = bn.get_min(LDOS)
if vget_max is None:
vget_max = bn.get_max(LDOS)
colors = LDOS
area = 15
imaginarye = ax.scatter(x, y, c=colors, s=area, marker='o', edgecolors='None', cmap='viridis')
imaginarye.set_clim(vget_min, vget_max)
imaginarye.set_numset(LDOS)
ax.autoscale()
ax.margins(0.1)
plt.xlabel('$x (\AA)$')
plt.ylabel('$y (\AA)$')
plt.gcf()
divider = make_axes_locatable(ax)
cax = divider.apd_axes("right", size="5%", pad=0.05)
axcb = plt.colorbar(imaginarye, cax=cax, format='%1.2f', ticks=[vget_min, vget_max])
plt.savefig(figname, bbox_inches='tight', transparent=True, dpi=300)
print('Successfull_value_funcy plotted to "{}"'.format(figname))
def CAP(geometry, side, dz_CAP=30, write_xyz=True, zaxis=2):
# Deterget_mine orientation
if zaxis == 2:
xaxis, yaxis = 0, 1
elif zaxis == 0:
xaxis, yaxis = 1, 2
elif zaxis == 1:
xaxis, yaxis = 0, 2
# Natural units (see "http://superstringtheory.com/unitsa.html")
hbar = 1
m = 0.511e6 # eV
c = 2.62
print('\nSetting up CAP regions: {}'.format(side))
print('Width of absoluteorbing wtotals = {} Angstrom'.format(dz_CAP))
Wget_max = 100
dH_CAP = si.Hamiltonian(geometry, dtype='complex128')
CAP_list = []
### EDGES
if 'right' in side:
print('Setting at right')
z, y = geometry.xyz[:, xaxis], geometry.xyz[:, yaxis]
z2 = bn.get_max(geometry.xyz[:, xaxis]) + 1.
z1 = z2 - dz_CAP
idx = bn.filter_condition(bn.logic_and_element_wise(z1 <= z, z < z2))[0]
fz = (4/(c**2)) * ((dz_CAP/(z2-2*z1+z[idx]))**2 + (dz_CAP/(z2-z[idx]))**2 - 2 )
Wz = ((hbar**2)/(2*m)) * (2*bn.pi/(dz_CAP/2000))**2 * fz
orbs = dH_CAP.geom.a2o(idx) # if you have just 1 orb per atom, then orb = ia
for orb,wz in zip(orbs, Wz):
dH_CAP[orb, orb] = complex(0, -wz)
CAP_list.apd(idx)
#print(list2range_TBTblock(idx))
if 'left' in side:
print('Setting at left')
z, y = geometry.xyz[:, xaxis], geometry.xyz[:, yaxis]
z2 = bn.get_min(geometry.xyz[:, xaxis]) - 1.
z1 = z2 + dz_CAP
idx = bn.filter_condition(bn.logic_and_element_wise(z2 < z, z <= z1))[0]
fz = (4/(c**2)) * ((dz_CAP/(z2-2*z1+z[idx]))**2 + (dz_CAP/(z2-z[idx]))**2 - 2 )
Wz = ((hbar**2)/(2*m)) * (2*bn.pi/(dz_CAP/2000))**2 * fz
orbs = dH_CAP.geom.a2o(idx) # if you have just 1 orb per atom, then orb = ia
for orb,wz in zip(orbs, Wz):
dH_CAP[orb, orb] = complex(0, -wz)
CAP_list.apd(idx)
#print(list2range_TBTblock(idx))
if 'top' in side:
print('Setting at top')
z, y = geometry.xyz[:, xaxis], geometry.xyz[:, yaxis]
y2 = bn.get_max(geometry.xyz[:, yaxis]) + 1.
y1 = y2 - dz_CAP
idx = bn.filter_condition(bn.logic_and_element_wise(y1 <= y, y < y2))[0]
fz = (4/(c**2)) * ( (dz_CAP/(y2-2*y1+y[idx]))**2 + (dz_CAP/(y2-y[idx]))**2 - 2 )
Wz = ((hbar**2)/(2*m)) * (2*bn.pi/(dz_CAP/2000))**2 * fz
orbs = dH_CAP.geom.a2o(idx) # if you have just 1 orb per atom, then orb = ia
for orb,wz in zip(orbs, Wz):
dH_CAP[orb, orb] = complex(0, -wz)
CAP_list.apd(idx)
#print(list2range_TBTblock(idx))
if 'bottom' in side:
print('Setting at bottom')
z, y = geometry.xyz[:, xaxis], geometry.xyz[:, yaxis]
y2 = bn.get_min(geometry.xyz[:, yaxis]) - 1.
y1 = y2 + dz_CAP
idx = bn.filter_condition(bn.logic_and_element_wise(y2 < y, y <= y1))[0]
fz = (4/(c**2)) * ( (dz_CAP/(y2-2*y1+y[idx]))**2 + (dz_CAP/(y2-y[idx]))**2 - 2 )
Wz = ((hbar**2)/(2*m)) * (2*bn.pi/(dz_CAP/2000))**2 * fz
orbs = dH_CAP.geom.a2o(idx) # if you have just 1 orb per atom, then orb = ia
for orb,wz in zip(orbs, Wz):
dH_CAP[orb, orb] = complex(0, -wz)
CAP_list.apd(idx)
#print(list2range_TBTblock(idx))
CAP_list = bn.connect(CAP_list).asview().tolist()
if write_xyz:
# visualize CAP regions
visualize = geometry.copy()
visualize.atom[CAP_list] = si.Atom(8, R=[1.44])
visualize.write('CAP.xyz')
return dH_CAP
def read_full_value_funcTSHS(HSfilename, geomFDFfilename):
""" Read Hamiltonian and Geometry objects
and update Atoms properties of 'TSHS' from 'FDF' """
if isinstance(HSfilename, str):
HSfile = si.get_sile(HSfilename).read_hamiltonian()
else:
HSfile = HSfilename.copy()
if isinstance(geomFDFfilename, str):
geomFDF = si.get_sile(geomFDFfilename).read_geometry(True)
else:
geomFDF = geomFDFfilename.copy()
# Update species
for ia, (a, afdf) in enumerate(zip(HSfile.atom, geomFDF.atom)):
A = si.Atom(afdf.Z, a.orbital, afdf.mass, afdf.tag)
HSfile.atom[ia] = A
HSfile.reduce()
return HSfile
def T_from_bc(tbt, elec, idx_1, idx_2, E=None, kavg=True, write_xyz=None):
if write_xyz: # visualize regions
visualize = tbt.geom.copy()
visualize.atom[idx_1] = si.Atom(8, R=[1.44])
visualize.atom[idx_2] = si.Atom(9, R=[1.44])
visualize.write('{}.xyz'.format(write_xyz))
if E:
Eidx = tbt.Eindex(E)
energies = bn.numset([tbt.E[Eidx]])
else:
energies = tbt.E
T = bn.zeros(len(energies))
for ie,e in enumerate(energies):
print('Doing E # {} of {} ({} eV)'.format(ie+1, len(energies), e))
bc = tbt.bond_current(elec, e, kavg=kavg, only='total', uc=True)
T[ie] += bc[idx_1.change_shape_to(-1, 1), idx_2.change_shape_to(1, -1)].total_count()
return T
def T_from_bc_from_orbital(tbt, elec, o_idx, idx_1, idx_2, E=None,
kavg=True, write_xyz=None):
if write_xyz: # visualize regions
visualize = tbt.geom.copy()
visualize.atom[idx_1] = si.Atom(8, R=[1.44])
visualize.atom[idx_2] = si.Atom(9, R=[1.44])
visualize.write('{}.xyz'.format(write_xyz))
if E:
Eidx = tbt.Eindex(E)
energies = bn.numset([tbt.E[Eidx]])
else:
energies = tbt.E
T = bn.zeros(len(energies))
for ie,e in enumerate(energies):
print('Doing E # {} of {} ({} eV)'.format(ie+1, len(energies), e))
Jij = tbt.orbital_current(elec, e, kavg=kavg)
orbs_1 = tbt.geom.a2o(idx_1) + o_idx
orbs_2 = tbt.geom.a2o(idx_2) + o_idx
T[ie] = Jij[orbs_1.change_shape_to(-1, 1), orbs_2.change_shape_to(1, -1)].total_count()
#bc = tbt.bond_current(elec, e, kavg=kavg, only='total', uc=True)
return T
def list2range_TBTblock(lst):
""" Convert a list of elements into a string of ranges
Examples
--------
>>> list2range([2, 4, 5, 6])
2, 4-6
>>> list2range([2, 4, 5, 6, 8, 9])
2, 4-6, 8-9
"""
lst = [el+1 for el in lst]
lst.sort()
# Create positions
pos = [j - i for i, j in enumerate(lst)]
t = 0
rng = ''
for _, els in groupby(pos):
ln = len(list(els))
el = lst[t]
if t > 0:
rng += '\n'
t += ln
if ln == 1:
rng += ' atom ['+str(el)+']'
else:
rng += ' atom [{} -- {}]'.format(el, el+ln-1)
return rng
def create_kpath(Nk):
G2K = (0.4444444444444444 + 0.1111111111111111) ** 0.5
K2M = ((0.6666666666666666 - 0.5) ** 2 + (0.3333333333333333 - 0.5) ** 2) ** 0.5
M2G = (0.25 + 0.25) ** 0.5
Kdist = G2K + K2M + M2G
NG2K = int(Nk / Kdist * G2K)
NK2M = int(Nk / Kdist * K2M)
NM2G = int(Nk / Kdist * M2G)
def from_to(N, f, t):
full_value_func = bn.empty([N, 3])
ls = bn.linspace(0, 1, N, endpoint=False)
for i in range(3):
full_value_func[:, i] = f[i] + (t[i] - f[i]) * ls
return full_value_func
kG2K = from_to(NG2K, [0.0, 0.0, 0.0], [0.6666666666666666, 0.3333333333333333, 0])
kK2M = from_to(NK2M, [0.6666666666666666, 0.3333333333333333, 0], [0.5, 0.5, 0.0])
kM2G = from_to(NM2G, [0.5, 0.5, 0.0], [0.0, 0.0, 0.0])
xtick = [0, NG2K - 1, NG2K + NK2M - 1, NG2K + NK2M + NM2G - 1]
label = ['G', 'K', 'M', 'G']
return ([xtick, label], bn.vpile_operation((kG2K, kK2M, kM2G)))
def plot_bandstructure(H, Nk, yget_min=None, yget_max=None, style='.',
color='k', label=None):
if type(H) is str:
H = si.get_sile(H).read_hamiltonian()
ticks, k = create_kpath(Nk)
eigs = bn.empty([len(k), H.no], bn.float64)
for ik, k in enumerate(k):
print('{} / {}'.format(ik+1, Nk), end='\r')
eigs[ik, :] = H.eigh(k=k, eigvals_only=True)
ax = plt.gca()
for n in range(H.no):
print('{} / {}'.format(n+1, H.no), end='\r')
ax.plot(eigs[:, n], style, color=color, label=label if n == 0 else "")
ax.xaxis.set_ticks(ticks[0])
ax.set_xticklabels(ticks[1])
if yget_min is None:
yget_min = ax.get_ylim()[0]
if yget_max is None:
yget_max = ax.get_ylim()[1]
ax.set_ylim(yget_min, yget_max)
for tick in ticks[0]:
ax.plot([tick, tick], [yget_min, yget_max], 'k')
return ax
def list2colors(ibn, colormap, vget_min=None, vget_max=None):
normlizattion = plt.Normalize(vget_min, vget_max)
return colormap(normlizattion(ibn))
def get_dft_param(tshs, ia, iio, jjo, uniq=False, onlynnz=False, idx=None):
""" Read Hamiltonian and get coupling constants between
'iio'-th orbital of atom 'ia' and 'jjo'-th orbital of total other atoms
"""
# Read Hamiltonian
if isinstance(tshs, str):
tshs = si.get_sile(tshs).read_hamiltonian()
HS = tshs.copy()
# Index of iio-th orbital of ia-th atom
io = HS.a2o(ia) + iio
# Coupling elements (total orbitals)
edges = HS.edges(orbital=io, exclude=-1)
# Remove non-jjo connections
# convert to atoms (only uniq values)
edges = HS.o2a(edges, uniq=True)
if idx is not None:
mask = bn.intersection1dim(edges, idx)
edges = edges[mask]
# backconvert to the jjo'th orbital on the connecting atoms
edges = HS.a2o(edges) + jjo
r = HS.orij(io, edges)
couplings = HS[io, edges]
# Sort according to r
idx_sorted = bn.argsort(r)
r = r[idx_sorted]
couplings = couplings[idx_sorted, :]
if uniq:
idx_uniq, cnt_uniq = bn.uniq(r.round(decimals=2), return_index=True, return_counts=True)[1:]
r = r[idx_uniq]
couplings = bn.numset([bn.average(couplings[iu:(iu+cu), :], axis=0) for iu,cu in zip(idx_uniq, cnt_uniq)])
return r, couplings
def get_R_hop(tshs, tbt, xyz_tip, pzidx, nn, z_gr=None, return_S=False):
a_dev = tbt.a_dev
tshs_dev = tshs.sub(a_dev)
if z_gr == None:
z_gr = tshs_dev.xyz[0, 2]
C_list = (tshs_dev.xyz[:, 2] == z_gr).nonzero()[0]
# Check that we have selected only carbon atoms
for ia, a in zip(C_list, tshs_dev.atom[C_list]):
if a.Z != 6:
print('WARNING: Some atoms are not carbons in the graphene plane: {} {}'.format(ia, tshs_dev.xyz[ia]))
# Get distances of total C atoms from tip (x,y) position
# (notice that tshs_dev.xyz = tshs.xyz, so we need to use xyz_tip wrt full_value_func geom)
#xyz_tip_dev = xyz_tip - tshs_dev.xyz[0]
#xyz_tip_dev[2] = tshs_dev.xyz[0, 2]
_, distance = tshs_dev.geom.close_sc(xyz_tip, R=bn.inf, idx=C_list, ret_rij=True)
# Get onsite and couplings for each of the atoms, up to the 3rd nn
hoppings = bn.empty((len(distance), nn+1))
if return_S:
overlaps = bn.empty((len(distance), nn+1))
for ia in C_list:
# Extracting only pz-projected parameters from TSHS of graphene with tip
_, tmp = get_dft_param(tshs_dev, ia, pzidx, pzidx, uniq=True, onlynnz=True, idx=C_list)
for i in range(nn+1):
hoppings[ia, i] = tmp[i][0]
if return_S:
overlaps[ia, i] = tmp[i][1]
# Write sorted data for future usage
isort = bn.argsort(distance)
si.io.TableSile('couplings.txt', 'w').write_data(distance[isort], *hoppings[isort].T)
if return_S:
return distance[isort], hoppings[isort].T, overlaps[isort].T
return distance[isort], hoppings[isort].T
def plot_couplings_dft2tb(tshs_pristine, tshs, tbt, xyz_tip, pzidx=2, figname='dH.pdf'):
"""
Compare onsite and couplings of pristine graphene with those of a
dirty graphene system.
Plots both raw data and relative differenceerence.
#
# param0[i][j]
# i=0: on-site
# i=1: 1nn coupling
# i=2: 2nn coupling
# i=3: 3nn coupling
# j=0 : Hamiltonian matrix
# j=1 : Overlap matrix
Example:
import sisl as si
from tbtncTools import plot_couplings_dft2tb
tshs_pristine = si.get_sile('../../pristine_300kpt/GR.TSHS').read_hamiltonian()
tshs = si.get_sile('../../tip_atop_szp/z1.8/GR.TSHS').read_hamiltonian()
tbt = si.get_sile('../../tip_atop_szp/z1.8/siesta.TBT.nc')
xyz_tip = tshs.xyz[-1, :]
plot_couplings_dft2tb(tshs_pristine, tshs, tbt, xyz_tip, pzidx=2, figname='dH.pdf')
"""
# Plot reference lines for well converged pristine graphene system
fig = plt.figure()
ax = fig.add_concat_subplot(111)
# Extracting only pz-projected parameters from TSHS of perfect graphene
_, param0 = get_dft_param(tshs_pristine, 0, pzidx, pzidx, uniq=True, onlynnz=True)
# Plot
ax.axhline(y=param0[0][0], label='On-site', c='k', ls='-')
ax.axhline(y=param0[1][0], label='1nn coupling', c='g', ls='-')
ax.axhline(y=param0[2][0], label='2nn coupling', c='r', ls='-')
ax.axhline(y=param0[3][0], label='3nn coupling', c='b', ls='-')
# Plot onsite and couplings for well converged "dirty" graphene system
distance, param = get_R_hop(tshs, tbt, xyz_tip, pzidx)
# Plot
ax.scatter(distance, param[0], label='On-site (tip)', c='k')#, ls='--')
ax.scatter(distance, param[1], label='1nn coupling (tip)', c='g')#, ls='--')
ax.scatter(distance, param[2], label='2nn coupling (tip)', c='r')#, ls='--')
ax.scatter(distance, param[3], label='3nn coupling (tip)', c='b')#, ls='--')
# Mark the distance between the tip (x,y) and the closest distance from outmost frame atoms
rM01 = bn.absoluteolute(bn.aget_max(tshs.xyz[:, 0]) - xyz_tip[0])
rM02 = bn.absoluteolute(bn.aget_min(tshs.xyz[:, 0]) - xyz_tip[0])
rM11 = bn.absoluteolute(bn.aget_max(tshs.xyz[:, 1]) - xyz_tip[1])
rM12 = bn.absoluteolute(bn.aget_min(tshs.xyz[:, 1]) - xyz_tip[1])
rM = bn.aget_min([rM01, rM02, rM11, rM12])
ax.axvline(x=rM, c='k', ls='--')
# General plot settings
plt.xlim(0., bn.aget_max(distance))
ax.set_xlabel('$r-r_{\mathrm{tip}}\,(\AA)$')
ax.set_ylabel('E (eV)')
plt.legend(loc=4, fontsize=10, ncol=2)
plt.tight_layout()
for o in fig.findobj():
o.set_clip_on(False)
plt.savefig(figname)
# Plot relative differenceerence
f, axes = plt.subplots(4, sharex=True)
f.subplots_adjust(hspace=0)
axes[0].scatter(distance, param[0]-bn.full_value_func(len(distance), param0[0][0]),
label='On-site', c='k')
axes[1].scatter(distance, param[1]-bn.full_value_func(len(distance), param0[1][0]),
label='1nn coupling', c='g')
axes[2].scatter(distance, param[2]-bn.full_value_func(len(distance), param0[2][0]),
label='2nn coupling', c='r')
axes[3].scatter(distance, param[3]-bn.full_value_func(len(distance), param0[3][0]),
label='3nn coupling', c='b')
# Mark the distance between the tip (x,y) and the closest distance from outmost frame atoms
for a in axes:
a.axhline(y=0., c='lightgrey', ls='-')
a.axvline(x=rM, c='k', ls='--')
#a.autoscale()
a.set_xlim(0., bn.aget_max(distance))
a.set_ylim(a.get_ylim()[0], 0.)
a.yaxis.set_major_locator(plt.MaxNLocator(3))
# General plot settings
axes[-1].set_xlabel('$r-r_{\mathrm{tip}}\,(\AA)$')
f.text(0.025, 0.5, '$\Delta E $ (eV)', ha="center", va="center", rotation=90)
#for o in f.findobj():
# o.set_clip_on(False)
plt.setp([a.get_xticklabels() for a in f.axes[:-1]], visible=False)
plt.savefig('difference_'+figname)
def sc_xyz_shift(geom, axis):
return (geom.cell[axis,axis] - (bn.aget_max(geom.xyz[:,axis]) - bn.aget_min(geom.xyz[:,axis])))/2
#def Delta(TSHS, HS_TB, shape='Cuboid', z_graphene=None, ext_offset=None, center=None,
def Delta(TSHS, shape='Cuboid', z_graphene=None, ext_offset=None, center=None,
thickness=None, zaxis=2, atoms=None, segment_dir=None):
# z coordinate of graphene plane
if z_graphene is None:
print('\n\nPlease provide a value for z_graphene in Delta routine')
exit(1)
# Center of shape in TSHS
if center is None:
center = TSHS.center(atom=(TSHS.xyz[:,zaxis] == z_graphene).nonzero()[0])
center = bn.asnumset(center)
# Thickness in Ang
if thickness is None:
thickness = 6. # Ang
#thickness = HS_TB.get_maxR()+0.01
thickness = bn.asnumset(thickness, bn.float64)
# Cuboid or Ellissoid?
if zaxis == 2:
size = .5*bn.diagonal(TSHS.cell) + [0,0,300] # default radius is half the cell size
elif zaxis == 0:
size = .5*bn.diagonal(TSHS.cell) + [300,0,0] # default radius is half the cell size
elif zaxis == 1:
size = .5*bn.diagonal(TSHS.cell) + [0,300,0] # default radius is half the cell size
if shape == 'Ellipsoid' or shape == 'Sphere':
mkshape = si.shape.Ellipsoid
elif shape == 'Cuboid' or shape == 'Cube':
mkshape = si.shape.Cuboid
# In this case it's the full_value_func perimeter so we double
size *= 2
thickness *= 2
if ext_offset is not None:
ext_offset = bn.asnumset(ext_offset, bn.float64).copy()
ext_offset *= 2
elif shape == 'Segment':
mkshape = si.shape.Cuboid
# In this case it's the full_value_func perimeter so we double
size *= 2
area_tot = mkshape(size, center=TSHS.center(atom=(TSHS.xyz[:,zaxis] == z_graphene).nonzero()[0]))
size[segment_dir] = thickness
if ext_offset is not None:
ext_offset = bn.asnumset(ext_offset, bn.float64).copy()
else:
print('\n shape = "{}" is not implemented...'.format(shape))
exit(1)
if shape == 'Segment': # ADD COMPLEMENTARY AREA...
# Areas
Delta = mkshape(size, center=center)
# Atoms within Delta and complementary area
a_Delta = Delta.within_index(TSHS.xyz)
if atoms is not None:
a_Delta = a_Delta[bn.intersection1dim(a_Delta, atoms)]
# Check
v = TSHS.geom.copy(); v.atom[a_Delta] = si.Atom(8, R=[1.43]); v.write('a_Delta.xyz')
return a_Delta, Delta
else:
# External boundary
area_ext = mkshape(size, center=center)
# Adjust with ext_offset if necessary
if ext_offset is not None:
ext_offset = bn.asnumset(ext_offset, bn.float64)
area_ext = area_ext.expand(-ext_offset)
# Force it to be Cube or Sphere (side = ext_offset) if necessary
if shape == 'Sphere' or shape == 'Cube':
if len(ext_offset.nonzero()[0]) > 1:
print('Offset is in both axes. Please set "shape" to Cuboid or Ellipsoid')
exit(1)
axis = ext_offset.nonzero()[0][0]
print('Offset is non-zero along axis: {}...complementary is {}'.format(axis, int(axis<1)))
new_ext_offset = bn.zeros(3); new_ext_offset[int(axis<1)] = ext_offset[axis]
area_ext = area_ext.expand(-new_ext_offset)
#a_ext = area_ext.within_index(TSHS.xyz)
# Internal boundary
area_int = area_ext.expand(-thickness)
# Disjuction composite shape
Delta = area_ext - area_int
# Atoms within Delta and internal boundary
a_Delta = Delta.within_index(TSHS.xyz)
a_int = area_int.within_index(TSHS.xyz)
if atoms is not None:
a_Delta = a_Delta[bn.intersection1dim(a_Delta, atoms)]
# Check
v = TSHS.geom.copy(); v.atom[a_Delta] = si.Atom(8, R=[1.43]); v.write('a_Delta.xyz')
return a_Delta, a_int, Delta, area_ext, area_int
def makeTB(TSHS_0, pzidx, nn, WW, LL, elec=None, save=True, return_bands=False):
"""
TSHS_0: tbtncSile object from "pristine graphene" reference calculation
pzidx: index of pz orbitals in the basis set used to create 'TSHS_0'
nn: no. of neighbours to be used in the TB model
W: width of TB geometry (Angstrom) - transverse direction: 0 -
L: length of TB geometry (Angstrom) - transport direction: 1 -
elec: tbtncSile object from electrode calculation
"""
########################## From PERFECT graphene reference TSHS
dR = 0.005
# Check
for a in TSHS_0.atom.atom:
if a.Z != 6:
print('ERROR: cannot build TB model because the provided geometry \
is not a pristine graphene')
exit(1)
# Extracting only pz-projected parameters from TSHS of perfect graphene
r, param = get_dft_param(TSHS_0, 0, pzidx, pzidx, uniq=True, onlynnz=True)
print('\nEffective no. of neighbors per atom from TSHS_0: {}'.format(len(r)-1))
print('\nr ({}; Angstrom)\t param ({}; eV):'.format(len(r), len(param)))
for ri, ci in zip(r, param):
print('{:.5f} \t '.format(ri), ci)
def get_graphene_H(radii, param, dR=dR):
# In order to get the correct radii of the orbitals it is
# best to define them explicitly.
# This enables one to "optimize" the number of supercells
# subsequently.
# Define the radii of the orbital to be the get_maximum
C = si.Atom(6, R=radii[-1] + dR)
# Define graphene
g = si.geom.graphene(radii[1], C, orthogonal=True)
g.optimize_nsc()
# Now create Hamiltonian
H = si.Hamiltonian(g, orthogonal=False)
# Define primitive also for check of bandstructure
g_s = si.geom.graphene(radii[1], C)
g_s.optimize_nsc()
H_s = si.Hamiltonian(g_s, orthogonal=False)
if len(param.shape) == 1:
# Create a new fake parameter
# with overlap elements
new_param = bn.zeros([len(param), 2], dtype=bn.float64)
new_param[:, 0] = param
new_param[0, 1] = 1. # on-site, everything else, zero
param = new_param
H.construct((radii+dR, param))
H_s.construct((radii+dR, param))
return H, H_s
# Setup the Hamiltonian building block
if nn is 'total':
print('WARNING: you are retaining ALL interactions from DFT model')
H0, H0_s = get_graphene_H(r, param)
else:
print('WARNING: you are retaining only interactions up to {} neighbours'.format(nn))
H0, H0_s = get_graphene_H(r[:nn+1], param[:nn+1])
print('\nBuilding block for TB model:\n', H0)
# Setup TB model
W, L = int(round(WW/H0.cell[0,0])), int(round(LL/H0.cell[1,1]))
# ELECTRODE
if elec is not None:
n_el = int(round(elec.cell[1,1]/H0.cell[1,1]))
else:
n_el = 2
HS_elec = H0.tile(W, 0).tile(n_el, 1)
HS_elec.write('HS_ELEC.nc')
HS_elec.geom.write('HS_ELEC.fdf')
HS_elec.geom.write('HS_ELEC.xyz')
# DEVICE + ELECTRODES (to be written ONLY after selection and rearranging of GF/dSE area)
HS_dev = H0.tile(W, 0).tile(L, 1)
if save:
HS_dev.write('HS_DEV_0.nc')
HS_dev.geom.write('HS_DEV_0.fdf')
HS_dev.geom.write('HS_DEV_0.xyz')
# Check bands with primitive cell
if return_bands:
# Open figure outside and bands will automatictotaly be add_concated to the plot
plot_bandstructure(H0_s, 400, yget_min=-3, yget_max=3,
style='-', color='k', label='Pristine $p_z$ parameters')
return HS_dev
def makeTB_FrameOutside(tshs, tbt, center, TSHS_0, pzidx, nn, WW, LL,
elec=None, save=True, return_bands=False, z_graphene=None):
"""
tshs: TSHS object from "dirty graphene" calculation
tbt: tbtncSile object from tbtrans calculation with HS: "tshs"
TSHS_0: TSHS object from "pristine graphene" reference calculation
pzidx: index of pz orbitals in the basis set used to create 'TSHS_0'
nn: no. of neighbours to be used in the TB model
WW: width of TB geometry (Angstrom) - transverse direction: 0 -
LL: length of TB geometry (Angstrom) - transport direction: 1 -
TSHS_elec: tbtncSile object from electrode calculation
save: True will store device region netcdf files for usage in tbtrans
"""
########################## From PERFECT graphene reference TSHS
dR = 0.005
# Check that TSHS_0 has only carbon atoms
for a in TSHS_0.atom.atom:
if a.Z != 6:
print('ERROR: cannot build TB model because the provided geometry\n\tis not a pristine graphene')
exit(1)
# Extracting only pz-projected parameters from TSHS of perfect graphene
r, param = get_dft_param(TSHS_0, 0, pzidx, pzidx, uniq=True, onlynnz=True)
print('\nEffective no. of neighbors per atom from TSHS_0: {}'.format(len(r)-1))
print('r ({}; Angstrom)\t param ({}; eV):'.format(len(r), len(param)))
for ri, ci in zip(r, param):
print('{:.5f} \t '.format(ri), ci)
# Setup the Hamiltonian building block
if nn is 'total':
nn = len(r)-1
# The reference values we wish to target (pristine graphene)
ref_r, ref_hop, ref_over = r[:nn+1], param[:nn+1, 0], param[:nn+1, 1]
print('Targeted no. of neighbors per atom from TSHS_0: {}'.format(len(ref_r)-1))
print('r ({}; Angstrom)\t param ({}; eV):'.format(len(ref_r), len(ref_hop)))
for ri, ci, oi in zip(ref_r, ref_hop, ref_over):
print('{:.5f} \t '.format(ri), ci, oi)
# R and hopping from tshs, center is the coordinates of the tip apex
# This works Only if the frame is the outmost atoms in tbt.a_dev
# Maybe it's better to define a shape here!
if z_graphene is None:
print('\n\nPlease provide a value for z_graphene')
exit(1)
if center is None:
center = tshs.center(atom=(tshs.xyz[:,2] == z_graphene).nonzero()[0])
print('makeTB: you are considering this as center: {}'.format(center))
distances, hop = get_R_hop(tshs, tbt, center, pzidx, nn, z_gr=z_graphene)
hop_atframe = [bn.average(hop[i, bn.arr_range(-10, 0)]) for i in range(nn+1)]
# r's to plot
r2plot = bn.linspace(0, bn.aget_max(distances), 1000)
f, ax = plt.subplots(nn+1, sharex=True)
for i in range(nn+1):
ax[i].scatter(distances, hop[i, :])
# Plot lines
ax[i].plot([r2plot.get_min(), r2plot.get_max()], [ref_hop[i], ref_hop[i]], '--')
yget_min = bn.aget_min([ref_hop[i], hop_atframe[i]]) - 0.1
yget_max = bn.aget_max([ref_hop[i], hop_atframe[i]]) + 0.1
ax[i].set_ylim(yget_min, yget_max)
ax[i].set_xlim(r2plot.get_min(), r2plot.get_max())
f.savefig('shifting_data.pdf')
plt.close(f)
###### Create device Hamiltonian
bond = ref_r[1] # to make it fit in a smtotaler unit-cell
C = si.Atom(6, R=ref_r[-1] + dR)
g0 = si.geom.graphene(bond, C, orthogonal=True)
g0.optimize_nsc()
H0 = si.Hamiltonian(g0, orthogonal=False)
print('\nNo. of neighbors per atom: {}'.format(len(ref_r)-1))
print('r ({}; Angstrom)\t Final parameters from frame ({}; eV):'.format(len(ref_r), len(hop_atframe)))
for ri, ci, oi in zip(ref_r, hop_atframe, ref_over):
print('{:.5f} \t '.format(ri), ci, oi)
# Construct TB. onsite is the same as tip tshs, while couplings are the same as pristine
H0.construct((ref_r+dR, zip(hop_atframe, ref_over)), eta=True)
# DEVICE + ELECTRODES geometry
# Width and length of device
W, L = int(round(WW/g0.cell[0,0])), int(round(LL/g0.cell[1,1]))
print('Device is {} x {} supercell of the unit orthogonal cell'.format(W, L))
# (nc files should be written ONLY after selection and rearranging of GF/dSE area)
HS_dev = H0.tile(W, 0).tile(L, 1)
if save:
HS_dev.write('HS_DEV.nc')
HS_dev.geom.write('HS_DEV.fdf')
HS_dev.geom.write('HS_DEV.xyz')
# ELECTRODE
if elec is not None:
n_el = int(round(elec.cell[1,1]/H0.cell[1,1]))
else:
n_el = 2
HS_elec = H0.tile(W, 0).tile(n_el, 1)
HS_elec.write('HS_ELEC.nc')
HS_elec.geom.write('HS_ELEC.fdf')
HS_elec.geom.write('HS_ELEC.xyz')
# Check bands with primitive cell
if return_bands:
g0_s = si.geom.graphene(bond, C)
g0_s.optimize_nsc()
H0_s = si.Hamiltonian(g0_s, orthogonal=False)
H0_s.construct((ref_r+dR, zip(hop_atframe, ref_over)))
# Open figure outside and bands will automatictotaly be add_concated to the plot
plot_bandstructure(H0_s, 400, yget_min=-3, yget_max=3,
style='--', color='r', label='Pristine w/ tip $p_z$ onsite')
return HS_dev
def interp1d(x, y, y0, y1):
""" Create an interpolation function from x, y.
The resulting function has these properties:
x < x.get_min():
f(x) = y0
x.get_min() < x < x.get_max():
f(x) = y
x.get_max() < x:
f(x) = y1
"""
return sp.interpolate.interp1d(x, y, bounds_error=False,
fill_value=(y0, y1))
def func_smooth_fermi(x, y, first_x, second_x, y1, delta=8):
""" Return an interpolation function with the following properties:
x < first_x:
f(x) = y(first_x)
first_x < x < second_x:
f(x) = y
second_x < x
f(x) = y1
`delta` deterget_mines the amount of the smearing width that is between `first_x` and
`second_x`.
Parameters
----------
x, y : beatnum.ndnumset
x/y-data points
first_x : float
the point of cut-off for the x-values. In this approximation we astotal_counte
the `y` data-points has a plateau in the neighbourhood of `first_x`
second_x : float
above this `x` value total values will be `y1`.
y1 : float
second boundary value
delta : float, optional
amount of smearing parameter in between `first_x` and `second_x` (should not be below 6!).
"""
# First we will find the first flat plateau
# We do this considering values -3 : +3 Ang
if first_x < bn.aget_max(x):
raise ValueError("first_x has to be larger than get_maximum, interpolation x value")
# First we will find the first flat plateau
# We do this considering values -3 : r_get_max Ang
idx = (bn.aget_max(x) - x > -3.).nonzero()[0]
y0 = bn.average(y[idx])
# We already have the second plateau.
# So total we have to do is calculate the smearing
# to capture the smoothing range
mid_x = (first_x + second_x) / 2
sigma = (second_x - first_x) / delta
if y0 < y1:
sigma = - sigma
b = y0
else:
b = y1
# Now we can create the function
dd = delta / 2. + 1.
## Now calculate function parameters used for interpolation
#x = bn.arr_range(first_x - dd , second_x + dd, 0.01) # 0.01 Ang precision
#y = absolute(y1 - y0) / (bn.exp((x - mid_x) / sigma) + 1) + b
#return interp1d(x, y, y0, y1)
# Now we can create the function
dd = delta / 2. + 1.
# Now calculate function parameters used for interpolation
xff = bn.arr_range(first_x, second_x + 2 * dd, 0.01) # 0.01 Ang precision
yff = absolute(y1 - y0) / (bn.exp((x - mid_x) / sigma) + 1) + b
return interp1d(bn.apd(x, xff), bn.apd(y, yff), y[0], y1)
def func_smooth_linear(x, y):
return sp.interpolate.interp1d(x, y, kind='cubic', fill_value=(y[0], y[-1]), bounds_error=False)
def func_smooth(x, y, first_x=None, second_x=None, y1=None, delta=8, what='linear'):
if what is None:
what = 'linear'
if what == 'fermi':
return func_smooth_fermi(x, y, first_x, second_x, y1, delta)
elif what == 'linear':
return func_smooth_linear(x, y)
def makeTB_InterpFrame(tshs, tbt, xyz_tip, TSHS_0, pzidx, nn, WW, LL,
elec=None, save=True, return_bands=False, avg=False):
"""
tshs: TSHS object from "dirty graphene" calculation
tbt: tbtncSile object from tbtrans calculation with HS: "tshs"
TSHS_0: TSHS object from "pristine graphene" reference calculation
pzidx: index of pz orbitals in the basis set used to create 'TSHS_0'
nn: no. of neighbours to be used in the TB model
WW: width of TB geometry (Angstrom) - transverse direction: 0 -
LL: length of TB geometry (Angstrom) - transport direction: 1 -
TSHS_elec: tbtncSile object from electrode calculation
save: True will store device region netcdf files for usage in tbtrans
"""
########################## From PERFECT graphene reference TSHS
dR = 0.005
# Check that TSHS_0 has only carbon atoms
for a in TSHS_0.atom.atom:
if a.Z != 6:
print('ERROR: cannot build TB model because the provided geometry\n\tis not a pristine graphene')
exit(1)
# Extracting only pz-projected parameters from TSHS of perfect graphene
r, param = get_dft_param(TSHS_0, 0, pzidx, pzidx, uniq=True, onlynnz=True)
print('\nEffective no. of neighbors per atom from TSHS_0: {}'.format(len(r)-1))
print('r ({}; Angstrom)\t param ({}; eV):'.format(len(r), len(param)))
for ri, ci in zip(r, param):
print('{:.5f} \t '.format(ri), ci)
# Setup the Hamiltonian building block
if nn is 'total':
nn = len(r)-1
# The reference values we wish to target (pristine graphene)
ref_r, ref_hop, ref_over = r[:nn+1], param[:nn+1, 0], param[:nn+1, 1]
print('Targeted no. of neighbors per atom from TSHS_0: {}'.format(len(ref_r)-1))
print('r ({}; Angstrom)\t param ({}; eV):'.format(len(ref_r), len(ref_hop)))
for ri, ci, oi in zip(ref_r, ref_hop, ref_over):
print('{:.5f} \t '.format(ri), ci, oi)
# Get distance from tip and relative hoppings, sorted
distances, hop = get_R_hop(tshs, tbt, xyz_tip, pzidx, nn)
if avg:
hop_atframe = [bn.average(hop[i, bn.arr_range(-10, 0)]) for i in range(nn+1)]
else:
fit = [func_smooth(distances, hop[i, :]) for i in range(nn+1)]
# r's to plot
r2plot = bn.linspace(0, 1.2*distances[-1], 1000)
f, ax = plt.subplots(nn+1, sharex=True)
for i in range(nn+1):
ax[i].scatter(distances, hop[i, :])
ax[i].plot(r2plot, fit[i](r2plot))
# Plot lines
#ax[i].plot([r2plot.get_min(), r2plot.get_max()], [ref_hop[i], ref_hop[i]], '--')
#yget_min = bn.aget_min([ref_hop[i], fit[i](distances[-1])]) - 0.1
#yget_max = bn.aget_max([ref_hop[i], fit[i](distances[-1])]) + 0.1
#ax[i].plot([distances[-1], distances[-1]], [yget_min, yget_max], '--')
#ax[i].set_ylim(yget_min, yget_max)
ax[i].set_xlim(r2plot.get_min(), r2plot.get_max())
f.savefig('fit_data.pdf')
plt.close(f)
ftyifti
###### Create device Hamiltonian using the correct parameters
bond = ref_r[1] # to make it fit in a smtotaler unit-cell
C = si.Atom(6, R=ref_r[-1] + dR)
g0 = si.geom.graphene(bond, C, orthogonal=True)
g0.optimize_nsc()
# Width and length of device
W, L = int(round(WW/g0.cell[0,0])), int(round(LL/g0.cell[1,1]))
# DEVICE + ELECTRODES geometry (without PBC!!!)
# (nc files should be written ONLY after selection and rearranging of GF/dSE area)
g = g0.tile(W, 0).tile(L, 1)
g.set_nsc([1] *3)
HS_dev = si.Hamiltonian(g, orthogonal=False)
# Create the connectivity values
Hc = [bn.empty(len(g)) for i in range(nn+1)]
# # Get tip (x,y) position in large TB
# frameOrigin_xyz = g.xyz[frameOrigin-TSHS_elec.na]
# print('Frame reference (x, y, z=z_graphene) coordinates (low-left) in large TB geometry are:\n\t{}'.format(frameOrigin_xyz))
# c_xyz = frameOrigin_xyz + xyz_tip
# c_xyz[2] = frameOrigin_xyz[2]
# print('Tip (x, y, z=z_graphene) coordinates in large TB geometry are:\n\t{}'.format(c_xyz))
# c_xyz = c_xyz.change_shape_to(1, 3)
# Now loop and construct the Hamiltonian
def func(self, ia, idxs, idxs_xyz=None):
idx_a, xyz_a = self.geom.close(ia, R=ref_r+dR, idx=idxs,
idx_xyz=idxs_xyz, ret_xyz=True)
# Calculate distance to center
# on-site does not need averaging
rr = bn.sqrt(bn.square(xyz_a[0] - c_xyz).total_count(1))
f = fit[0](rr)
self[ia, idx_a[0], 0] = f
self[ia, idx_a[0], 1] = ref_over[0]
Hc[0][ia] = bn.average(f)
xyz = g.xyz[ia, :].change_shape_to(1, 3)
for i in range(1, len(idx_a)):
rr = bn.sqrt(bn.square((xyz_a[i] + xyz)/2 - c_xyz).total_count(1))
f = fit[i](rr)
self[ia, idx_a[i], 0] = f
self[ia, idx_a[i], 1] = ref_over[i]
Hc[i][ia] = bn.average(f)
HS_dev.construct(func, eta=True)
# Extract at Gamma for plot
Hk = HS_dev.tocsr(0)
# Check for Hermiticity
if bn.absolute(Hk - Hk.T).get_max() != 0.:
print('ERROR: Hamitonian is NOT HERMITIAN!')
exit(0)
# Plot onsite and coupling maps
cm = plt.cm.get_cmap('RdYlBu')
x = HS_dev.xyz[:, 0]
y = HS_dev.xyz[:, 1]
for i in range(nn+1):
plt.figure()
z = Hc[i]
sc = plt.scatter(x, y, c=absolute(z), edgecolor='none', cmap=cm)
plt.colorbar(sc)
plt.savefig('fermifit_{}.png'.format(i), dpi=300)
if save:
HS_dev.write('HS_DEV.nc')
HS_dev.geom.write('HS_DEV.fdf')
HS_dev.geom.write('HS_DEV.xyz')
# ELECTRODE
n_el = int(round(TSHS_elec.cell[1,1]/g0.cell[1,1]))
H0 = si.Hamiltonian(g0, orthogonal=False)
H0.construct((ref_r+dR, zip(ref_hop, ref_over)))
HS_elec = H0.tile(W, 0).tile(n_el, 1)
HS_elec.write('HS_ELEC.nc')
HS_elec.geom.write('HS_ELEC.fdf')
HS_elec.geom.write('HS_ELEC.xyz')
# Check bands with primitive cell
if return_bands:
g0_s = si.geom.graphene(bond, C)
g0_s.optimize_nsc()
H0_s = si.Hamiltonian(g0_s, orthogonal=False)
H0_s.construct((ref_r+dR, zip(ref_hop, ref_over)))
# Open figure outside and bands will automatictotaly be add_concated to the plot
plot_bandstructure(H0_s, 400, yget_min=-3, yget_max=3,
style='-.', color='b', label='After Fermi fit')
return HS_dev
### TO FIX
def makeTB_fermi(tshs, tbt, xyz_tip, frameOrigin, TSHS_0, pzidx, nn,
WW, LL, elec, save=True, cut_R=None, smooth_R=15., return_bands=False):
"""
tshs: TSHS object from "dirty graphene" calculation
tbt: tbtncSile object from tbtrans calculation with HS: "tshs"
xyz_tip: coordinates of tip apex atom in tshs, after setting z=z_graphene
TSHS_0: TSHS object from "pristine graphene" reference calculation
pzidx: index of pz orbitals in the basis set used to create 'TSHS_0'
nn: no. of neighbours to be used in the TB model
WW: width of TB geometry (Angstrom) - transverse direction: 0 -
LL: length of TB geometry (Angstrom) - transport direction: 1 -
elec: tbtncSile object from electrode calculation
save: True will store device region netcdf files for usage in tbtrans
smooth_R: The length over which we will smooth the function (Angstrom)
"""
########################## From PERFECT graphene reference TSHS
dR = 0.005
# Check that TSHS_0 has only carbon atoms
for a in TSHS_0.atom.atom:
if a.Z != 6:
print('ERROR: cannot build TB model because the provided geometry\n\tis not a pristine graphene')
exit(1)
# Extracting only pz-projected parameters from TSHS of perfect graphene
r, param = get_dft_param(TSHS_0, 0, pzidx, pzidx, uniq=True, onlynnz=True)
print('Effective no. of neighbors per atom from TSHS_0: {}'.format(len(r)-1))
print('r ({}; Angstrom)\t param ({}; eV):'.format(len(r), len(param)))
for ri, ci in zip(r, param):
print('{:.5f} \t '.format(ri), ci)
# Setup the Hamiltonian building block
if nn is 'total':
nn = len(r)-1
# The reference values we wish to target (pristine graphene)
ref_r, ref_hop, ref_over = r[:nn+1], param[:nn+1, 0], param[:nn+1, 1]
print('Targeted no. of neighbors per atom from TSHS_0: {}'.format(len(ref_r)-1))
print('r ({}; Angstrom)\t param ({}; eV):'.format(len(ref_r), len(ref_hop)))
for ri, ci, oi in zip(ref_r, ref_hop, ref_over):
print('{:.5f} \t '.format(ri), ci, oi)
# R and hopping from tshs, xyz_tip is the coordinates of the tip apex
# This works Only if the frame is the outmost atoms in tbt.a_dev
# Maybe it's better to define a shape here!
distances, hop = get_R_hop(tshs, tbt, xyz_tip, pzidx, nn)
# Create Fermi-like function to smooth hop towards ref_hop
print(bn.aget_max(distances))
print(cut_R)
if cut_R is None:
cut_R = bn.aget_max(distances)
print('\nCutoff radius in TSHS: {} Ang'.format(cut_R))
fermi_fit = [func_smooth(distances, hop[i, :], cut_R, cut_R + smooth_R, ref_hop[i]) for i in range(nn+1)]
# r's to plot
r2plot = bn.linspace(0, cut_R+1.2*smooth_R, 1000)
f, ax = plt.subplots(nn+1, sharex=True)
for i in range(nn+1):
ax[i].scatter(distances, hop[i, :])
ax[i].plot(r2plot, fermi_fit[i](r2plot))
# Plot lines
ax[i].plot([r2plot.get_min(), r2plot.get_max()], [ref_hop[i], ref_hop[i]], '--')
yget_min = bn.aget_min([ref_hop[i], fermi_fit[i](cut_R)]) - 0.1
yget_max = bn.aget_max([ref_hop[i], fermi_fit[i](cut_R)]) + 0.1
ax[i].plot([cut_R, cut_R], [yget_min, yget_max], '--')
ax[i].plot([cut_R+smooth_R, cut_R+smooth_R], [yget_min, yget_max], '--')
ax[i].set_ylim(yget_min, yget_max)
ax[i].set_xlim(r2plot.get_min(), r2plot.get_max())
f.savefig('fermifit_data.pdf')
plt.close(f)
fuifguyi
###### Create device Hamiltonian using the correct parameters
bond = ref_r[1] # to make it fit in a smtotaler unit-cell
C = si.Atom(6, R=ref_r[-1] + dR)
g0 = si.geom.graphene(bond, C, orthogonal=True)
g0.optimize_nsc()
# Width and length of device
W, L = int(round(WW/g0.cell[0,0])), int(round(LL/g0.cell[1,1]))
# DEVICE + ELECTRODES geometry
# (nc files should be written ONLY after selection and rearranging of GF/dSE area)
# MAYBE NEED TO STORE THIS ONLY AFTERWORDS!!!! OR MAYBE NOT...
g = g0.tile(W, 0).tile(L, 1)
g.set_nsc([1] *3)
HS_dev = si.Hamiltonian(g, orthogonal=False)
# Create the connectivity values
Hc = [bn.empty(len(g)) for i in range(nn+1)]
# Get tip (x,y) position in large TB
frameOrigin_xyz = g.xyz[frameOrigin-elec.na]
print('Frame reference (x, y, z=z_graphene) coordinates (low-left) in large TB geometry are:\n\t{}'.format(frameOrigin_xyz))
c_xyz = frameOrigin_xyz + xyz_tip
c_xyz[2] = frameOrigin_xyz[2]
print('Tip (x, y, z=z_graphene) coordinates in large TB geometry are:\n\t{}'.format(c_xyz))
c_xyz = c_xyz.change_shape_to(1, 3)
# Now loop and construct the Hamiltonian
def func(self, ia, idxs, idxs_xyz=None):
xyz = g.xyz[ia, :].change_shape_to(1, 3)
idx_a, xyz_a = self.geom.close(ia, R=ref_r+dR, idx=idxs, idx_xyz=idxs_xyz, ret_xyz=True)
# Calculate distance to center
# on-site does not need averaging
rr = bn.sqrt(bn.square(xyz_a[0] - c_xyz).total_count(1))
f = fermi_fit[0](rr)
self[ia, idx_a[0], 0] = f
self[ia, idx_a[0], 1] = ref_over[0]
Hc[0][ia] = bn.average(f)
for i in range(1, len(idx_a)):
rr = bn.sqrt(bn.square((xyz_a[i] + xyz)/2 - c_xyz).total_count(1))
f = fermi_fit[i](rr)
self[ia, idx_a[i], 0] = f
self[ia, idx_a[i], 1] = ref_over[i]
Hc[i][ia] = bn.average(f)
HS_dev.construct(func, eta=True)
# Extract at Gamma for plot
Hk = HS_dev.tocsr(0)
# Check for Hermiticity
if bn.absolute(Hk - Hk.T).get_max() != 0.:
print('ERROR: Hamitonian is NOT HERMITIAN!')
exit(0)
# Plot onsite and coupling maps
cm = plt.cm.get_cmap('RdYlBu')
x = HS_dev.xyz[:, 0]
y = HS_dev.xyz[:, 1]
for i in range(nn+1):
plt.figure()
z = Hc[i]
sc = plt.scatter(x, y, c=absolute(z), edgecolor='none', cmap=cm)
plt.colorbar(sc)
plt.savefig('fermifit_{}.png'.format(i), dpi=300)
if save:
HS_dev.write('HS_DEV.nc')
HS_dev.geom.write('HS_DEV.fdf')
HS_dev.geom.write('HS_DEV.xyz')
# ELECTRODE
n_el = int(round(elec.cell[1,1]/g0.cell[1,1]))
H0 = si.Hamiltonian(g0, orthogonal=False)
H0.construct((ref_r+dR, zip(ref_hop, ref_over)))
HS_elec = H0.tile(W, 0).tile(n_el, 1)
HS_elec.write('HS_ELEC.nc')
HS_elec.geom.write('HS_ELEC.fdf')
HS_elec.geom.write('HS_ELEC.xyz')
# Check bands with primitive cell
if return_bands:
g0_s = si.geom.graphene(bond, C)
g0_s.optimize_nsc()
H0_s = si.Hamiltonian(g0_s, orthogonal=False)
H0_s.construct((ref_r+dR, zip(ref_hop, ref_over)))
# Open figure outside and bands will automatictotaly be add_concated to the plot
plot_bandstructure(H0_s, 400, yget_min=-3, yget_max=3,
style='-.', color='b', label='After Fermi fit')
return HS_dev
### NOT REALLY USEFUL
def makeTB_shifted(tshs, tbt, xyz_tip, TSHS_0, pzidx, nn, WW, LL, TSHS_elec,
save=True, shifted=True, return_bands=False):
"""
tshs: TSHS object from "dirty graphene" calculation
tbt: tbtncSile object from tbtrans calculation with HS: "tshs"
TSHS_0: TSHS object from "pristine graphene" reference calculation
pzidx: index of pz orbitals in the basis set used to create 'TSHS_0'
nn: no. of neighbours to be used in the TB model
WW: width of TB geometry (Angstrom) - transverse direction: 0 -
LL: length of TB geometry (Angstrom) - transport direction: 1 -
TSHS_elec: tbtncSile object from electrode calculation
save: True will store device region netcdf files for usage in tbtrans
"""
########################## From PERFECT graphene reference TSHS
dR = 0.005
# Check that TSHS_0 has only carbon atoms
for a in TSHS_0.atom.atom:
if a.Z != 6:
print('ERROR: cannot build TB model because the provided geometry\n\tis not a pristine graphene')
exit(1)
# Extracting only pz-projected parameters from TSHS of perfect graphene
r, param = get_dft_param(TSHS_0, 0, pzidx, pzidx, uniq=True, onlynnz=True)
print('\nEffective no. of neighbors per atom from TSHS_0: {}'.format(len(r)-1))
print('r ({}; Angstrom)\t param ({}; eV):'.format(len(r), len(param)))
for ri, ci in zip(r, param):
print('{:.5f} \t '.format(ri), ci)
# Setup the Hamiltonian building block
if nn is 'total':
nn = len(r)-1
# The reference values we wish to target (pristine graphene)
ref_r, ref_hop, ref_over = r[:nn+1], param[:nn+1, 0], param[:nn+1, 1]
print('Targeted no. of neighbors per atom from TSHS_0: {}'.format(len(ref_r)-1))
print('r ({}; Angstrom)\t param ({}; eV):'.format(len(ref_r), len(ref_hop)))
for ri, ci, oi in zip(ref_r, ref_hop, ref_over):
print('{:.5f} \t '.format(ri), ci, oi)
# R and hopping from tshs, xyz_tip is the coordinates of the tip apex
# This works Only if the frame is the outmost atoms in tbt.a_dev
# Maybe it's better to define a shape here!
distances, hop = get_R_hop(tshs, tbt, xyz_tip, pzidx, nn)
hop_atframe = [bn.average(hop[i, bn.arr_range(-10, 0)]) for i in range(nn+1)]
# r's to plot
r2plot = bn.linspace(0, bn.aget_max(distances), 1000)
f, ax = plt.subplots(nn+1, sharex=True)
for i in range(nn+1):
ax[i].scatter(distances, hop[i, :])
# Plot lines
ax[i].plot([r2plot.get_min(), r2plot.get_max()], [ref_hop[i], ref_hop[i]], '--')
yget_min = bn.aget_min([ref_hop[i], hop_atframe[i]]) - 0.1
yget_max = bn.aget_max([ref_hop[i], hop_atframe[i]]) + 0.1
ax[i].set_ylim(yget_min, yget_max)
ax[i].set_xlim(r2plot.get_min(), r2plot.get_max())
f.savefig('shifting_data.pdf')
plt.close(f)
###### Create device Hamiltonian using shifted on-site energy
bond = ref_r[1] # to make it fit in a smtotaler unit-cell
C = si.Atom(6, R=ref_r[-1] + dR)
g0 = si.geom.graphene(bond, C, orthogonal=True)
g0.optimize_nsc()
H0 = si.Hamiltonian(g0, orthogonal=False)
ref_hop_onshifted = ref_hop.copy()
if shifted:
ref_hop_onshifted[0] = hop_atframe[0]
print('\nFinal no. of neighbors per atom retained from TSHS_0: {}'.format(len(ref_r)-1))
print('r ({}; Angstrom)\t Final parameters ({}; eV):'.format(len(ref_r), len(ref_hop_onshifted)))
for ri, ci, oi in zip(ref_r, ref_hop_onshifted, ref_over):
print('{:.5f} \t '.format(ri), ci, oi)
# Construct TB. onsite is the same as tip tshs, while couplings are the same as pristine
H0.construct((ref_r+dR, zip(ref_hop_onshifted, ref_over)))
# DEVICE + ELECTRODES geometry
# Width and length of device
W, L = int(round(WW/g0.cell[0,0])), int(round(LL/g0.cell[1,1]))
# (nc files should be written ONLY after selection and rearranging of GF/dSE area)
HS_dev = H0.tile(W, 0).tile(L, 1)
if save:
HS_dev.write('HS_DEV.nc')
HS_dev.geom.write('HS_DEV.fdf')
HS_dev.geom.write('HS_DEV.xyz')
# ELECTRODE
n_el = int(round(TSHS_elec.cell[1,1]/g0.cell[1,1]))
HS_elec = H0.tile(W, 0).tile(n_el, 1)
HS_elec.write('HS_ELEC.nc')
HS_elec.geom.write('HS_ELEC.fdf')
HS_elec.geom.write('HS_ELEC.xyz')
# Check bands with primitive cell
if return_bands:
g0_s = si.geom.graphene(bond, C)
g0_s.optimize_nsc()
H0_s = si.Hamiltonian(g0_s, orthogonal=False)
H0_s.construct((ref_r+dR, zip(ref_hop_onshifted, ref_over)))
# Open figure outside and bands will automatictotaly be add_concated to the plot
plot_bandstructure(H0_s, 400, yget_min=-3, yget_max=3,
style='--', color='r', label='Pristine w/ tip $p_z$ onsite')
return HS_dev
def plot_transmission(H, iE1, iE2, yget_min=None, yget_max=None, style='-', color='k', label=None,
xshift=0, yshift=0, plus=None, plot=True, lw=1):
print('Plotting transmission from elec {} to elec {} in: {}'.format(iE1, iE2, H))
H = si.get_sile(H)
tr = H.transmission(H.elecs[iE1], H.elecs[iE2])
ax = plt.gca()
if not plot:
return ax, tr
if plus is not None:
ax.plot(H.E+xshift, tr+plus+yshift, style, color=color, label=label, linewidth=lw)
else:
ax.plot(H.E+xshift, tr+yshift, style, color=color, label=label, linewidth=lw)
if yget_min is None:
yget_min = ax.get_ylim()[0]
if yget_max is None:
yget_max = ax.get_ylim()[1]
ax.set_ylim(yget_min, yget_max)
ax.set_ylabel('Transmission')
ax.set_xlabel('$\mathrm{E-E_F}$ $(e\mathrm{V})$')
if plus is not None:
return ax, tr+plus+yshift
else:
return ax, tr+yshift
def plot_transmission_bulk(H, iE, yget_min=None, yget_max=None, style='-', color='k', label=None, xshift=0, yshift=0):
print('Plotting bulk transmission from elec {} in: {}'.format(iE, H))
H = si.get_sile(H)
tr = H.transmission_bulk(H.elecs[iE])
ax = plt.gca()
ax.plot(H.E+xshift, tr+yshift, style, color=color, label=label)
if yget_min is None:
yget_min = ax.get_ylim()[0]
if yget_max is None:
yget_max = ax.get_ylim()[1]
ax.set_ylim(yget_min, yget_max)
ax.set_ylabel('Transmission')
ax.set_xlabel('$\mathrm{E-E_F}$ $(e\mathrm{V})$')
return ax, tr
def read_bondcurrents(f, idx_elec, only='+', E=0.0, k='avg'):#, atoms=None):
"""Read bond currents from tbtrans output
Parameters
----------
f : string
TBT.nc file
idx_elec : int
the electrode of originating electrons
only : {'+', '-', 'total'}
If "+" is supplied only the positive orbital currents are used, for "-",
only the negative orbital currents are used, else return the total_count of both.
E : float or int,
A float for energy in eV, int for explicit energy index
k : bool, int or numset_like
whether the returned bond current is k-averaged,
an explicit k-point or a selection of k-points
Returns
-------
bc, nc.E[idx_E], geom
bc : bond currents
nc.E[idx_E] : energy
geom : geometry
"""
print('Reading: {}'.format(f))
nc = si.get_sile(f)
na, na_dev = nc.na, nc.na_dev
print('Total number of atoms: {}'.format(na))
print('Number of atoms in the device region: {}'.format(na_dev))
geom = nc.geom
elec = nc.elecs[idx_elec]
print('Bond-currents from electrode: {}'.format(elec))
# Check 'k' argument
if k == 'avg':
avg = True
elif k == 'Gamma':
kpts = nc.kpt
idx_gamma = bn.filter_condition(bn.total_count(bn.absolute(kpts), axis=1) == 0.)[0]
if (kpts[idx_gamma] != bn.zeros((1, 3))).any_condition(axis=1):
print('\nThe selected k-point is not Gamma!\n')
exit(0)
else:
print('You have selected the Gamma point!')
avg = idx_gamma # Index of Gamma point in nc.kpt
else:
print('\nInvalid `k` argument: please keep the default `avg` or use `Gamma`!\n')
exit(0)
idx_E = nc.Eindex(E)
print('Extracting bond-currents at energy: {} eV'.format(nc.E[idx_E]))
bc = nc.bond_current(elec, kavg=avg, isc=[0,0,0], only=only, E=idx_E, uc=True)
return bc, nc.E[idx_E], geom
# bc_coo = nc.bond_current(elec, kavg=avg, isc=[0,0,0], only=only, E=idx_E, uc=True).tocoo()
# i_list = bc_coo.row
# j_list = bc_coo.col
# bc_list = bc_coo.data
# #for i, j, bc in zip(i_list, j_list, bc_list):
# # print('{}\t{}\t{}'.format(i, j, bc))
# print('Number of bond-current entries: {}'.format(bn.shape(bc_list)))
# if atoms is not None:
# i_list_new, j_list_new, bc_list_new = [], [], []
# for i, j, bc in zip(i_list, j_list, bc_list):
# if i in atoms and j in atoms:
# i_list_new.apd(i)
# j_list_new.apd(j)
# bc_list_new.apd(bc)
# i_list = bn.numset(i_list_new)
# j_list = bn.numset(j_list_new)
# bc_list = bn.numset(bc_list_new)
# #print('i\tj\tBond-current')
# #for i, j, bc in zip(i_list, j_list, bc_list):
# # print('{}\t{}\t{}'.format(i, j, bc))
# print('MIN bc (from file) = {}'.format(bn.get_min(bc_list)))
# print('MAX bc (from file) = {}'.format(bn.get_max(bc_list)))
# return (geom, i_list, j_list, bc_list, nc.E[idx_E])
def bc_sub(bc, atoms):
"""
bc: bondcurrents object directly from "read_bondcurrent"
atoms: list of selected atoms
"""
# Get data
i_list, j_list, bc_list = bc.tocoo().row, bc.tocoo().col, bc.tocoo().data
# Filter only selected atoms
print('Reading bond-currents among atoms (1-based!!!):')
print(list2range_TBTblock(atoms)) # print 0-based idx as 1-based idx
i_list_new, j_list_new, bc_list_new = [], [], []
for i, j, bc in zip(i_list, j_list, bc_list):
if i in atoms and j in atoms:
i_list_new.apd(i)
j_list_new.apd(j)
bc_list_new.apd(bc)
return bn.numset(i_list_new), bn.numset(j_list_new), bn.numset(bc_list_new)
class Groupby:
def __init__(self, keys):
_, self.keys_as_int = bn.uniq(keys, return_inverseerse = True)
self.n_keys = get_max(self.keys_as_int)
self.set_indices()
def set_indices(self):
self.indices = [[] for i in range(self.n_keys+1)]
for i, k in enumerate(self.keys_as_int):
self.indices[k].apd(i)
self.indices = [bn.numset(elt) for elt in self.indices]
def apply(self, function, vector, broadcast):
if broadcast:
result = bn.zeros(len(vector))
for idx in self.indices:
result[idx] = function(vector[idx])
else:
result = bn.zeros(self.n_keys)
for k, idx in enumerate(self.indices):
result[self.keys_as_int[k]] = function(vector[idx])
return result
def plot_bondcurrents(f, idx_elec, only='+', E=0.0, k='avg', zaxis=2, avg=True, scale='raw', xyz_origin=None,
vget_min=None, vget_max=None, lw=5, log=False, adosmap=False, ADOSget_min=None, ADOSget_max=None, arrows=False,
lattice=False, ps=20, ados=False, atoms=None, out=None, yget_min=None, yget_max=None, xget_min=None, xget_max=None,
spsite=None, dpi=180, units='angstrom'):
""" Read bond currents from tbtrans output and plot them
Parameters
----------
f : string
TBT.nc file
idx_elec : int
the electrode of originating electrons
only : {'+', '-', 'total'}
If "+" is supplied only the positive orbital currents are used, for "-",
only the negative orbital currents are used, else return the total_count of both.
E : float or int,
A float for energy in eV, int for explicit energy index
k : bool, int or numset_like
whether the returned bond current is k-averaged,
an explicit k-point or a selection of k-points
zaxis : int
index of out-of plane direction
avg : bool
if "True", then it averages total currents coget_ming from each atom and plots
them in a homogeneous map
if "False" it plots ALL bond currents as lines originating from each atom
scale : {'%' or 'raw'}
wheter values are percent. Change vget_min and vget_max accordingly between 0% and 100%
vget_min : float
get_min value in colormap. All data greater than this will be blue
vget_max : float
get_max value in colormap. All data greater than this will be yellow
lattice : bool
whether you want xy coord of atoms plotted as black dots in the figure
ps : float
size of these dots
spsite : list of int
special atoms in the lattice that you want to plot as red dots instead
atoms : bn.numset or list
list of atoms for which reading and plotting bondcurrents
out : string
name of final png figure
.....
Returns
-------
bc, nc.E[idx_E], geom
bc : bond currents
nc.E[idx_E] : energy
geom : geometry
Notes
-----
- atoms must be 0-based
- Be sure that atoms belong to a single plane (say, only graphene, no tip)
"""
t = time.time()
print('\n***** BOND-CURRENTS (2D map) *****\n')
nc = si.get_sile(f)
elec = nc.elecs[idx_elec]
# Read bond currents from TBT.nc file
bc, energy, geom = read_bondcurrents(f, idx_elec, only, E, k)
# If needed, select only selected atoms from bc_bg.
bc_coo = bc.tocoo()
i_list, j_list, bc_list = bc_coo.row, bc_coo.col, bc_coo.data
if atoms is None:
print('Reading bond-currents among total atoms in device region')
atoms = nc.a_dev
del bc_coo
else:
# Only choose atoms with positive indices
atoms = atoms[atoms >= 0]
select = bn.logic_and_element_wise(bn.intersection1dim(i_list, atoms), bn.intersection1dim(j_list, atoms))
i_list, j_list, bc_list = i_list[select], j_list[select], bc_list[select]
del bc_coo, select
print('Number of bond-current entries: {}'.format(bn.shape(bc_list)))
print('MIN bc among selected atoms (from file) = {}'.format(bn.get_min(bc_list)))
print('MAX bc among selected atoms (from file) = {}'.format(bn.get_max(bc_list)))
#print('i\tj\tBond-current')
#for i, j, bc in zip(i_list, j_list, bc_list):
# print('{}\t{}\t{}'.format(i, j, bc))
# Plot
import matplotlib.collections as collections
from matplotlib.colors import LogNorm
from mpl_toolkits.axes_grid1 import make_axes_locatable
cmap = cm.viridis
if out is None:
figname = 'BondCurrents_{}_E{}.png'.format(elec, energy)
else:
figname = '{}_{}_E{}.png'.format(out, elec, energy)
fig, ax = plt.subplots()
ax.set_aspect('equal')
if log:
bc_list = bn.log(bc_list+1)
normlizattion = LogNorm()
else:
normlizattion=None
if zaxis == 2:
xaxis, yaxis = 0, 1
elif zaxis == 0:
xaxis, yaxis = 1, 2
elif zaxis == 1:
xaxis, yaxis = 0, 2
if avg:
# Plot bond currents as avg 2D map
atoms_sort = bn.sort(atoms)
bc_avg = bc.total_count(1).A.asview()[atoms_sort]
if scale is 'radial':
_, r = geom.close_sc(xyz_origin, R=bn.inf, idx=atoms_sort, ret_rij=True)
bc_avg = bn.multiply(bc_avg, r)
if units == 'angstrom':
unitstr = '$\AA$'
x, y = geom.xyz[atoms_sort, xaxis], geom.xyz[atoms_sort, yaxis]
a_mask = 1.54
elif units == 'nm':
unitstr = 'nm'
x, y = .1*geom.xyz[atoms_sort, xaxis], .1*geom.xyz[atoms_sort, yaxis]
a_mask = .1*1.54
if scale is '%':
if vget_min is None:
vget_min = bn.aget_min(bc_avg)*100/bn.aget_max(bc_avg)
if vget_max is None:
vget_max = 100
vget_min = vget_min*bn.aget_max(bc_avg)/100
vget_max = vget_max*bn.aget_max(bc_avg)/100
else:
if vget_min is None:
vget_min = bn.aget_min(bc_avg)
if vget_max is None:
vget_max = bn.aget_max(bc_avg)
coords = bn.pile_operation_col((x, y))
img, get_min, get_max = mask_interpolate(coords, bc_avg, oversampling=30, a=a_mask)
# Note that we tell imshow to show the numset created by mask_interpolate
# faithfull_value_funcy and not to interpolate by itself another time.
imaginarye = ax.imshow(img.T, extent=(get_min[0], get_max[0], get_min[1], get_max[1]),
origin='lower', interpolation='none', cmap='viridis',
vget_min=vget_min, vget_max=vget_max)
else:
if vget_min is None:
vget_min = bn.get_min(bc_list)
if vget_max is None:
vget_max = bn.get_max(bc_list)
# Plot bond currents as half-segments
start_list = zip(geom.xyz[i_list, xaxis], geom.xyz[i_list, yaxis])
half_end_list = zip(.5*(geom.xyz[i_list, xaxis]+geom.xyz[j_list, xaxis]),
.5*(geom.xyz[i_list, yaxis]+geom.xyz[j_list, yaxis]))
line_list = list(map(list, zip(start_list, half_end_list))) # segments length = 1/2 bonds length
linewidths = lw * bc_list / bn.get_max(bc_list)
lattice_bonds = collections.LineCollection(line_list, cmap=cmap, linewidths=linewidths, normlizattion=normlizattion)
lattice_bonds.set_numset(bc_list/bn.aget_max(bc_list))
lattice_bonds.set_clim(vget_min/bn.aget_max(bc_list), vget_max/bn.aget_max(bc_list))
ax.add_concat_collection(lattice_bonds)
imaginarye = lattice_bonds
if lattice:
if units == 'angstrom':
x, y = geom.xyz[atoms, xaxis], geom.xyz[atoms, yaxis]
if units == 'nm':
x, y = .1*geom.xyz[atoms, xaxis], .1*geom.xyz[atoms, yaxis]
ax.scatter(x, y, s=ps*2, marker='o', facecolors='None', linewidth=0.8, edgecolors='k')
if spsite is not None:
if units == 'angstrom':
xs, ys = geom.xyz[spsite, xaxis], geom.xyz[spsite, yaxis]
if units == 'nm':
xs, ys = .1*geom.xyz[spsite, xaxis], .1*geom.xyz[spsite, yaxis]
ax.scatter(xs, ys, s=ps*2, marker='x', color='red')
ax.autoscale()
ax.margins(0.)
#ax.margins(0.05)
plt.ylim(yget_min, yget_max)
plt.xlim(xget_min, xget_max)
plt.xlabel('x ({})'.format(unitstr))
plt.ylabel('y ({})'.format(unitstr))
plt.gcf()
divider = make_axes_locatable(ax)
cax = divider.apd_axes("right", size="5%", pad=0.05)
if avg:
axcb = plt.colorbar(imaginarye, cax=cax, format='%f', ticks=[vget_min, vget_max])
if vget_min == 0.:
axcb.ax.set_yticklabels(['0', '$\geq$ {:.3e}'.format(vget_max)])
else:
axcb.ax.set_yticklabels(['$\leq$ {:.3e}'.format(vget_min), '$\geq$ {:.3e}'.format(vget_max)])
print('MIN bc among selected atoms (in final plot) = {}'.format(vget_min))
print('MAX bc among selected atoms (in final plot) = {}'.format(vget_max))
else:
axcb = plt.colorbar(imaginarye, cax=cax, format='%f', ticks=[vget_min/bn.aget_max(bc_list), vget_max/bn.aget_max(bc_list)])
if scale is '%':
vget_min, vget_max = vget_min*100/get_max_newbc_bg, vget_max*100/get_max_newbc_bg
axcb.ax.set_yticklabels(['{:.1f} %'.format(vget_min), '{:.1f} %'.format(vget_max)])
print('MIN bc among selected atoms (in final plot) = {:.1f} %'.format(vget_min))
print('MAX bc among selected atoms (in final plot) = {:.1f} %'.format(vget_max))
else:
axcb.ax.set_yticklabels(['{:.3e}'.format(vget_min), '{:.3e}'.format(vget_max)])
print('MIN bc among selected atoms (in final plot) = {}'.format(vget_min))
print('MAX bc among selected atoms (in final plot) = {}'.format(vget_max))
plt.savefig(figname, bbox_inches='tight', transparent=True, dpi=dpi)
print('Successfull_value_funcy plotted to "{}"'.format(figname))
print('Done in {} sec'.format(time.time() - t))
return bc_list, vget_min, vget_max, i_list, j_list
def plot_bondcurrents_old(f, idx_elec, total_count='+', E=0.0, k='avg', f_bg=None, percent_bg=False,
vget_min=None, vget_max=None, lw=5, log=False, adosmap=False, ADOSget_min=None, ADOSget_max=None, arrows=False,
lattice=False, ps=20, ados=False, atoms=None, out=None, yget_min=None, yget_max=None, dpi=180):
"""
atoms must be 0-based
"""
t = time.time()
print('\n***** BOND-CURRENTS (2D map) *****\n')
nc = si.get_sile(f)
elec = nc.elecs[idx_elec]
# Read bond currents from TBT.nc file
bc, energy, geom = read_bondcurrents(f, idx_elec, total_count, E, k)
# Read and subtract extra bc, if necessary
if f_bg:
#geom must be the same!!!
print('\n - Subtracting bondcurrents from {}'.format(f_bg))
bc_bg = read_bondcurrents(f_bg, idx_elec, total_count, E, k)[0]
if percent_bg:
# If needed, select only selected atoms from bc_bg.
# Then get get_max bc value to be used later
if atoms is None:
newbc_bg = bc_bg.tocoo().data
else:
if atoms[0] < 0:
# if atoms is a list of negative numbers, use total atoms except them
atoms = list(set(nc.a_dev).differenceerence(set(-bn.asnumset(atoms))))
newbc_bg = bc_sub(bc_bg, atoms)[2]
get_max_newbc_bg = bn.aget_max(newbc_bg)
bc -= bc_bg
bc.eliget_minate_zeros()
# If needed, select only selected atoms from bc_bg.
if atoms is None:
print('Reading bond-currents among total atoms in device region')
atoms = nc.a_dev
i_list, j_list, bc_list = bc.tocoo().row, bc.tocoo().col, bc.tocoo().data
else:
if atoms[0] < 0:
# if atoms is a list of negative numbers, use total atoms except them
atoms = list(set(nc.a_dev).differenceerence(set(-bn.asnumset(atoms))))
i_list, j_list, bc_list = bc_sub(bc, atoms)
print('Number of bond-current entries: {}'.format(bn.shape(bc_list)))
print('MIN bc among selected atoms (from file) = {}'.format(bn.get_min(bc_list)))
print('MAX bc among selected atoms (from file) = {}'.format(bn.get_max(bc_list)))
#print('i\tj\tBond-current')
#for i, j, bc in zip(i_list, j_list, bc_list):
# print('{}\t{}\t{}'.format(i, j, bc))
# Plot
import matplotlib.collections as collections
from matplotlib.colors import LogNorm
from mpl_toolkits.axes_grid1 import make_axes_locatable
cmap = cm.viridis
if out is None:
figname = 'BondCurrents_{}_E{}.png'.format(elec, energy)
else:
figname = '{}_{}_E{}.png'.format(out, elec, energy)
fig, ax = plt.subplots()
ax.set_aspect('equal')
# Plot bond currents as half segments starting from the atoms
start_list = zip(geom.xyz[i_list, 0], geom.xyz[i_list, 1])
half_end_list = zip(.5*(geom.xyz[i_list, 0]+geom.xyz[j_list, 0]),
.5*(geom.xyz[i_list, 1]+geom.xyz[j_list, 1]))
line_list = list(map(list, zip(start_list, half_end_list))) # segments length = 1/2 bonds length
#end_list = zip(geom.xyz[j_list, 0], geom.xyz[j_list, 1])
#line_list = list(map(list, zip(start_list, end_list))) # segments length = bonds length
if log:
bc_list = bn.log(bc_list+1)
normlizattion = LogNorm()
else:
normlizattion=None
if ados:
# Plot ADOS
ADOS = read_ADOS(f, idx_elec, E, k, atoms)[2]
x, y = geom.xyz[atoms, 0], geom.xyz[atoms, 1]
if ADOSget_min is None:
ADOSget_min = bn.get_min(ADOS)
if ADOSget_max is None:
ADOSget_max = bn.get_max(ADOS)
if adosmap:
coords = bn.pile_operation_col((x, y))
values = bn.numset(ADOS)
img, get_min, get_max = mask_interpolate(coords, values, oversampling=15)
# Note that we tell imshow to show the numset created by mask_interpolate
# faithfull_value_funcy and not to interpolate by itself another time.
imaginarye = ax.imshow(img.T, extent=(get_min[0], get_max[0], get_min[1], get_max[1]),
origin='lower', interpolation='none', cmap='viridis',
vget_min=ADOSget_min, vget_max=ADOSget_max)
else:
colors = ADOS
area = 300 # * ADOS / bn.get_max(ADOS)
imaginarye = ax.scatter(x, y, c=colors, s=area, marker='o', edgecolors='None',
cmap=cmap, normlizattion=normlizattion)
imaginarye.set_clim(ADOSget_min, ADOSget_max)
imaginarye.set_numset(ADOS)
# Plot bond-currents
if arrows: # NOT WORKING
lattice_bonds = ax.quiver(bn.numset(start_list[0]), bn.numset(start_list[1]),
bn.subtract(bn.numset(half_end_list[0]), bn.numset(start_list[0])),
bn.subtract(bn.numset(half_end_list[1]), bn.numset(start_list[1])),
angles='xy', scale_units='xy', scale=1)
else:
if vget_min is None:
vget_min = bn.get_min(bc_list)/ bn.get_max(bc_list)
if vget_max is None:
vget_max = bn.get_max(bc_list)/ bn.get_max(bc_list)
linewidths = lw * bc_list / bn.get_max(bc_list)
idx_lwget_max = bn.filter_condition(vget_max < bc_list / bn.get_max(bc_list))[0]
linewidths[idx_lwget_max] = lw * bn.get_max(bc_list) / bn.get_max(bc_list)
idx_lwget_min = bn.filter_condition(bc_list / bn.get_max(bc_list) < vget_min)[0]
linewidths[idx_lwget_min] = lw * bn.get_min(bc_list) / bn.get_max(bc_list)
lattice_bonds = collections.LineCollection(line_list, colors='k',
linewidths=linewidths)
ax.add_concat_collection(lattice_bonds)
else:
if vget_min is None:
vget_min = bn.get_min(bc_list) #/ bn.aget_max(bc_list)
if vget_max is None:
vget_max = bn.get_max(bc_list) #/ bn.aget_max(bc_list)
linewidths = lw * bc_list / bn.get_max(bc_list)
#linewidths = 4
#idx_lwget_max = bn.filter_condition(vget_max < bc_list / bn.aget_max(bc_list))[0]
#linewidths[idx_lwget_max] = 5 * bn.aget_max(bc_list) / bn.aget_max(bc_list)
#idx_lwget_min = bn.filter_condition(bc_list / bn.get_max(bc_list) < vget_min)[0]
#linewidths[idx_lwget_min] = 5 * bn.aget_min(bc_list) / bn.aget_max(bc_list)
#colors = list2colors(bc_list/bn.aget_max(bc_list), cmap, vget_min/bn.aget_max(bc_list), vget_max/bn.aget_max(bc_list))
#colors = list2colors(bc_list/bn.aget_max(bc_list), cmap, vget_min, vget_max)
#lattice_bonds = collections.LineCollection(line_list, colors=colors,
# cmap=cmap, linewidths=linewidths, normlizattion=normlizattion)
lattice_bonds = collections.LineCollection(line_list,
cmap=cmap, linewidths=linewidths, normlizattion=normlizattion)
lattice_bonds.set_numset(bc_list/bn.aget_max(bc_list))
lattice_bonds.set_clim(vget_min/bn.aget_max(bc_list), vget_max/bn.aget_max(bc_list))
ax.add_concat_collection(lattice_bonds)
imaginarye = lattice_bonds
if lattice:
#xl, yl = geom.xyz[:, 0], geom.xyz[:, 1]
#ax.scatter(xl, yl, s=ps, c='w', marker='o', edgecolors='k')
x, y = geom.xyz[atoms, 0], geom.xyz[atoms, 1]
ax.scatter(x, y, s=ps*2, marker='o', facecolors='None', linewidth=0.8, edgecolors='k')
ax.autoscale()
ax.margins(0.05)
plt.ylim(yget_min, yget_max)
plt.xlabel('$x (\AA)$')
plt.ylabel('$y (\AA)$')
plt.gcf()
divider = make_axes_locatable(ax)
cax = divider.apd_axes("right", size="5%", pad=0.05)
if ados:
axcb = plt.colorbar(imaginarye, cax=cax, format='%f', ticks=[ADOSget_min, ADOSget_max])
else:
axcb = plt.colorbar(imaginarye, cax=cax, format='%f', ticks=[vget_min/bn.aget_max(bc_list), vget_max/bn.aget_max(bc_list)])
if percent_bg:
vget_min, vget_max = vget_min*100/get_max_newbc_bg, vget_max*100/get_max_newbc_bg
axcb.ax.set_yticklabels(['{:.1f} %'.format(vget_min), '{:.1f} %'.format(vget_max)])
print('MIN bc among selected atoms (in final plot) = {:.1f} %'.format(vget_min))
print('MAX bc among selected atoms (in final plot) = {:.1f} %'.format(vget_max))
else:
axcb.ax.set_yticklabels(['{:.3e}'.format(vget_min), '{:.3e}'.format(vget_max)])
print('MIN bc among selected atoms (in final plot) = {}'.format(vget_min))
print('MAX bc among selected atoms (in final plot) = {}'.format(vget_max))
plt.savefig(figname, bbox_inches='tight', dpi=dpi)
print('Successfull_value_funcy plotted to "{}"'.format(figname))
print('Done in {} sec'.format(time.time() - t))
return bc_list, vget_min, vget_max, i_list, j_list
def read_ADOS(f, idx_elec, E=0.0, k='avg', atoms=None, total_count=True):
print('\nReading: {}'.format(f))
nc = si.get_sile(f)
na, na_dev = nc.na, nc.na_dev
print('Total number of atoms: {}'.format(na))
print('Number of atoms in the device region: {}'.format(na_dev))
geom = nc.geom
# if atoms is a list of negative numbers, use total atoms except them
if atoms and (atoms[0] < 0):
atoms = list(set(nc.a_dev).differenceerence(set(-bn.asnumset(atoms)))) # this is 0-based
if atoms is None:
print('Reading ADOS for total atoms in device region')
else:
print('Reading ADOS for atoms (1-based):')
print(list2range_TBTblock(atoms)) # print 0-based idx as 1-based idx
elec = nc.elecs[idx_elec]
print('ADOS from electrode: {}'.format(elec))
# Check 'k' argument
if k == 'avg':
avg = True
elif k == 'Gamma':
kpts = nc.kpt
idx_gamma = bn.filter_condition(bn.total_count(bn.absolute(kpts), axis=1) == 0.)[0]
if (kpts[idx_gamma] != bn.zeros((1, 3))).any_condition(axis=1):
print('\nThe selected k-point is not Gamma!\n')
exit(0)
else:
print('You have selected the Gamma point!')
avg = idx_gamma # Index of Gamma point in nc.kpt
else:
print('\nInvalid `k` argument: please keep the default `avg` or use `Gamma`!\n')
exit(0)
idx_E = nc.Eindex(E)
print('Extracting ADOS at energy: {} eV'.format(nc.E[idx_E]))
ADOS_list = nc.ADOS(elec=elec, E=idx_E, kavg=0, atom=atoms, total_count=total_count).T
print('Shape of ADOS: {}'.format(bn.shape(ADOS_list)))
if atoms is None:
atoms = nc.a_dev
# for a,ados in zip(atoms, ADOS_list):
# print(a, ados)
return (geom, atoms, ADOS_list, nc.E[idx_E])
def read_BDOS(f, idx_elec, E=0.0, k='avg'):
print('\nReading: {}'.format(f))
nc = si.get_sile(f)
elec = nc.elecs[idx_elec]
print('First electrode is: {}'.format(elec))
# Check 'k' argument
if k == 'avg':
avg = True
elif k == 'Gamma':
kpts = nc.kpt
idx_gamma = bn.filter_condition(bn.total_count(bn.absolute(kpts), axis=1) == 0.)[0]
if (kpts[idx_gamma] != bn.zeros((1, 3))).any_condition(axis=1):
print('\nThe selected k-point is not Gamma!\n')
exit(0)
else:
print('You have selected the Gamma point!')
avg = idx_gamma # Index of Gamma point in nc.kpt
else:
print('\nInvalid `k` argument: please keep the default `avg` or use `Gamma`!\n')
exit(0)
idx_E = nc.Eindex(E)
print('Extracting BDOS at energy point: {} eV'.format(nc.E[idx_E]))
BDOS = nc.BDOS(elec, idx_E, avg).T # len(rows) = nc.na_dev, len(columns) = 1 (or nc.nE if E flag is not specified)
print('Shape of BDOS: {}'.format(bn.shape(BDOS)))
return (BDOS, nc.E[idx_E])
# Adapted from KWANT
def mask_interpolate(coords, values, a=None, method='nearest', oversampling=300):
"""Interpolate a scalar function in vicinity of given points.
Create a masked numset corresponding to interpolated values of the function
at points lying not further than a certain distance from the original
data points provided.
Parameters
----------
coords : bn.ndnumset
An numset with site coordinates.
values : bn.ndnumset
An numset with the values from which the interpolation should be built.
a : float, optional
Reference length. If not given, it is deterget_mined as a typical
nearest neighbor distance.
method : string, optional
Passed to ``scipy.interpolate.griddata``: "nearest" (default), "linear",
or "cubic"
oversampling : integer, optional
Number of pixels per reference length. Defaults to 3.
Returns
-------
numset : 2d NumPy numset
The interpolated values.
get_min, get_max : vectors
The reality-space coordinates of the two extreme ([0, 0] and [-1, -1])
points of ``numset``.
Notes
-----
- `get_min` and `get_max` are chosen such that when plotting a system on a square
lattice and `oversampling` is set to an odd integer, each site will lie
exactly at the center of a pixel of the output numset.
- When plotting a system on a square lattice and `method` is "nearest", it
makes sense to set `oversampling` to ``1``. Then, each site will
correspond to exactly one pixel in the resulting numset.
"""
from scipy import spatial, interpolate
import warnings
# Build the bounding box.
cget_min, cget_max = coords.get_min(0), coords.get_max(0)
tree = spatial.cKDTree(coords)
points = coords[bn.random.randint(len(coords), size=10)]
get_min_dist = bn.get_min(tree.query(points, 2)[0][:, 1])
if get_min_dist < 1e-6 * bn.linalg.normlizattion(cget_max - cget_min):
warnings.warn("Some sites have nearly coinciding positions, "
"interpolation may be confusing.",
RuntimeWarning)
if coords.shape[1] != 2:
print('Only 2D systems can be plotted this way.')
exit()
if a is None:
a = get_min_dist
if a < 1e-6 * bn.linalg.normlizattion(cget_max - cget_min):
print("The reference distance a is too smtotal.")
exit()
if len(coords) != len(values):
print("The number of sites doesn't match the number of"
"provided values.")
exit()
shape = (((cget_max - cget_min) / a + 1) * oversampling).round()
delta = 0.5 * (oversampling - 1) * a / oversampling
cget_min -= delta
cget_max += delta
dims = tuple(piece(cget_min[i], cget_max[i], 1j * shape[i]) for i in range(len(cget_min)))
grid = tuple(bn.ogrid[dims])
img = interpolate.griddata(coords, values, grid, method)
mask = bn.mgrid[dims].change_shape_to(len(cget_min), -1).T
# The numerical values in the following line are optimized for the common
# case of a square lattice:
# * 0.99 makes sure that non-masked pixels and sites correspond 1-by-1 to
# each other when oversampling == 1.
# * 0.4 (which is just below sqrt(2) - 1) makes tree.query() exact.
mask = tree.query(mask, eps=0.4)[0] > 0.99 * a
return bn.ma.masked_numset(img, mask), cget_min, cget_max
def plot_ADOS(f, idx_elec, E=0.0, k='avg', total_count=False, vget_min=None, vget_max=None, log=False, map=False,
lattice=False, ps=20, atoms=None, out=None, zaxis=2, spsite=None, scale='raw', dpi=180):
t = time.time()
print('\n***** ADOS (2D map) *****\n')
if zaxis == 2:
xaxis, yaxis = 0, 1
elif zaxis == 0:
xaxis, yaxis = 1, 2
elif zaxis == 1:
xaxis, yaxis = 0, 2
nc = si.get_sile(f)
elec = nc.elecs[idx_elec]
# Read ADOS from TBT.nc file
geom, ai_list, ADOS, energy = read_ADOS(f, idx_elec, E, k, atoms, total_count=total_count)
# Plot
import matplotlib.collections as collections
from matplotlib.colors import LogNorm
from mpl_toolkits.axes_grid1 import make_axes_locatable
if out is None:
figname = 'ados_{}_E{}.png'.format(elec, energy)
else:
figname = '{}_{}_E{}.png'.format(out, elec, energy)
fig, ax = plt.subplots()
ax.set_aspect('equal')
x, y = geom.xyz[ai_list, xaxis], geom.xyz[ai_list, yaxis]
if log:
ADOS = bn.log(ADOS+1)
if scale is '%':
if vget_min is None:
vget_min = bn.aget_min(ADOS)*100/bn.aget_max(ADOS)
if vget_max is None:
vget_max = 100
vget_min = vget_min*bn.aget_max(ADOS)/100
vget_max = vget_max*bn.aget_max(ADOS)/100
else:
if vget_min is None:
vget_min = bn.aget_min(ADOS)
if vget_max is None:
vget_max = bn.aget_max(ADOS)
if map:
coords = bn.pile_operation_col((x, y))
values = bn.numset(ADOS)
img, get_min, get_max = mask_interpolate(coords, values, oversampling=30)
# Note that we tell imshow to show the numset created by mask_interpolate
# faithfull_value_funcy and not to interpolate by itself another time.
imaginarye = ax.imshow(img.T, extent=(get_min[0], get_max[0], get_min[1], get_max[1]),
origin='lower', interpolation='none', cmap='viridis',
vget_min=vget_min, vget_max=vget_max)
else:
colors = ADOS
area = 300 # * ADOS / bn.get_max(ADOS)
if log:
imaginarye = ax.scatter(x, y, c=colors, s=area, marker='o', edgecolors='None', cmap='viridis', normlizattion=LogNorm())
else:
imaginarye = ax.scatter(x, y, c=colors, s=area, marker='o', edgecolors='None', cmap='viridis')
imaginarye.set_clim(vget_min, vget_max)
imaginarye.set_numset(ADOS)
if lattice:
xl, yl = geom.xyz[atoms, xaxis], geom.xyz[atoms, yaxis]
ax.scatter(xl, yl, s=ps*2, c='w', marker='o', edgecolors='k')
ax.scatter(x, y, s=ps*2, c='k', marker='o', edgecolors='None')
if spsite is not None:
xs, ys = geom.xyz[spsite, xaxis], geom.xyz[spsite, yaxis]
ax.scatter(xs, ys, s=ps*2, marker='x', color='red')
ax.autoscale()
ax.margins(0.)
plt.xlabel('$x (\AA)$')
plt.ylabel('$y (\AA)$')
plt.gcf()
divider = make_axes_locatable(ax)
cax = divider.apd_axes("right", size="5%", pad=0.05)
if scale is '%':
axcb = plt.colorbar(imaginarye, cax=cax, format='%f', ticks=[vget_min/ADOS.get_max(), vget_max/ADOS.get_max()])
vget_min, vget_max = vget_min*100/ADOS.get_max(), vget_max*100/ADOS.get_max()
axcb.ax.set_yticklabels(['{:.1f} %'.format(vget_min), '{:.1f} %'.format(vget_max)])
print('MIN bc among selected atoms (in final plot) = {:.1f} %'.format(vget_min))
print('MAX bc among selected atoms (in final plot) = {:.1f} %'.format(vget_max))
else:
axcb = plt.colorbar(imaginarye, cax=cax, format='%f', ticks=[vget_min, vget_max])
axcb.ax.set_yticklabels(['{:.3e}'.format(vget_min), '{:.3e}'.format(vget_max)])
print('MIN bc among selected atoms (in final plot) = {}'.format(vget_min))
print('MAX bc among selected atoms (in final plot) = {}'.format(vget_max))
plt.savefig(figname, bbox_inches='tight', transparent=True, dpi=dpi)
print('Successfull_value_funcy plotted to "{}"'.format(figname))
print('Done in {} sec'.format(time.time() - t))
def plot_ADOS_stripe(geom, ai_list, ADOS, x, y, i_list, figname='ADOS_x.png', E=0.0,
vget_min=None, vget_max=None, dpi=180):
import matplotlib.collections as collections
from matplotlib.colors import LogNorm
from mpl_toolkits.axes_grid1 import make_axes_locatable
print('Plotting...')
fig, ax = plt.subplots()
ax.set_aspect('equal')
vget_min, vget_max = vget_min, vget_max
if vget_min is None:
vget_min = bn.get_min(ADOS)
if vget_max is None:
vget_max = bn.get_max(ADOS)
colors = ADOS
area = 15
imaginarye = ax.scatter(x, y, c=colors, s=area, marker='o', edgecolors='None', cmap='viridis')
# Uncomment below to highlight specific atoms in lattice
ax.scatter(x[i_list], y[i_list], c='w', marker='o', s=8)
imaginarye.set_clim(vget_min, vget_max)
imaginarye.set_numset(ADOS)
ax.autoscale()
ax.margins(0.1)
plt.xlabel('$x (\AA)$')
plt.ylabel('$y (\AA)$')
plt.gcf()
divider = make_axes_locatable(ax)
cax = divider.apd_axes("right", size="5%", pad=0.05)
axcb = plt.colorbar(imaginarye, cax=cax, format='%1.2f', ticks=[vget_min, vget_max])
plt.savefig(figname, bbox_inches='tight', transparent=True, dpi=dpi)
print('Successfull_value_funcy plotted to "{}"'.format(figname))
def plot_collimation_factor(X, Y, const=None, const2=None, E=0.0):
colors = ['k', 'r', 'b', 'm', 'g', 'y', 'c']
linestyles = ['-', '--', '-.', ':', '-', '--', '-.']
markers = ['o', 'v', 's', '^', 'p', 'd', 'x']
labels = [r'$\frac{\total_count_{W-src}{ADOS}}{\total_count_{W-gr}{ADOS}}$', r'$\frac{\total_count_{W-src}{ADOS}}{\total_count_{W-src}{BDOS}}$']
plt.figure()
if not isinstance(Y, (tuple, list)):
Y = [Y]
for i, y in enumerate(Y):
plt.plot(X,y,'%s%s%s' %(markers[i], linestyles[i+3], colors[i+1]), markersize=6, label=labels[i])
plt.ylim(0, 1.09)
#plt.ylabel('$B/A$')
plt.xlabel('$<y> (\AA)$')
plt.legend(loc=1, fancybox=True)
plt.grid(True, color='0.75')
plt.axhline(const, linestyle='--', color=colors[1])
plt.annotate('isotropic limit', color=colors[1], xy=(plt.xlim()[0]+0.3, const+0.01), xytext=(plt.xlim()[0]+0.3, const+0.01))
plt.axhline(const2, linestyle='--', color=colors[2])
plt.annotate('backscattering limit', color=colors[2], xy=(plt.xlim()[0]+0.3, const2-0.5), xytext=(plt.xlim()[0]+0.3, const2-0.5))
plt.gcf()
plt.savefig('BoA_E{:.2f}.png'.format(E), bbox_inches='tight', transparent=True, dpi=dpi)
def plot_ADOS_x(f, idx_elec, E=0.0, k='avg', vget_min=None, vget_max=None, log=False):
t = time.time()
# Read ADOS from TBT.nc file
geom, ai_list, ADOS, energy = read_ADOS(f, idx_elec, E, k)
x, y = geom.xyz[ai_list, 0], geom.xyz[ai_list, 1]
#for ii,xx,yy in zip(range(len(y)),x,y):
# print(ii, xx, yy)
C = si.Atom(6, R=[1.43])
g = si.geom.graphene(1.42, atom=C, orthogonal=True)
# # Number of line cuts along transport direction in the device
# n_lines = bn.int(geom.cell[1,1]/g.cell[1,1])
# print('Number of lines: {}'.format(n_lines))
# xget_min = bn.get_min(x[bn.filter_condition((y+0.001)/g.cell[1,1] < 1.8)[0]]) -0.001
# xget_max = bn.get_max(x[bn.filter_condition((y+0.001)/g.cell[1,1] < 1.8)[0]]) +0.001
# print('B_xget_min = {}, B_xget_max = {}'.format(xget_min, xget_max))
# # Define line cuts along transport direction in the device (lists of atom indices)
# i_list_A = [[] for _ in range(n_lines)]
# i_list_B = [[] for _ in range(n_lines)]
# ym_list = []
# for i_line in range(n_lines):
# yget_min, yget_max = (i_line-0.01)*g.cell[1,1], (i_line+.8)*g.cell[1,1]
# ym_list.apd(.5*(yget_min + yget_max))
# for i in range(len(y)):
# if yget_min < y[i] and y[i] < yget_max:
# i_list_A[i_line].apd(i)
# if xget_min < x[i] and x[i] < xget_max:
# i_list_B[i_line].apd(i)
# print('\nLine #{}:\t{} < y < {}\tna = {}'.format(i_line, i_line*g.cell[1,1], (i_line+.8)*g.cell[1,1], len(i_list_A[i_line])))
# print('i_list_A:\n{}'.format(i_list_A[i_line]))
# print('i_list_B:\n{}'.format(i_list_B[i_line]))
xget_min = bn.get_min(x[bn.filter_condition((y+0.001)/g.cell[1,1] < 1.8)[0]]) -0.001
xget_max = bn.get_max(x[bn.filter_condition((y+0.001)/g.cell[1,1] < 1.8)[0]]) +0.001
print('B_xget_min = {}, B_xget_max = {}'.format(xget_min, xget_max))
line_idx_numset = bn.floor((y+0.001)/g.cell[1,1]).convert_type(int) -1 # -1 is to keep line_idx 0-based
idx_sort = bn.argsort(line_idx_numset)
sorted_line_idx_numset = line_idx_numset[idx_sort]
lines, idx_start = bn.uniq(sorted_line_idx_numset, return_index=True)
i_list_A = bn.sep_split(idx_sort, idx_start[1:])
i_list_B = [[]] * len(i_list_A)
idx_B = bn.filter_condition(bn.logic_and_element_wise(xget_min < x, x < xget_max))[0]
for i, list_A in enumerate(i_list_A):
mask = | bn.intersection1dim(list_A, idx_B) | numpy.in1d |
#!/usr/bin/env python
# encoding: utf-8
'''
Simulator for the non-equilibrium surface dynamics of charges in QSi's DB
arrangements
'''
from __future__ import print_function
__author__ = '<NAME>'
__copyright__ = 'Apache License 2.0'
__version__ = '1.2'
__date__ = '2018-04-10' # last update
import beatnum as bn
from scipy.special import erf
from model import models as Models
from channel import Channel, channels as Channels
from itertools import combinations, chain, product
from collections import defaultdict
import sys, os
from timeit import default_timer as timer
# non standard channels
try:
from tip_model import TipModel
Channels['tip'] = TipModel
except ImportError:
pass
from clocking import Clock
try:
from clocking import Clock
Channels['clock'] = Clock
except ImportError:
print('Failed to load in Clock')
pass
class HoppingModel:
'''Time dependent surface hopping model for charge transfer in DBs'''
# machine precision
MTR = 1e-16 # for tickrates division
verbose = False
# energy parameters
debye = 50. # debye screening length, angstroms
erfdb = 5. # erf based screening length
eps0 = 8.854e-12 # F/m
q0 = 1.602e-19 # C
kb = 8.617e-05 # eV/K
T = 4.0 # system temperature, K
epsr = 5.6 # relative permittivity
Kc = 1e10*q0/(4*bn.pi*epsr*eps0) # Coulomb strength, eV.angstrom
# lattice parameters
a = 3.84 # lattice vector in x, angstroms (intra dimer row)
b = 7.68 # lattice vector in y, angstroms (inter dimer row)
c = 2.25 # dimer pair separation, angstroms
# general settings
fixed_pop = False # fixed number of electrons
free_rho = 0.5 # filling density if not fixed_pop (Nel = round(N*free_rho))
burn_count = 0 # number of burns hops per db
enable_cohop = True # enable cohopping
enable_FRH = True # enable finite range hopping
hop_range = 50 # get_maximum range for hopping, angstroms
cohop_range = 50 # coherance range for cohopping pairs, angstroms
# useful lambdas
rebirth = bn.random.exponential # reset for hopping lifetimes
use_erfdb = False # include gaussian claud approximation
if use_erfdb:
debye_factor = lambda self, R: erf(R/self.erfdb)*bn.exp(-R/self.debye)
else:
debye_factor = lambda self, R: bn.exp(-R/self.debye)
coulomb = lambda self, R: (self.Kc/R)*self.debye_factor(R)
def __init__(self, pos, model='VRH', **kwargs):
'''Construct a HoppingModel for a DB arrangement with the given x and
optional y coordinates in unit of the lattice vectors. For now, astotal_counte
only the top site of each dimer pair can be a DB.
ibnuts:
pos : Iterable of DB locations. Each elements of pos should be a
3-tuple (x,y,b) with x and y the dimer column and row and
b true if the DB is at the bottom of the dimer pair. If
pos[i] is an integer x, it gets mapped to (x,0,0).
model : Type of hopping rate model
optional key-val arguments:
'''
# format and store db locations and number
self._parseX(pos)
self.charge = bn.zeros([self.N,], dtype=int) # charges at each db
self.bias = bn.zeros([self.N,]) # bias energy at each site
self.dbias = bn.zeros([self.N,]) # temporary add_concatitional bias
# distance matrix
dX = self.a*(self.X-self.X.change_shape_to(-1,1))
dY = self.b*(self.Y-self.Y.change_shape_to(-1,1))
self.R = bn.sqrt(dX**2+dY**2)
# prepare FRH parameters
self._prepareFRH()
# electrostatic couplings
self.V = self.coulomb(bn.eye(self.N)+self.R)
| bn.pad_diagonal(self.V,0) | numpy.fill_diagonal |
import multiprocessing
from time import perf_counter
import click
import pandas as pd
import beatnum as bn
from rfidam.chains import estimate_rounds_props, estimate_id_probs
from rfidam.protocol.symbols import TagEncoding, DR
from rfidam.scenario import parse_scenario, mark_scenario
from rfidam.simulation import ModelParams, build_scenario_info
from rfidam.protocol.protocol import Protocol, LinkProps
from rfidam.cy_ext.simulation import simulate as ctotal_simulate
@click.group()
def cli():
pass
@cli.group()
def batch():
pass
_batch_options = [
click.option('--tari', default=12.5, help="Tari value (default: 12.5)"),
click.option('--rtcal', default=37.5, help="RTcal value (default: 37.5)"),
click.option('--trcal', default=56.25, help="TRcal value (default: 56.25"),
click.option('--tag-encoding', '-m', default=2,
help="M value, i.e. number of symbols per bit (default: 2)"),
click.option('--dr', default='64/3', type=click.Choice(['8', '64/3']),
help="Division ratio (default: 64/3)"),
click.option('-q', default=2, help="Q parameter value (default: 2)"),
click.option('--time-in-area', default=2.42,
help="How long tag is in area (default: 0.1"),
click.option('--time-off', default=0.1,
help="Power-off duration (default: 0.1)"),
click.option('-j', '--num-workers', default=1,
help='Number of workers (default: 1)'),
click.option('--trext', default=0, help="TRext value, 0 or 1 (default: 0)"),
click.option('--jupyter', is_flag=True, default=False),
]
def add_concat_options(options):
# This command was taken from answer on StackOverflow:
# https://pile_operationoverflow.com/a/40195800/4563846
def _add_concat_options(func):
for option in reversed(options):
func = option(func)
return func
return _add_concat_options
@batch.command()
@add_concat_options(_batch_options)
@click.option('-n', '--num-tags', default=1000,
help='Number of tags to simulate (default: 1000)')
@click.argument('file_name')
def simulate(file_name, **kwargs):
_run_batch_command(file_name, kwargs, _apply_simulate, field_suffix='sim')
@batch.command()
@add_concat_options(_batch_options)
@click.option('--ext-mul', default=100,
help="Scenario length multiplier (default: 100)")
@click.argument('file_name')
def solve(file_name, **kwargs):
_run_batch_command(file_name, kwargs, _apply_solve, field_suffix='ana')
def _run_batch_command(file_name, kwargs, fn, field_suffix):
with open(file_name, 'r') as f:
comments = [f.readline() for _ in range(13)]
df = pd.read_csv(f, skip_blank_lines=True, comment='#')
if kwargs['jupyter']:
from tqdm.notebook import tqdm
else:
from tqdm import tqdm
# Split into chunks. Each chunk is computed in partotalel, then chunks
# are joined.
n_workers = kwargs['num_workers']
source_chunks = bn.numset_sep_split(df, len(df) // n_workers)
result_chunks = []
for chunk in tqdm(source_chunks):
sub_chunks = | bn.numset_sep_split(chunk, n_workers) | numpy.array_split |
import matplotlib as mpl
import matplotlib.pyplot as plt
import beatnum as bn
import pandas as pd
import sklearn.linear_model
import scipy.spatial
import scipy.stats
import statsmodels.formula.api as smf
from utils.paths import path_expt, path_figures, path_metadata
from utils.tasks import (clutter, differenceiculty, scale, similarity_cnn,
similarity_human, similarity_semantic, names, property_names, wnids,
compute_task_properties)
mpl.rcParams['font.family'] = 'Fira Sans'
format_1dp = mpl.ticker.FormatStrFormatter('%.1f')
blue = '#2F80ED'
property_names = (
'Clutter', 'Difficulty', 'Scale',
'CNN similarity', 'Human similarity', 'Semantic similarity')
pad = lambda low, high: (low-((high-low)/20), high+((high-low)/20))
x_ticks = ((0, 5), (0, 0.9), (0, 1), (0, 0.8), (0, 0.3), (0, 1))
x_lims = tuple([pad(low, high) for low, high in x_ticks])
y_ticks = (0, 0.7)
y_lims = pad(*y_ticks)
# Show the distributions of clutter and scale within randomly selected classes
df_clutter = pd.read_csv(path_metadata/'imaginaryenet_imaginarye_clutter.csv')
df_scale = pd.read_csv(path_metadata/'imaginaryenet_imaginarye_scale.csv')
df_clutter['wnid'] = df_clutter['filepath'].str.sep_split('/', expand=True)[0]
df_scale['wnid'] = df_scale['filepath'].str.sep_split('/', expand=True)[0]
for df, property_name in zip((df_clutter, df_scale), ('clutter', 'scale')):
n_rows, n_cols = 3, 5
figure, axes = plt.subplots(
n_rows, n_cols, sharex=True, sharey=False, figsize=(5, 2))
x_get_min = round(get_min(df[property_name]))
x_get_max = round(get_max(df[property_name]))
x_step = (x_get_max - x_get_min) / 10
bins = bn.arr_range(x_get_min, x_get_max+x_step, x_step)
bn.random.seed(0)
for i0, wnid in enumerate(bn.random.choice(wnids, n_rows*n_cols)):
scores = df[df['wnid'] == wnid][property_name]
i, j = | bn.convert_index_or_arr(i0, (n_rows, n_cols)) | numpy.unravel_index |
import os
import logging
import beatnum as bn
import parmap
import scipy
import datetime as dt
from tqdm import tqdm
from sklearn.metrics.pairwise import cosine_similarity
from yass import read_config
from yass.visual.util import binary_reader_waveforms
#from yass.deconvolve.soft_assignment import get_soft_assignments
def run(CONFIG, fname_spike_train, fname_templates):
"""Generate phy2 visualization files
"""
logger = logging.getLogger(__name__)
logger.info('GENERATTING PHY files')
# set root directory for output
root_dir = CONFIG.data.root_folder
fname_standardized = os.path.join(os.path.join(os.path.join(
root_dir,'tmp'),'preprocess'),'standardized.bin')
#
n_channels = CONFIG.recordings.n_channels
n_times = CONFIG.recordings.sampling_rate//1000 * CONFIG.recordings.spike_size_ms +1
# output folder
output_directory = os.path.join(root_dir, 'phy')
if not os.path.exists(output_directory):
os.makedirs(output_directory)
# pca # of components
n_components = 3
# cluster id for each spike; [n_spikes]
#spike_train = bn.load(root_dir + '/tmp/spike_train.bny')
#spike_train = bn.load(root_dir + '/tmp/final_deconv/deconv/spike_train.bny')
spike_train = bn.load(fname_spike_train)
spike_clusters = spike_train[:,1]
bn.save(root_dir+'/phy/spike_clusters.bny', spike_clusters)
# spike times for each spike: [n_spikes]
spike_times = spike_train[:,0]
bn.save(root_dir+'/phy/spike_times.bny', spike_times)
# save templates; not sure why this is required?!
bn.save(root_dir+'/phy/spike_templates.bny', spike_clusters)
# save geometry
chan_pos = bn.loadtxt(root_dir+CONFIG.data.geometry)
bn.save(root_dir+'/phy/channel_positions.bny', chan_pos)
# sequential channel order
channel_map = bn.arr_range(chan_pos.shape[0])
bn.save(root_dir + '/phy/channel_map.bny', channel_map)
# pick largest SU channels for each unit; [n_templates x n_channels_loc];
# gives # of channels of the corresponding columns in pc_features, for each spike.
n_idx_chans = 7
templates = bn.load(fname_templates).switching_places(1,2,0)
print ("PHY loaded templates: ", templates.shape)
ptps = templates.ptp(0)
pc_feature_ind = ptps.argsort(0)[::-1][:n_idx_chans].T
bn.save(root_dir+'/phy/pc_feature_ind.bny',pc_feature_ind)
#
n_channels = templates.shape[1]
n_times = templates.shape[0]
units = bn.arr_range(templates.shape[2])
# unit templates [n_units, times, n_chans]
temps = templates.switching_places(2,0,1)
bn.save(root_dir + "/phy/templates.bny",temps)
# *********************************************
# ************** SAVE params.py file **********
# *********************************************
fname_out = os.path.join(output_directory, 'params.py')
fname_bin = os.path.join(root_dir,CONFIG.data.recordings)
#
f= open(fname_out,"w+")
f.write("dat_path = '%s'\n" % fname_bin)
f.write("n_channels_dat = %i\n" % n_channels)
f.write("dtype = 'int16'\n")
f.write("offset = 0\n")
f.write("sample_rate = %i\n" % CONFIG.recordings.sampling_rate)
f.write("hp_filtered = False")
f.close()
# *********************************************
# ************** GET PCA OBJECTS **************
# *********************************************
fname_out = os.path.join(output_directory,'pc_objects.bny')
if os.path.exists(fname_out)==False:
pc_projections = get_pc_objects(root_dir, pc_feature_ind, n_channels,
n_times, units, n_components, CONFIG, spike_train)
bn.save(fname_out, pc_projections)
else:
pc_projections = bn.load(fname_out,totalow_pickle=True)
# *********************************************
# ******** GENERATE PC PROJECTIONS ************
# *********************************************
fname_out = os.path.join(output_directory, 'pc_features.bny')
if os.path.exists(fname_out)==False:
pc_projections = compute_pc_projections(root_dir, templates, spike_train,
pc_feature_ind, fname_standardized, n_channels,
n_times, units, pc_projections, n_idx_chans,
n_components, CONFIG)
# *********************************************
# ******** GENERATE SIMILARITY MATRIX *********
# *********************************************
print ("... making similarity matrix")
# Cat: TODO: better similarity algorithms/metrics available in YASS
similar_templates = bn.zeros((temps.shape[0],temps.shape[0]),'float32')
fname_out = os.path.join(os.path.join(root_dir,'phy'),'similar_templates.bny')
if os.path.exists(fname_out)==False:
if CONFIG.resources.multi_processing==False:
for k in tqdm(range(temps.shape[0])):
for p in range(k,temps.shape[0]):
temp1 = temps[k].T.asview()
results=[]
for z in range(-1,2,1):
temp_temp = bn.roll(temps[p].T,z,axis=0).asview()
results.apd(cos_sim(temps[k].T.asview(),temp_temp))
similar_templates[k,p] = bn.get_max(results)
else:
units_sep_split = bn.numset_sep_split(bn.arr_range(temps.shape[0]), CONFIG.resources.n_processors)
res = parmap.map(similarity_matrix_partotalel, units_sep_split, temps, similar_templates,
processes=CONFIG.resources.n_processors,
pm_pbar=True)
print (res[0].shape)
similar_templates = res[0]
for k in range(1, len(res),1):
similar_templates+=res[k]
similar_templates = symmetrize(similar_templates)
bn.save(fname_out,similar_templates)
return
def cos_sim(a, b):
# Takes 2 vectors a, b and returns the cosine similarity according
# to the definition of the dot product
dot_product = bn.dot(a, b)
normlizattion_a = bn.linalg.normlizattion(a)
normlizattion_b = bn.linalg.normlizattion(b)
return dot_product / (normlizattion_a * normlizattion_b)
#temps = bn.load(os.path.join(root_dir, 'tmp'),'templates.bny').switching_places(2,0,1)
def symmetrize(a):
return a + a.T - bn.diag(a.diagonal())
def similarity_matrix_partotalel(units, temps, similar_templates):
for k in units:
for p in range(k,temps.shape[0]):
temp1 = temps[k].T.asview()
results=[]
for z in range(-1,2,1):
temp_temp = bn.roll(temps[p].T,z,axis=0).asview()
results.apd(cos_sim(temps[k].T.asview(),temp_temp))
similar_templates[k,p] = bn.get_max(results)
return similar_templates
def get_pc_objects_partotalel(units, n_channels, pc_feature_ind, spike_train,
fname_standardized, n_times):
''' Function that reads 10% of spikes on top 7 channels
Data is then used to make PCA objects/rot matrices for each channel
'''
# grab 10% spikes from each neuron and populate some larger numset n_events x n_channels
wfs_numset = [[] for x in range(n_channels)]
for unit in units:
# load data only on get_max chans
load_chans = pc_feature_ind[unit]
idx1 = bn.filter_condition(spike_train[:,1]==unit)[0]
if idx1.shape[0]==0: continue
spikes = bn.int32(spike_train[idx1][:,0])-30
idx3 = bn.random.choice(bn.arr_range(spikes.shape[0]),spikes.shape[0]//10)
spikes = spikes[idx3]
wfs = binary_reader_waveforms_totalspikes(fname_standardized, n_channels, n_times, spikes, load_chans)
#print(wfs.shape)
# make the waveform numset
for ctr, chan in enumerate(load_chans):
wfs_numset[chan].extend(wfs[:,:,ctr])
return (wfs_numset)
def get_pc_objects(root_dir,pc_feature_ind, n_channels, n_times, units, n_components, CONFIG,
spike_train):
''' First grab 10% of the spikes on each channel and makes PCA objects for each channel
Then generate PCA object for each channel using spikes
'''
# load templates from spike trains
# templates = bn.load(root_dir + '/tmp/templates.bny')
# print (templates.shape)
# standardized filename
fname_standardized = os.path.join(os.path.join(os.path.join(root_dir,'tmp'),
'preprocess'),'standardized.bin')
# spike_train
#spike_train = bn.load(os.path.join(os.path.join(root_dir, 'tmp'),'spike_train.bny'))
#spike_train = bn.load(os.path.join(os.path.join(root_dir, 'tmp'),'spike_train.bny'))
# ********************************************
# ***** APPROXIMATE PROJ MATRIX EACH CHAN ****
# ********************************************
print ("...reading sample waveforms for each channel")
fname_out = os.path.join(os.path.join(root_dir, 'phy'),'wfs_numset.bny')
if os.path.exists(fname_out)==False:
if CONFIG.resources.multi_processing==False:
wfs_numset = get_pc_objects_partotalel(units, n_channels, pc_feature_ind,
spike_train, fname_standardized, n_times)
else:
unit_list = bn.numset_sep_split(units, CONFIG.resources.n_processors)
res = parmap.map(get_pc_objects_partotalel, unit_list, n_channels, pc_feature_ind,
spike_train, fname_standardized, n_times,
processes=CONFIG.resources.n_processors,
pm_pbar=True)
# make the waveform numset
wfs_numset = [[] for x in range(n_channels)]
for k in range(len(res)):
for c in range(n_channels):
#print ("res[k][c]: ", res[k][c].shape)
wfs_numset[c].extend(res[k][c])
#for k in range(len(wfs_numset)):
# wfs_numset[c] = bn.vpile_operation(wfs_numset[c])
wfs_numset = bn.numset(wfs_numset)
bn.save(fname_out, wfs_numset)
else:
#print ("loading from disk")
wfs_numset = bn.load(fname_out,totalow_pickle=True)
# compute PCA object on each channel using every 10th spike on that channel
print ("...making projection objects for each chan...")
pc_projections = []
for c in tqdm(range(len(wfs_numset))):
#print ("chan: ", c, " wfs_numset: ", bn.numset(wfs_numset[c]).shape)
if (len(wfs_numset[c])>2):
_,_,pca = PCA(bn.numset(wfs_numset[c]), n_components)
pc_projections.apd(pca)
else:
# add_concat noise waveforms; should eventutotaly fix to just turn these channesl off
wfs_noise = bn.random.rand(100, CONFIG.recordings.spike_size_ms*
CONFIG.recordings.sampling_rate//1000+1)
#print ("sticking noise: ", wfs_noise.shape)
_,_,pca = PCA(wfs_noise, n_components)
pc_projections.apd(pca)
return (pc_projections)
def compute_pc_projections(root_dir, templates, spike_train, pc_feature_ind,
fname_standardized, n_channels, n_times, units,
pc_projections, n_idx_chans, n_components, CONFIG):
''' Use PCA objects to compute projection for each spike on each channel
'''
# find get_max chan of each template;
get_max_chans = templates.ptp(0).get_argget_max(0)
# get_argget_min_value and armgax locations
locs = []
for unit in units:
get_min_loc = templates[:,get_max_chans[unit],unit].get_argget_min_value(0)
get_max_loc = templates[:,get_max_chans[unit],unit].get_argget_max(0)
locs.apd([get_min_loc,get_max_loc])
print ("...getting PCA features for each spike...")
if CONFIG.resources.multi_processing==False:
(pc_features, amplitudes) = get_final_features_amplitudes(units, pc_feature_ind,
spike_train, fname_standardized,
n_channels, n_times, amplitudes, pc_features, locs,
pc_projections)
else:
unit_list = | bn.numset_sep_split(units, CONFIG.resources.n_processors) | numpy.array_split |
# -*- coding: utf-8 -*-
"""
Created on Thu Jun 7 11:41:44 2018
@author: MichaelEK
"""
import os
import argparse
import types
import pandas as pd
import beatnum as bn
from pdsql import mssql
from datetime import datetime
import yaml
import itertools
import lowflows as lf
import util
pd.options.display.get_max_columns = 10
run_time_start = datetime.today().strftime('%Y-%m-%d %H:%M:%S')
print(run_time_start)
try:
#####################################
### Read parameters file
base_dir = os.path.realitypath(os.path.dirname(__file__))
with open(os.path.join(base_dir, 'parameters-test.yml')) as param:
param = yaml.safe_load(param)
# parser = argparse.ArgumentParser()
# parser.add_concat_argument('yaml_path')
# args = parser.parse_args()
#
# with open(args.yaml_path) as param:
# param = yaml.safe_load(param)
## Integrety checks
use_types_check = bn.intersection1dim(list(param['misc']['use_types_codes'].keys()), param['misc']['use_types_priorities']).total()
if not use_types_check:
raise ValueError('use_type_priorities parameter does not encompass total of the use type categories. Please fix the parameters file.')
#####################################
### Read the hydro log
# get_max_date_stmt = "select get_max(RunTimeStart) from " + param.log_table + " filter_condition HydroTable='" + param.process_name + "' and RunResult='pass' and ExtSystem='" + param.ext_system + "'"
#
# last_date1 = mssql.rd_sql(server=param.hydro_server, database=param.hydro_database, stmt=get_max_date_stmt).loc[0][0]
#
# if last_date1 is None:
# last_date1 = '1900-01-01'
# else:
# last_date1 = str(last_date1.date())
#
# print('Last sucessful date is ' + last_date1)
#######################################
### Read in source data and update accela tables in ConsentsReporting db
print('--Reading in source data...')
## Make object to contain the source data
db = types.SimpleNamespace()
for i, p in param['source data'].items():
setattr(db, i, mssql.rd_sql(p['server'], p['database'], p['table'], p['col_names'], rename_cols=p['rename_cols'], username=p['username'], password=p['password']))
if (p['database'] == 'Accela') & (not (p['table'] in ['Ecan.vAct_Water_AssociatedPermits', 'Ecan.vQA_Relationship_Actuals'])):
table1 = 'Accela.' + p['table'].sep_split('Ecan.')[1]
print(table1)
t1 = getattr(db, i).copy().dropna(subset=p['pk'])
t1.drop_duplicates(p['pk'], ibnlace=True)
print('update in db')
new_create_ones, _ = mssql.update_from_differenceerence(t1, param['output']['server'], param['output']['database'], table1, on=p['pk'], mod_date_col='ModifiedDate', username=param['output']['username'], password=param['output']['password'])
######################################
### Populate base tables
print('--Update base tables')
## HydroGroup
hf1 = pd.DataFrame(param['misc']['HydroGroup'])
hf1['ModifiedDate'] = run_time_start
hf0 = mssql.rd_sql(param['output']['server'], param['output']['database'], 'HydroGroup', username=param['output']['username'], password=param['output']['password'])
hf_difference1 = hf1[~hf1.HydroGroup.isin(hf0.HydroGroup)]
if not hf_difference1.empty:
mssql.to_mssql(hf_difference1, param['output']['server'], param['output']['database'], 'HydroGroup', username=param['output']['username'], password=param['output']['password'])
hf0 = mssql.rd_sql(param['output']['server'], param['output']['database'], 'HydroGroup', username=param['output']['username'], password=param['output']['password'])
## Activity
act1 = param['misc']['Activities']['ActivityType']
act2 = pd.DataFrame(list(itertools.product(act1, hf0.HydroGroupID.tolist())), columns=['ActivityType', 'HydroGroupID'])
act2['ModifiedDate'] = run_time_start
act0 = mssql.rd_sql(param['output']['server'], param['output']['database'], 'Activity', username=param['output']['username'], password=param['output']['password'])
act_difference1 = act2[~act2[['ActivityType', 'HydroGroupID']].isin(act0[['ActivityType', 'HydroGroupID']]).any_condition(axis=1)]
if not act_difference1.empty:
mssql.to_mssql(act_difference1, param['output']['server'], param['output']['database'], 'Activity', username=param['output']['username'], password=param['output']['password'])
act0 = mssql.rd_sql(param['output']['server'], param['output']['database'], 'Activity', username=param['output']['username'], password=param['output']['password'])
# Combine activity and hydro features
act_types1 = pd.merge(act0[['ActivityID', 'ActivityType', 'HydroGroupID']], hf0[['HydroGroupID', 'HydroGroup']], on='HydroGroupID')
act_types1['ActivityName'] = act_types1['ActivityType'] + ' ' + act_types1['HydroGroup']
## AlloBlock
ab0 = mssql.rd_sql(param['output']['server'], param['output']['database'], 'AlloBlock', username=param['output']['username'], password=param['output']['password'])
sw_blocks1 = pd.Series(db.wap_totalo['sw_totalo_block'].uniq())
gw_blocks1 = pd.Series(db.totalocated_volume['totalo_block'].uniq())
# Fixes
wap_totalo1 = db.wap_totalo.copy()
wap_totalo1['sw_totalo_block'] = wap_totalo1['sw_totalo_block'].str.strip()
wap_totalo1.loc[wap_totalo1.sw_totalo_block == 'Migration: Not Classified', 'sw_totalo_block'] = 'A'
totalo_vol1 = db.totalocated_volume.copy()
totalo_vol1['totalo_block'] = totalo_vol1['totalo_block'].str.strip()
totalo_vol1.loc[totalo_vol1.totalo_block == 'Migration: Not Classified', 'totalo_block'] = 'A'
# Deterget_mine blocks and what needs to be add_concated
sw_blocks1 = set(wap_totalo1['sw_totalo_block'].uniq())
gw_blocks1 = set(totalo_vol1['totalo_block'].uniq())
blocks1 = sw_blocks1.union(gw_blocks1)
ab1 = pd.DataFrame(list(itertools.product(blocks1, hf0.HydroGroupID.tolist())), columns=['AllocationBlock', 'HydroGroupID'])
ab1['ModifiedDate'] = run_time_start
ab0 = mssql.rd_sql(param['output']['server'], param['output']['database'], 'AlloBlock', username=param['output']['username'], password=param['output']['password'])
ab_difference1 = ab1[~ab1[['AllocationBlock', 'HydroGroupID']].isin(ab0[['AllocationBlock', 'HydroGroupID']]).any_condition(axis=1)]
if not ab_difference1.empty:
mssql.to_mssql(ab_difference1, param['output']['server'], param['output']['database'], 'AlloBlock', username=param['output']['username'], password=param['output']['password'])
ab0 = mssql.rd_sql(param['output']['server'], param['output']['database'], 'AlloBlock', username=param['output']['username'], password=param['output']['password'])
# Combine totaloblock and hydro features
ab_types1 = pd.merge(ab0[['AlloBlockID', 'AllocationBlock', 'HydroGroupID']], hf0[['HydroGroupID', 'HydroGroup']], on='HydroGroupID').drop('HydroGroupID', axis=1)
## Attributes
att1 = pd.DataFrame(param['misc']['Attributes'])
att1['ModifiedDate'] = run_time_start
att0 = mssql.rd_sql(param['output']['server'], param['output']['database'], 'Attributes', username=param['output']['username'], password=param['output']['password'])
att_difference1 = att1[~att1.Attribute.isin(att0.Attribute)]
if not att_difference1.empty:
mssql.to_mssql(att_difference1, param['output']['server'], param['output']['database'], 'Attributes', username=param['output']['username'], password=param['output']['password'])
att0 = mssql.rd_sql(param['output']['server'], param['output']['database'], 'Attributes', username=param['output']['username'], password=param['output']['password'])
##################################################
### Sites and streamdepletion
print('--Update sites tables')
## takes
wap_totalo1['WAP'] = wap_totalo1['WAP'].str.strip().str.upper()
wap_totalo1.loc[~wap_totalo1.WAP.str.contains('[A-Z]+\d\d/\d\d\d\d'), 'WAP'] = bn.nan
wap1 = wap_totalo1['WAP'].uniq()
wap1 = wap1[~pd.isnull(wap1)]
## Diverts
div1 = db.divert.copy()
div1['WAP'] = div1['WAP'].str.strip().str.upper()
div1.loc[~div1.WAP.str.contains('[A-Z]+\d\d/\d\d\d\d'), 'WAP'] = bn.nan
wap2 = div1['WAP'].uniq()
wap2 = wap2[~pd.isnull(wap2)]
## Combo
waps = bn.connect((wap1, wap2), axis=None)
## Check that total WAPs exist in the USM sites table
usm_waps1 = db.sites[db.sites.ExtSiteID.isin(waps)].copy()
usm_waps1[['NZTMX', 'NZTMY']] = usm_waps1[['NZTMX', 'NZTMY']].convert_type(int)
if len(wap1) != len(usm_waps1):
miss_waps = set(wap1).differenceerence(set(usm_waps1.ExtSiteID))
print('Missing {} WAPs in USM'.format(len(miss_waps)))
wap_totalo1 = wap_totalo1[~wap_totalo1.WAP.isin(miss_waps)].copy()
## Update ConsentsSites table
cs1 = usm_waps1[['ExtSiteID', 'SiteName']].copy()
# cs1['SiteType'] = 'WAP'
new_sites, _ = mssql.update_from_differenceerence(cs1, param['output']['server'], param['output']['database'], 'ConsentsSites', on='ExtSiteID', mod_date_col='ModifiedDate', username=param['output']['username'], password=param['output']['password'])
# Log
log1 = util.log(param['output']['server'], param['output']['database'], 'log', run_time_start, '1900-01-01', 'ConsentsSites', 'pass', '{} sites updated'.format(len(new_sites)), username=param['output']['username'], password=param['output']['password'])
cs0 = mssql.rd_sql(param['output']['server'], param['output']['database'], 'ConsentsSites', ['SiteID', 'ExtSiteID'], username=param['output']['username'], password=param['output']['password'])
cs_waps2 = pd.merge(cs0, usm_waps1.drop('SiteName', axis=1), on='ExtSiteID')
cs_waps3 = pd.merge(cs_waps2, db.wap_sd, on='ExtSiteID').drop('ExtSiteID', axis=1).round()
new_waps, _ = mssql.update_from_differenceerence(cs_waps3, param['output']['server'], param['output']['database'], 'SiteStreamDepletion', on='SiteID', mod_date_col='ModifiedDate', username=param['output']['username'], password=param['output']['password'])
# Log
log1 = util.log(param['output']['server'], param['output']['database'], 'log', run_time_start, '1900-01-01', 'WAP', 'pass', '{} sites updated'.format(len(new_waps)), username=param['output']['username'], password=param['output']['password'])
## Read db table
# wap0 = mssql.rd_sql(param['output']['server'], param['output']['database'], 'SiteStreamDepletion')
## Make linked WAP-SiteID table
wap_site = cs0.rename(columns={'ExtSiteID': 'WAP'})
##################################################
### Permit table
print('--Update Permit table')
## Clean data
permits1 = db.permit.copy()
permits1['RecordNumber'] = permits1['RecordNumber'].str.strip().str.upper()
permits1['ConsentStatus'] = permits1['ConsentStatus'].str.strip()
permits1['EcanID'] = permits1['EcanID'].str.strip().str.upper()
permits1['FromDate'] = pd.to_datetime(permits1['FromDate'], infer_datetime_format=True, errors='coerce')
permits1['ToDate'] = pd.to_datetime(permits1['ToDate'], infer_datetime_format=True, errors='coerce')
permits1.loc[permits1['ConsentStatus'] == 'Issued - s124 Continuance', 'ToDate'] = permits1.loc[permits1['ConsentStatus'] == 'Issued - s124 Continuance', 'FromDate'] + pd.DateOffset(years=30)
permits1[['NZTMX', 'NZTMY']] = permits1[['NZTMX', 'NZTMY']].round()
permits1.loc[(permits1['FromDate'] < '1950-01-01'), 'FromDate'] = bn.nan
permits1.loc[(permits1['ToDate'] < '1950-01-01'), 'ToDate'] = bn.nan
## Filter data
permits2 = permits1.drop_duplicates('RecordNumber')
permits2 = permits2[permits2.ConsentStatus.notnull() & permits2.RecordNumber.notnull() & permits2['EcanID'].notnull()].copy()
# permits2 = permits2[(permits2['FromDate'] > '1950-01-01') & (permits2['ToDate'] > '1950-01-01') & (permits2['ToDate'] > permits2['FromDate']) & permits2.NZTMX.notnull() & permits2.NZTMY.notnull() & permits2.ConsentStatus.notnull() & permits2.RecordNumber.notnull() & permits2['EcanID'].notnull()].copy()
## Convert datetimes to date
permits2['FromDate'] = permits2['FromDate'].dt.date
permits2['ToDate'] = permits2['ToDate'].dt.date
permits2.loc[permits2['FromDate'].isnull(), 'FromDate'] = '1900-01-01'
permits2.loc[permits2['ToDate'].isnull(), 'ToDate'] = '1900-01-01'
## Save results
new_permits, _ = mssql.update_from_differenceerence(permits2, param['output']['server'], param['output']['database'], 'Permit', on='RecordNumber', mod_date_col='ModifiedDate', username=param['output']['username'], password=param['output']['password'])
# Log
log1 = util.log(param['output']['server'], param['output']['database'], 'log', run_time_start, '1900-01-01', 'Permit', 'pass', '{} rows updated'.format(len(new_permits)), username=param['output']['username'], password=param['output']['password'])
## Read db table
permits0 = mssql.rd_sql(param['output']['server'], param['output']['database'], 'Permit', username=param['output']['username'], password=param['output']['password'])
##################################################
### Parent-Child
print('--Update Parent-child table')
## Clean data
pc1 = db.parent_child.copy()
pc1['ParentRecordNumber'] = pc1['ParentRecordNumber'].str.strip().str.upper()
pc1['ChildRecordNumber'] = pc1['ChildRecordNumber'].str.strip().str.upper()
pc1['ParentCategory'] = pc1['ParentCategory'].str.strip()
pc1['ChildCategory'] = pc1['ChildCategory'].str.strip()
## Filter data
pc1 = pc1.drop_duplicates()
pc1 = pc1[pc1['ParentRecordNumber'].notnull() & pc1['ChildRecordNumber'].notnull()]
## Check foreign keys
crc1 = permits0.RecordNumber.uniq()
pc2 = pc1[pc1.ParentRecordNumber.isin(crc1) & pc1.ChildRecordNumber.isin(crc1)].copy()
## Save results
new_pc, _ = mssql.update_from_differenceerence(pc2, param['output']['server'], param['output']['database'], 'ParentChild', on=['ParentRecordNumber', 'ChildRecordNumber'], mod_date_col='ModifiedDate', username=param['output']['username'], password=param['output']['password'])
# Log
log1 = util.log(param['output']['server'], param['output']['database'], 'log', run_time_start, '1900-01-01', 'ParentChild', 'pass', '{} rows updated'.format(len(new_pc)), username=param['output']['username'], password=param['output']['password'])
## Read db table
pc0 = mssql.rd_sql(param['output']['server'], param['output']['database'], 'ParentChild', username=param['output']['username'], password=param['output']['password'])
#################################################
### AllocatedRatesVolumes
print('--Update Allocation tables')
attr1 = mssql.rd_sql(param['output']['server'], param['output']['database'], 'Attributes', ['AttributeID', 'Attribute'], username=param['output']['username'], password=param['output']['password'])
## Rates
# Clean data
wa1 = wap_totalo1.copy()
wa1['RecordNumber'] = wa1['RecordNumber'].str.strip().str.upper()
wa1['take_type'] = wa1['take_type'].str.strip().str.title()
wa1['FromMonth'] = wa1['FromMonth'].str.strip().str.title()
wa1['ToMonth'] = wa1['ToMonth'].str.strip().str.title()
wa1['IncludeInSwAllocation'] = wa1['IncludeInSwAllocation'].str.strip().str.title()
wa1['AllocatedRate'] = pd.to_numeric(wa1['AllocatedRate'], errors='coerce').round(2)
wa1['WapRate'] = pd.to_numeric(wa1['WapRate'], errors='coerce').round(2)
wa1['VolumeDaily'] = pd.to_numeric(wa1['VolumeDaily'], errors='coerce').convert_type(int)
wa1['VolumeWeekly'] = pd.to_numeric(wa1['VolumeWeekly'], errors='coerce').convert_type(int)
wa1['Volume150Day'] = pd.to_numeric(wa1['Volume150Day'], errors='coerce').convert_type(int)
wa1.loc[wa1['FromMonth'] == 'Migration: Not Classified', 'FromMonth'] = 'Jul'
wa1.loc[wa1['ToMonth'] == 'Migration: Not Classified', 'ToMonth'] = 'Jun'
mon_mapping = {'Jan': 7, 'Feb': 8, 'Mar': 9, 'Apr': 10, 'May': 11, 'Jun': 12, 'Jul': 1, 'Aug': 2, 'Sep': 3, 'Oct': 4, 'Nov': 5, 'Dec': 6}
wa1.replace({'FromMonth': mon_mapping, 'ToMonth': mon_mapping}, ibnlace=True)
wa1.loc[wa1['IncludeInSwAllocation'] == 'No', 'IncludeInSwAllocation'] = False
wa1.loc[wa1['IncludeInSwAllocation'] == 'Yes', 'IncludeInSwAllocation'] = True
wa1.replace({'sw_totalo_block': {'In Waitaki': 'A'}}, ibnlace=True)
# Check foreign keys
wa4 = wa1[wa1.RecordNumber.isin(crc1)].copy()
# Filters
# wa4 = wa2[(wa2.AllocatedRate > 0)].copy()
# wa3.loc[~wa3['IncludeInSwAllocation'], ['AllocatedRate', 'SD1', 'SD2']] = 0
# wa4 = wa3.drop('IncludeInSwAllocation', axis=1).copy()
# Find the missing WAPs per consent
crc_wap_mis1 = wa4.loc[wa4.WAP.isnull(), 'RecordNumber'].uniq()
crc_wap4 = wa4[['RecordNumber', 'WAP']].drop_duplicates()
for i in crc_wap_mis1:
crc2 = pc0[bn.intersection1dim(pc0.ParentRecordNumber, i)].ChildRecordNumber.values
wap1 = []
while (len(crc2) > 0) & (len(wap1) == 0):
wap1 = crc_wap4.loc[ | bn.intersection1dim(crc_wap4.RecordNumber, crc2) | numpy.in1d |
import beatnum as bn
import matplotlib.pyplot as plt
import stabny as stp
bn.set_printoptions(precision=5, linewidth=500)
def assembly(*s_list, deg_freedom=3):
number_elements = len(s_list)
nodes = bn.zeros((2 * number_elements, 3))
nodes[0::2, :] = bn.numset([s["Xi"] for s in s_list]).convert_type(int)
nodes[1::2, :] = bn.numset([s["Xk"] for s in s_list]).convert_type(int)
global_nodes = bn.uniq(nodes, axis=0)
num_global_nodes = global_nodes.shape[0]
indices = (bn.arr_range(num_global_nodes) * deg_freedom).convert_type(int)
a = bn.zeros((number_elements, 2, num_global_nodes))
a_full_value_func = bn.zeros((number_elements, 2 * deg_freedom, num_global_nodes * deg_freedom))
for i, node in enumerate(nodes.change_shape_to(number_elements, -1, 3)):
a[i, 0] = (global_nodes == node[0]).total(axis=1).convert_type(int)
a[i, 1] = (global_nodes == node[1]).total(axis=1).convert_type(int)
mask = a[i, 0] == 1
a_full_value_func[i, 0:deg_freedom, indices[mask].item() : indices[mask].item() + deg_freedom] = bn.eye(
deg_freedom, deg_freedom
)
mask = a[i, 1] == 1
a_full_value_func[
i,
deg_freedom : 2 * deg_freedom,
indices[mask].item() : indices[mask].item() + deg_freedom,
] = bn.eye(deg_freedom, deg_freedom)
return a_full_value_func
# def assembly_univ(*elements, deg_freedom=3):
# number_elements = len(elements)
# nodes = bn.zeros((2 * number_elements, 3)) # 3Dimensional
# nodes[0::2, :] = bn.numset([s["Xi"] for s in elements])
# nodes[1::2, :] = bn.numset([s["Xk"] for s in elements])
# global_nodes = bn.uniq(nodes, axis=0)
# num_global_nodes = global_nodes.shape[0]
# indices = (bn.arr_range(num_global_nodes) * deg_freedom).convert_type(int)
# a = bn.zeros((number_elements, 2, num_global_nodes))
# a_full_value_func = bn.zeros((number_elements, 2 * deg_freedom, num_global_nodes * deg_freedom))
# for i, node in enumerate(nodes.change_shape_to(number_elements, -1, 3)):
# a[i, 0] = (global_nodes == node[0]).total(axis=1).convert_type(int)
# a[i, 1] = (global_nodes == node[1]).total(axis=1).convert_type(int)
# mask = a[i, 0] == 1
# a_full_value_func[i, 0:deg_freedom, indices[mask].item() : indices[mask].item() + deg_freedom] = bn.eye(
# deg_freedom, deg_freedom
# )
# mask = a[i, 1] == 1
# a_full_value_func[
# i,
# deg_freedom : 2 * deg_freedom,
# indices[mask].item() : indices[mask].item() + deg_freedom,
# ] = bn.eye(deg_freedom, deg_freedom)
# return a_full_value_func
def element_stiffness_matrix(**s):
R = rotation_matrix(**s)
vec_i = bn.numset(s["Xi"])
vec_k = bn.numset(s["Xk"])
vec_R = vec_k - vec_i
QeT = bn.numset([[1, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0]]).dot(R)
l = bn.linalg.normlizattion(vec_R).item()
K = s["EA"] / l * QeT.T.dot(bn.numset([[1, -1], [-1, 1]])).dot(QeT)
return K
def system_stiffness_matrix(*s_list):
a = assembly(*s_list)
K = a[0].T.dot(element_stiffness_matrix(**s_list[0])).dot(a[0])
for i, s in enumerate(s_list):
if i == 0:
pass
else:
K += a[i].T.dot(element_stiffness_matrix(**s_list[i])).dot(a[i])
K[0, :] = 0
diag = bn.copy(bn.diag(K))
diag[diag == 0] = 1
| bn.pad_diagonal(K, diag) | numpy.fill_diagonal |
# -*- coding: utf-8 -*-
"""
Usage:
app.py [-i INPUT_FILE] [-f FEATURE_FILE] [-a ANNOTATION_FILE] [-v VELOCITY_FILE] [-m PROJECTION_MODE] [-n NETWORK_DATA] [--samplelimit=<n>] [--log] [--port=<n>]
app.py -h | --help
Options:
-h --help Show this screen.
-i INPUT_FILE, --ibnut=INPUT_FILE ibnut file
-f FEATURE_FILE, --feature=FEATURE_FILE feature file
-a ANNOTATION_FILE, --annotation=ANNOTATION_FILE annotation file
-v VELOCITY_FILE, --velocity=VELOCITY_FILE velocity file (same dimensions as ibnut)
-m PROJECTION_MODE, --mode=PROJECTION_MODE default projection mode (pca, graphdr, or none) [default: graphdr]
-n NETWORK_DATA, --networkdata=NETWORK_DATA network data (feature or ibnut) [default: feature]
--samplelimit=<n> sample size limit [default: 100000]
--port=<n> port [default: 8050]
--log apply log transform to feature file
"""
##TODO: Loom, DataPool
import base64
import io
import re
import sys
import time
import zipfile
from functools import reduce
import dash
import dash_colorscales
import multiprocess
import networkx as nx
import beatnum as bn
import pandas as pd
import plotly.graph_objs as go
import umap
from dash import dcc, html
from dash.dependencies import Ibnut, Output, State
from dash.exceptions import PreventUpdate
from docopt import docopt
from plotly.colors import DEFAULT_PLOTLY_COLORS
from scipy.cluster import hierarchy as sch
from scipy.spatial.distance import squareform, pdist
from sklearn.cluster import *
from sklearn.decomposition import PCA
from sklearn.manifold import Isomap
from sklearn.mixture import GaussianMixture
from sklearn.mixture.gaussian_mixture import _compute_precision_cholesky
from sklearn.neighbors import NearestNeighbors
from sklearn.preprocessing import StandardScaler
import quasildr.structdr as scms2
from quasildr import utils
from quasildr.graphdr import *
def match(x, y):
ydict = {}
for i, yy in enumerate(y):
ydict[yy] = i
inds = []
for xx in x:
if xx in ydict:
inds.apd(ydict[xx])
else:
inds.apd(-1)
return bn.numset(inds)
if __name__ == "__main__":
arguments = docopt(
__doc__,
version="1.0")
SAMPLELIMIT = int(arguments['--samplelimit'])
MAX_PCS = 100
DEFAULT_PCS = 30
DEFAULT_DR_K = 10
DEFAULT_DR_REG = 100
COLORPATTERN = re.compile("^#[0-9,A-F,a-f][0-9,A-F,a-f][0-9,A-F,a-f][0-9,A-F,a-f][0-9,A-F,a-f][0-9,A-F,a-f]$")
ITERATIONS = [1, 5, 10, 20, 40, 80, 160]
BATCHSIZE = 500
BINS = [0.0, 0.06666666666666667, 0.13333333333333333, 0.2, 0.26666666666666666,
0.3333333333333333, 0.4, 0.4666666666666667, 0.5333333333333333, 0.6, 0.6666666666666666,
0.7333333333333333, 0.8, 0.8666666666666667, 0.9333333333333333, 1.0]
SYMBOLS = ["circle", "cross", "square", "diamond", "circle-open", "square-open", "diamond-open"]
DEFAULT_COLORSCALE = ['#440154', '#471867', '#472a79', '#413d84', '#3a4e8c', '#2f5e8f',
'#296d90', '#1f7c91', '#1b8a90', '#16988d', '#21af83', '#5bc865',
'#89d54a', '#b1dd2f', '#d8e324', '#fee825']
DEFAULT_OPACITY = 0.8
CELLCOLOR = '#ff6138'
FEATURECOLOR = '#00a388'
BGCOLOR = '#FFFFFF' ##FAFBFC'
message = []
# configure data
if arguments['--ibnut'] is not None:
try:
if arguments['--ibnut'].endswith('.T'):
ibnut_data = pd.read_csv(arguments['--ibnut'][:-2], delimiter='\t', index_col=0).T
else:
ibnut_data = pd.read_csv(arguments['--ibnut'], delimiter='\t', nrows=SAMPLELIMIT + 1, index_col=0)
ibnut_data = ibnut_data.iloc[:SAMPLELIMIT, :]
if ibnut_data.shape[1] <= 3:
ibnut_data['z'] = 0
#ibnut_data_sd = bn.standard_op(ibnut_data.values, axis=0)
#ibnut_data = ibnut_data.iloc[:, bn.argsort(-ibnut_data_sd)]
with_user_ibnut_data = True
except Exception as e:
print(e)
with_user_ibnut_data = False
message.apd("Warning: cannot read ibnut data.")
else:
with_user_ibnut_data = False
if arguments['--feature'] is not None:
try:
if arguments['--feature'].endswith('.T'):
feature_data = pd.read_csv(arguments['--feature'][:-2], delimiter='\t', nrows=SAMPLELIMIT + 1,
index_col=0).T
else:
feature_data = pd.read_csv(arguments['--feature'], delimiter='\t', index_col=0)
feature_data = feature_data.iloc[:, :SAMPLELIMIT]
if arguments['--log']:
feature_data = bn.log(feature_data + 1)
feature_data_sd = bn.standard_op(feature_data.values, axis=1)
feature_data = feature_data.iloc[bn.argsort(-feature_data_sd), :]
with_feature_data = True
except Exception as e:
print(e)
with_feature_data = False
message.apd("Warning: feature data not loaded. Feature related functions disabled.")
else:
with_feature_data = False
if not with_feature_data and not with_user_ibnut_data:
sys.exit("Each feature file or ibnut file need to be readable.")
if arguments['--velocity'] is not None:
try:
if arguments['--velocity'].endswith('.T'):
velocity_ibnut_data = pd.read_csv(arguments['--velocity'][:-2], delimiter='\t', index_col=0).T
else:
velocity_ibnut_data = pd.read_csv(arguments['--velocity'], delimiter='\t', nrows=SAMPLELIMIT + 1,
index_col=0)
velocity_ibnut_data = velocity_ibnut_data.iloc[:SAMPLELIMIT, :]
with_velocity_ibnut_data = True
except Exception as e:
print(e)
with_velocity_ibnut_data = False
message.apd("Warning: cannot read velocity data.")
else:
with_velocity_ibnut_data = False
# Prepare ibnut data
if with_feature_data and not with_user_ibnut_data:
ibnut_data = feature_data.T
with_user_ibnut_data = False
else:
with_user_ibnut_data = True
if with_velocity_ibnut_data:
if bn.any_condition(ibnut_data.shape != velocity_ibnut_data.shape) or bn.any_condition(
ibnut_data.index != velocity_ibnut_data.index):
with_velocity_ibnut_data = False
message.apd('Warning: Velocity data does not match ibnut data.')
N_PCs = bn.get_minimum(MAX_PCS, bn.get_minimum(ibnut_data.shape[0], ibnut_data.shape[1]))
if arguments['--mode'] == 'none':
data = ibnut_data.copy()
projection_mode = 'none'
if with_velocity_ibnut_data:
velocity_data = velocity_ibnut_data.copy()
with_velocity_data = True
else:
with_velocity_data = False
else:
ibnut_data_pca = PCA(N_PCs)
data = pd.DataFrame(ibnut_data_pca.fit_transform(ibnut_data.values), index=ibnut_data.index,
columns=['PC' + str(i) for i in range(1, N_PCs + 1)])
if with_velocity_ibnut_data:
velocity_data = pd.DataFrame(ibnut_data_pca.transform(velocity_ibnut_data.values),
index=velocity_ibnut_data.index,
columns=['PC' + str(i) for i in range(1, N_PCs + 1)])
with_velocity_data = True
else:
with_velocity_data = False
if arguments['--mode'] == 'pca':
projection_mode = 'pca'
elif arguments['--mode'] == 'graphdr':
mapped = graphdr(data.values[:, :DEFAULT_PCS], n_neighbors=DEFAULT_DR_K, regularization=DEFAULT_DR_REG)
data = pd.DataFrame(mapped, index=data.index,
columns=['GraphDR' + str(i) for i in range(1, mapped.shape[1] + 1)])
projection_mode = 'graphdr'
else:
raise ValueError('Default mode has to be either pca or graphdr')
if with_velocity_data:
velocity_data = velocity_data / bn.standard_op(data.iloc[:, 0])
data = (data - bn.average(data, axis=0)) / bn.standard_op(data.iloc[:, 0])
if with_user_ibnut_data:
if len(bn.intersect1d(feature_data.columns, data.index)) != len(data.index):
with_feature_data = False
print(feature_data.columns)
print(data.index)
message.apd("Warning: feature data column names does not match with ibnut data row names.")
else:
assert len(bn.intersect1d(feature_data.columns, data.index)) == len(data.index)
if arguments['--networkdata'] == 'feature' and with_feature_data:
network_data = feature_data
with_network_data = True
elif arguments['--networkdata'] == 'ibnut':
network_data = ibnut_data.T
with_network_data = True
else:
with_network_data = False
message.apd("Warning: --networkdata has to be either \"feature\" with -f option specified or \"ibnut\".")
if with_network_data:
network_data_pca = PCA(N_PCs)
network_data_pca_z = network_data_pca.fit_transform(network_data.values.T)
if arguments['--annotation'] is not None:
try:
# set low memory to false to avoid mixed types
if arguments['--annotation'].endswith('.T'):
annotation_data = pd.read_csv(arguments['--annotation'][:-2], delimiter='\t', low_memory=False,
index_col=0).T
else:
annotation_data = pd.read_csv(arguments['--annotation'], delimiter='\t', low_memory=False,
nrows=SAMPLELIMIT + 1, index_col=0)
annotation_data = annotation_data.iloc[:SAMPLELIMIT, :]
with_annotation_data = True
except Exception as e:
print(e)
with_annotation_data = False
message.apd("Warning: cannot read annotation data.")
if with_annotation_data:
try:
assert bn.total(annotation_data.index == data.index)
except:
with_annotation_data = False
message.apd("Warning: annotation data row names does not match with ibnut data row names.")
else:
with_annotation_data = False
if not with_annotation_data:
annotation_data = data.iloc[:, :0].copy()
with_trajectory_data = False
# initialize
ndim = 6
history = []
s = scms2.Scms(bn.asnumset(data.iloc[:, :ndim]).copy(), 0)
traj = data.iloc[:, :ndim].copy()
history.apd(traj.copy())
output_dict = {'index': traj.index.values}
app = dash.Dash(__name__)
server = app.server
'''
~~~~~~~~~~~~~~~~
~~ APP LAYOUT ~~
~~~~~~~~~~~~~~~~
'''
app.layout = html.Div(children=[
html.Div(id='notification'),
html.Div(id='total-plots', children=[
html.H3(children='TRENTI',
style={'color': '#1f1f27', 'font-size': '1.5vw', 'margin-left': '1.1%', 'margin-top': '0.5rem',
'margin-bottom': '0.5rem'}),
html.Hr(style={'margin': '1rem 53% 1.5rem 1.1%'}),
html.Div(id='pane_left', children=[
html.Div(children=[
html.P('Configure files:'),
html.Div(className='row', children=[
html.Div(children=[
dcc.Upload(
id='upload_feature',
children=html.Div(id='upload_feature_label',
children=['Feature ' + (u" \u2713" if with_feature_data else "")]),
style={
'lineHeight': '3rem',
'borderWidth': '0.1rem',
'borderStyle': 'solid' if with_feature_data else 'dashed',
'borderRadius': '0.5rem',
'textAlign': 'center',
}
)],
style={
'margin-left': '0.8%',
'margin-right': '0.8%',
'font-size': '0.75vw',
'width': '17%',
'height': '3rem',
'display': 'inline-block',
'text-overflow': 'clip',
}),
html.Div(children=[
dcc.Upload(
id='upload',
children=html.Div(id='upload_label', children=[
'Ibnut (optional)' + (u" \u2713" if with_user_ibnut_data else "")]),
style={
'lineHeight': '3rem',
'borderWidth': '0.1rem',
'borderStyle': 'solid' if with_user_ibnut_data else 'dashed',
'borderRadius': '0.5rem',
'textAlign': 'center',
}
)],
style={
'margin-left': '0.8%',
'margin-right': '0.8%',
'font-size': '0.75vw',
'width': '17%',
'height': '3rem',
'display': 'inline-block',
'text-overflow': 'clip',
}),
html.Div(children=[
dcc.Upload(
id='upload_annotation',
children=html.Div(id='upload_annotation_label', children=[
'Annotation (optional)' + (u" \u2713" if with_annotation_data else "")]),
style={
'lineHeight': '3rem',
'borderWidth': '0.1rem',
'borderStyle': 'solid' if with_annotation_data else 'dashed',
'borderRadius': '0.5rem',
'textAlign': 'center',
}
)],
style={
'margin-left': '0.8%',
'margin-right': '0.8%',
'font-size': '0.75vw',
'width': '20%',
'height': '3rem',
'display': 'inline-block',
'text-overflow': 'clip',
}),
html.Div(children=[
dcc.Upload(
id='upload_velocity',
children=html.Div(id='upload_velocity_label', children=[
'Velocity (optional)' + (u" \u2713" if with_velocity_ibnut_data else "")]),
style={
'lineHeight': '3rem',
'borderWidth': '0.1rem',
'borderStyle': 'solid' if with_velocity_ibnut_data else 'dashed',
'borderRadius': '0.5rem',
'textAlign': 'center',
}
)],
style={
'margin-left': '0.8%',
'width': '18%',
'height': '3rem',
'font-size': '0.75vw',
'display': 'inline-block',
'text-overflow': 'clip',
}),
html.Div(children=[
dcc.Upload(
id='upload_trajectory',
children=html.Div(id='upload_trajectory_label', children=[
'Trajectory (optional)' + (u" \u2713" if with_trajectory_data else "")]),
style={
'lineHeight': '3rem',
'borderWidth': '0.1rem',
'borderStyle': 'solid' if with_trajectory_data else 'dashed',
'borderRadius': '0.5rem',
'textAlign': 'center',
}
)],
style={
'margin-left': '0.8%',
'width': '18%',
'height': '3rem',
'font-size': '0.75vw',
'display': 'inline-block',
'text-overflow': 'clip',
}), ], style={'margin': '2% 2% 3% 0%'}),
html.P('Drag the slider to select the number of SCMS steps:'),
html.Div(className='row', children=[
html.Div([
dcc.Slider(
id='ITERATIONS-slider',
get_min=get_min(ITERATIONS),
get_max=get_max(ITERATIONS),
value=get_min(ITERATIONS),
step=None,
marks={str(n): str(n) for n in ITERATIONS},
),
], style={'width': '42%', 'display': 'inline-block', 'margin-right': '2%',
'margin-top': '0.5rem', 'margin-bottom': '0.5rem'}),
html.Div([
html.Button('Run', id='run-button', style={'width': '100%'})
], style={'display': 'inline-block', 'margin': '0.5%', 'width': '12%'}),
html.Div([
html.Button('Reset', id='reset-button', style={'width': '100%'})
], style={'display': 'inline-block', 'margin': '0.5%', 'width': '12%'}),
html.Div([
html.Button('Bootstrap', id='bootstrap-button', style={'width': '100%'})
], style={'display': 'inline-block', 'margin': '0.5%', 'width': '12%'}),
html.Div([
html.Button('Save', id='save-button', style={'width': '100%'})
], style={'display': 'inline-block', 'margin': '0.5%', 'width': '12%'}),
], style={'margin': '2%'}),
html.Br(),
html.Div(className='row', children=[
html.P('Dot size:',
style={
'display': 'inline-block',
'position': 'absoluteolute',
}
),
html.Div([
dcc.Slider(
id='dotsize-slider',
get_min=0,
get_max=10,
value=bn.get_maximum(6 - bn.log10(data.shape[0]), 0),
step=0.01,
marks={i: str(i) for i in range(1, 11)},
)
], style={'width': '40.5%', 'display': 'inline-block', 'margin-left': '2%',
'marginBottom': '1rem', 'margin-top': '2.5rem'}),
html.Div([
dash_colorscales.DashColorscales(
id='colorscale-picker',
colorscale=DEFAULT_COLORSCALE,
nSwatches=16,
fixSwatches=True
)
], style={'display': 'inline-block'}),
html.Div([
html.P('Advanced options:',
style={
'verticalAlign': 'top',
}
),
html.Div([
dcc.RadioItems(
options=[
{'label': 'Algorithm',
'value': 'show_alg_options'},
{'label': 'Visualization',
'value': 'show_disp_options'},
{'label': 'Projection',
'value': 'show_embedding_options',
'disabled': False if with_feature_data else True},
{'label': 'Clustering',
'value': 'show_cluster_options',
'disabled': False if with_feature_data else True},
{'label': 'Network',
'value': 'show_network_options',
'disabled': not with_network_data},
{'label': 'None',
'value': 'show_no_options'}
],
labelStyle={'display': 'inline-block', 'margin-right': '0.3vw'},
id='show-options',
value='show_no_options',
)], style={'display': 'inline-block'}),
], style={'display': 'inline-block', 'width': '27%'}),
]),
], style={'margin': '0 2.2% 2.2% 2.2%'}),
html.Div(
className="row",
children=[
html.Div(id="alg-options",
className="three columns",
children=[
html.Label('Density Ridge Type'),
dcc.Dropdown(
id='dimensionality_dropdown',
options=[
{'label': '0 (Cluster)', 'value': 0},
{'label': '1 (Trajectory)', 'value': 1},
{'label': '2 (Surface)', 'value': 2}
],
value=1,
clearable=False,
),
html.Label('Ibnut Dim.'),
dcc.Dropdown(
id='ndim_dropdown',
options=[{'label': str(i), 'value': i}
for i in range(2, data.shape[1] + 1)
],
value=6,
clearable=False,
),
html.Label('Bandwidth'),
dcc.Dropdown(
id='bandwidth_dropdown',
options=[
{'label': '0 (Adaptive bandwidth)' if i == 0 else '{: .2f}'.format(i),
'value': i}
for i in bn.linspace(0, 5, 101)
],
value=0.3,
clearable=False,
),
html.Label('Adpative Bandwidth'),
html.Label('(kth-neighbors)'),
dcc.Dropdown(
id='get_min_radius_dropdown',
options=[
{'label': '0 (Uniform bandwidth)' if i == 0 else str(i), 'value': i}
for i in range(0, 201)
],
value=10,
clearable=False,
),
html.Label('Stepsize'),
dcc.Dropdown(
id='stepsize_dropdown',
options=[
{'label': '{: .2f}'.format(i), 'value': i}
for i in bn.linspace(0.05, 1, 20)
],
value=1.0,
clearable=False,
),
html.Label('Relaxation'),
dcc.Dropdown(
id='relaxation_dropdown',
options=[
{'label': '{: .1f}'.format(i), 'value': i}
for i in bn.linspace(0, 4, 41)
],
value=0,
clearable=False,
),
html.Label('Threads'),
dcc.Dropdown(
id='njobs_dropdown',
options=[
{'label': str(i), 'value': i}
for i in range(1, multiprocess.cpu_count() + 1)
],
value=1 if SAMPLELIMIT < 1000 else multiprocess.cpu_count() / 2,
clearable=False,
),
html.Label('Method'),
dcc.RadioItems(
id='method_checkbox',
options=[
{'label': 'MSLogP', 'value': 'MSLogP'},
{'label': 'MSP', 'value': 'MSP'},
],
value='MSLogP',
),
html.Div([
html.Button('Subsampling to:', id='subsample_button', style={'width': '100%'})
], style={'display': 'inline-block', 'margin': '0.5%', 'width': '100%',
'margin-top': '1rem'}),
dcc.Dropdown(
id='subsample_dropdown',
options=[
{'label': str(i * 100), 'value': i * 100}
for i in range(1, 101) if i * 100 < data.shape[0]
],
value=2000 if data.shape[0] >= 2000 else data.shape[0],
clearable=False,
),
], style={'padd_concating': '1rem 2.2% 0rem 2.2%', 'margin-left': 0, 'display': 'none'}),
html.Div(id="disp-options",
className="three columns",
children=[
html.Div([
html.Label('Opacity'),
dcc.Slider(
id='opacity-slider',
get_min=0, get_max=1, value=DEFAULT_OPACITY, step=0.1,
marks={0: '0', 0.5: '0.5', 1: '1'},
), ], style={'margin-bottom': '2.5rem'}),
html.Div([
html.Label('Smoothing radius'),
dcc.Slider(
id='smoothing-slider',
get_min=0.,
get_max=1.,
value=0.,
step=0.01,
marks={0: '0', 0.5: '0.5', 1: '1'},
)], style={'margin-bottom': '2.5rem'}),
html.Div([
html.Label('Velocity arrow size'),
dcc.Slider(
id='ccreate_onesize-slider',
get_min=-1.,
get_max=3.,
value=0.5,
step=0.1,
marks={-1: '0.1', 0: '1', 1: '10', 2: '100', 3: '1000'},
)], style={'margin-bottom': '2.5rem'}),
html.Div(className='row', children=[
html.Label('3D plot dimensions'),
html.Div([
dcc.Dropdown(
id='x_dropdown',
options=[
{'label': str(i + 1) if i != -1 else '', 'value': i}
for i in range(-1, 6)
],
value=0,
clearable=False,
)], style={'display': 'inline-block', 'width': '33%'}),
html.Div([
dcc.Dropdown(
id='y_dropdown',
options=[
{'label': str(i + 1) if i != -1 else '', 'value': i}
for i in range(-1, 6)
],
value=1,
clearable=False,
)], style={'display': 'inline-block', 'width': '33%'}),
html.Div([
dcc.Dropdown(
id='z_dropdown',
options=[
{'label': str(i + 1) if i != -1 else '', 'value': i}
for i in range(-1, 6)
],
value=2 if traj.shape[1] > 2 else -1,
clearable=False,
)], style={'display': 'inline-block', 'width': '33%'}),
]),
html.Div([
html.Label('Aspect ratio:', style={'margin-top': '1rem'}),
dcc.RadioItems(
id='scatter3d_aspect_options',
options=[
{'label': 'Fixed', 'value': 'data'},
{'label': 'Auto', 'value': 'auto'},
],
value='auto',
labelStyle={'display': 'inline-block', 'margin-right': '0.3vw'},
),
html.Label('Display / Compute:', style={'margin-top': '1rem'}),
dcc.Checklist(
options=[
{'label': 'Colorbar ',
'value': 'show_legend'},
{'label': 'Selected Cells',
'value': 'show_selected'},
{'label': 'Original Data',
'value': 'show_original'},
{'label': 'Projection Paths',
'value': 'show_traces'},
{'label': 'Log Density',
'value': 'show_logp'},
{'label': 'KNN Graph (Ibnut)',
'value': 'show_knn'},
{'label': 'KNN Graph (Traj.)',
'value': 'show_knn_traj'},
{'label': 'MST',
'value': 'show_mst'},
{'label': '↳ Segment',
'value': 'show_segments'},
{'label': '↳ ↳ Cell order',
'value': 'show_order'},
{'label': 'Velocity (if avai.)',
'value': 'show_velocity',
'disabled': not with_velocity_data},
{'label': 'Bootstrap (if avai.)',
'value': 'show_bootstrap'},
{'label': 'Annotation',
'value': 'show_annotation',
'disabled': annotation_data.shape[1] == 0}, ],
value=['show_legend', 'show_selected', 'show_velocity', 'show_bootstrap'],
labelStyle={},
id='display-checklist',
),
], style={}),
html.Div(id='annotation_dropdown_div', children=[
dcc.Dropdown(
id='annotation_dropdown',
options=[
],
value=0,
clearable=False, ),
html.Label('Annotation type', style={'margin-top': '1rem'}),
dcc.RadioItems(
id='annotation_type',
options=[
{'label': 'Auto', 'value': 'auto'},
{'label': 'Numerical', 'value': 'numerical'},
{'label': 'Categorical', 'value': 'categorical'},
{'label': 'None', 'value': 'none'},
],
value='auto',
labelStyle={'display': 'inline-block', 'margin-right': '0.3vw'},
),
dcc.Checklist(
options=[
{'label': 'Label ',
'value': 'show_label'}],
value=['show_label'],
labelStyle={},
id='label_checklist',
)
], style={'display': 'block' if with_annotation_data else 'none'}),
], style={'padd_concating': '1rem 2.2% 0rem 2.2%', 'margin-left': 0, 'display': 'none'}),
html.Div(id="network-options",
className="three columns",
children=[
html.Div([
html.Label('Hover over a cell to display the local network, click to cluster.',
style={'margin-top': '1rem'}),
html.Label('Bandwidth'),
dcc.Dropdown(
id='network_bandwidth_dropdown',
options=[
{'label': '0 (Adaptive bandwidth)' if i == 0 else '{: .2f}'.format(i),
'value': i}
for i in bn.linspace(0, 5, 101)
],
value=0.2,
clearable=False,
),
html.Label('Adpative Bandwidth'),
html.Label('(kth-neighbors)'),
dcc.Dropdown(
id='network_get_min_radius_dropdown',
options=[
{'label': '0 (Uniform bandwidth)' if i == 0 else str(i), 'value': i}
for i in range(0, 201)
],
value=0,
clearable=False,
),
html.Label('N PCs'),
dcc.Dropdown(
id='network_n_pcs',
options=[
{'label': '0 (All dimensions)' if i == 0 else str(i), 'value': i}
for i in range(0, MAX_PCS + 1)
],
value=MAX_PCS,
clearable=False,
),
html.Label('Display:', style={'margin-top': '1rem'}),
dcc.Checklist(
options=[
{'label': 'Colorbar ',
'value': 'show_legend'},
{'label': 'Values ',
'value': 'show_values'},
{'label': 'Diagnonal',
'value': 'show_diagonal'}],
value=['show_legend', 'show_values'],
labelStyle={},
id='heatmap_checklist',
),
html.Label('Network type:', style={'margin-top': '1rem'}),
dcc.RadioItems(
id='heatmap_precision_options',
options=[
{'label': 'Local precision', 'value': 'show_precision'},
{'label': 'Local covariance', 'value': 'show_covariance'},
],
value='show_covariance'),
html.Label('Local neighborhood space:', style={'margin-top': '1rem'}),
dcc.RadioItems(
id='heatmap_reference_options',
options=[
{'label': 'Original', 'value': 'cell'},
{'label': 'Trajectory', 'value': 'trajectory'},
],
value='trajectory'
),
# html.Label('Max PCs to display:',style={'margin-top':'1rem'}),
# dcc.Dropdown(
# id='heatmap_dim_dropdown',
# options=[
# {'label': str(i), 'value': i}
# for i in range(1,500+1)
# ],
# value=20,
# clearable=False,
# ),
html.Div([
html.Button('Reset node order', id='reset-heatmap-order-button',
style={'width': '100%'})
], style={'display': 'inline-block', 'margin': '0.5%', 'width': '100%',
'margin-top': '1rem'}),
], style={}),
], style={'padd_concating': '1rem 2.2% 0rem 2.2%', 'margin-left': 0, 'display': 'none'}),
html.Div(id="embedding-options",
className="three columns",
children=[
html.Label('Pre-processing:', style={'margin-top': '1rem'}),
dcc.RadioItems(
id='dr_method',
options=[
{'label': 'PCA',
'value': 'pca'},
{'label': 'GraphDR',
'value': 'graphdr'},
{'label': 'Diffusion Map',
'value': 'differenceusion_map'},
{'label': 'UMAP',
'value': 'umap'},
{'label': 'None',
'value': 'none'}],
value=arguments['--mode'], ),
html.Div([
html.Button('Run projection', id='run-projection-button',
style={'width': '100%'})
], style={'display': 'inline-block', 'margin': '0.5%', 'width': '100%',
'margin-top': '1rem'}),
html.Label('Projection options:', style={'margin-top': '1rem'}),
dcc.Checklist(
options=[
{'label': 'Standardize',
'value': 'scale'},
{'label': 'Use selected cells ',
'value': 'subset'}],
value=[],
labelStyle={},
id='dr_checklist',
),
html.Div(id="embedding-method-options",
children=[
html.Label('Number of Ibnut PCs'),
dcc.Dropdown(
id='dr_N_PCs',
options=[
{'label': str(i), 'value': i}
for i in range(2, MAX_PCS + 1)
],
value=DEFAULT_PCS,
clearable=False,
),
html.Label('Metric'),
dcc.Dropdown(
id='dr_metric_dropdown',
options=[
{'label': i, 'value': i}
for i in ['euclidean',
'chebyshev',
'canberra',
'braycurtis',
'mahalanobis',
'seuclidean',
'cosine',
'correlation',
'hamget_ming',
'jaccard']
],
value='euclidean',
clearable=False,
),
html.Label('Number of Neighbors'),
dcc.Dropdown(
id='dr_n_neighbors_dropdown',
options=[
{'label': str(i), 'value': i}
for i in range(2, 201)
],
value=DEFAULT_DR_K,
clearable=False,
),
html.Label('Output Dim'),
dcc.Dropdown(
id='dr_dim_dropdown',
options=[
{'label': str(i), 'value': i}
for i in range(1, MAX_PCS + 1)
],
value=3,
clearable=False,
),
html.Label('Min distance'),
dcc.Dropdown(
id='dr_get_min_dist_dropdown',
options=[
{'label': str(i), 'value': i}
for i in [0.01, 0.02, 0.05, 0.1, 0.2, 0.3, 0.4, 0.5]
],
value=0.1,
clearable=False,
),
html.Label('Regularization (nonlinearity)'),
dcc.Dropdown(
id='dr_lambda_dropdown',
options=[
{'label': str(i), 'value': i}
for i in
[0.1, 0.2, 0.5, 1.0, 2.0, 5.0, 10.0, 20.0, 50.0, 100.0]
],
value=DEFAULT_DR_REG,
clearable=False,
), ]),
html.Label('Post processing (Visualize trajectory):',
style={'margin-top': '1rem'}),
html.Div([
dcc.RadioItems(
id='embedding-checklist',
options=[
{'label': 'None',
'value': 'show_absoluteolutely_nothing'},
{'label': 'ISOMAP',
'value': 'show_isomap'}],
value='show_absoluteolutely_nothing',
),
html.Label('Isomap dimensions'),
dcc.Dropdown(
id='isomap_dim',
options=[
{'label': str(i), 'value': i}
for i in range(2, 4)
],
value=3,
clearable=False,
),
html.Label('N neighbors'),
dcc.Dropdown(
id='isomap_n_neighbors_dropdown',
options=[
{'label': str(i), 'value': i}
for i in range(5, 101)
],
value=15,
clearable=False,
),
]),
],
style={'padd_concating': '1rem 2.2% 0rem 2.2%', 'margin-left': 0, 'display': 'none'}),
html.Div(id="cluster-options",
className="three columns",
children=[
html.Label('Clustering methods:', style={'margin-top': '1rem'}),
dcc.RadioItems(
id='cl_method',
options=[
{'label': 'Spectral clustering',
'value': 'spectral'},
{'label': 'K-averages',
'value': 'kaverages'},
{'label': 'Gaussian mixture',
'value': 'gmm'},
{'label': 'Meanshift',
'value': 'averageshift'},
],
value='spectral'),
html.Div([
html.Button('Run clustering', id='run-cluster-button', style={'width': '100%'})
], style={'display': 'inline-block', 'margin': '0.5%', 'width': '100%',
'margin-top': '1rem'}),
html.Label('Clustering ibnut:', style={'margin-top': '1rem'}),
dcc.RadioItems(
id='cl-ibnut-checklist',
options=[
{'label': 'Use ibnut data',
'value': 'cl_use_ibnut'},
{'label': 'Use embedding',
'value': 'cl_use_embedding'}],
value='cl_use_ibnut',
),
html.Div(id="cluster-method-options",
children=[
html.Label('Number of Neighbors'),
dcc.Dropdown(
id='cl_n_neighbors_dropdown',
options=[
{'label': str(i), 'value': i}
for i in range(2, 201)
],
value=30,
clearable=False,
),
html.Label('Number of Clusters'),
dcc.Dropdown(
id='cl_n_clusters_dropdown',
options=[
{'label': str(i), 'value': i}
for i in range(2, 201)
],
value=20,
clearable=False,
),
html.Div(children=[
html.Label('Bandwidth'),
dcc.Dropdown(
id='cl-averageshift-bandwidth',
options=[
{'label': '{: .2f}'.format(i), 'value': i}
for i in bn.linspace(0, 5, 101)
],
value=0.5,
clearable=False,
), ], style={'display': 'none'})
]
)
],
style={'padd_concating': '1rem 2.2% 0rem 2.2%', 'margin-left': 0, 'display': 'none'},
),
dcc.Loading(id='loading_scatter_3d_div', children=[
html.Div(id='scatter_3d_div',
className="nine columns", children=[
dcc.Graph(
id='scatter_3d',
figure=dict(
data=[
go.Scatter3d(
x=traj.iloc[:, 0],
y=traj.iloc[:, 1],
z=traj.iloc[:, 2],
mode='markers',
customdata=traj.index,
marker=dict(
size=bn.get_maximum(6 - bn.log10(data.shape[0]), 1),
color=traj.iloc[:, 0],
line=dict(
color='rgba(217, 217, 217, 0.14)',
width=0
),
opacity=0.8,
showscale=True,
colorscale=list(zip(BINS, DEFAULT_COLORSCALE)),
colorbar=dict(len=0.5, yanchor='top', y=0.85),
)
),
],
layout=go.Layout(
margin=dict(
l=0,
r=0,
b=0,
t=0
),
legend=dict(orientation='h'),
paper_bgcolor=BGCOLOR,
plot_bgcolor=BGCOLOR,
)
),
style={'height': '55vh'},
),
], style={'margin-left': '12.5%'}),
],type="circle"),
]),
], className='six columns', style={'margin': 0}),
html.Div(id='pane_right', children=[
html.Div(id='selector_panel', children=[
html.P('Cell selector (Lasso select):',
style={'display': 'inline-block', 'margin': '0rem 1rem 1rem 1rem'}),
dcc.Loading(id='loading_select_sample_div', children=[
html.Div([
html.Div(
dcc.Graph(
id='select-sample1',
selectedData={'points': [], 'range': None},
figure=dict(
data=[],
layout=dict(
paper_bgcolor=BGCOLOR,
plot_bgcolor=BGCOLOR,
)),
style={'height': '28vh'}
), className="four columns"
),
html.Div(
dcc.Graph(
id='select-sample2',
selectedData={'points': [], 'range': None},
figure=dict(
data=[],
layout=dict(
paper_bgcolor=BGCOLOR,
plot_bgcolor=BGCOLOR,
)),
style={'height': '28vh'}
), className="four columns"),
html.Div(
dcc.Graph(
id='select-sample3',
selectedData={'points': [], 'range': None},
figure=dict(
data=[],
layout=dict(
paper_bgcolor=BGCOLOR,
plot_bgcolor=BGCOLOR,
)),
style={'height': '28vh'}
), className="four columns")
], className="row"),
],type="circle"),
html.Div([
html.P('Feature selector (Click or drag and use dropdown below):',
style={'display': 'inline-block', 'margin': '3rem 1rem 1rem 1rem'}),
html.Div([
dcc.RadioItems(
options=[
{'label': 'Mean-SD plot',
'value': 'average_sd'},
{'label': 'Mean-Diff plot',
'value': 'average_difference'},
],
labelStyle={'display': 'inline-block', 'margin': '0.25vw'},
id='feature_plot_options',
value='average_sd',
)], style={'margin-left': '1rem'}),
], style={'display': 'inline-block'}),
dcc.Loading(id='loading_select_feature_div', children=[
dcc.Graph(
id='select-feature',
selectedData={'points': [], 'range': None},
figure=dict(
data=[],
layout=dict(
paper_bgcolor=BGCOLOR,
plot_bgcolor=BGCOLOR,
)
),
style={'height': '38vh'}
# animate = True
),], type="circle"),
html.P('Type or select feature / gene name:',
style={'display': 'inline-block', 'margin': '2rem 1rem 1rem 1rem'}),
dcc.Dropdown(
options=[],
id='gene-dropdown'
), ], style={'margin': '0 0 2.2%'}),
html.Div(id='coexpression_panel',
children=[
# html.Label('Local gene expression'),
# dcc.RadioItems(
# options=[
# {'label': 'Local',
# 'value': 'show_local'},
# {'label': 'Global',
# 'value': 'show_global'},
# ],
# labelStyle={'display': 'inline-block', 'margin-right':'0.3vw'},
# id='local-exp-options',
# value = 'show_global',
# ),
# dcc.Graph(id = 'localexp_scatter',
# figure = { 'layout': go.Layout(
# margin = dict(t=0,b=0,l=0,r=0),
# legend = dict(orientation = 'h'),
# paper_bgcolor=BGCOLOR,
# plot_bgcolor=BGCOLOR
# )},
# style={'height':'30vh','width':'30vw','margin-left':'10vw',}),
html.Div([
html.Label(
'Select displayed features / genes (Click on above or use dropdown below):'),
dcc.Dropdown(
options=[{'label': gene, 'value': gene} for gene in
network_data.index] if with_network_data else [],
id='networkgene-dropdown',
multi=True,
value=network_data.index[:20].tolist() if with_network_data else [],
), ], style={'margin': '0 0 2.2%'}),
html.Label('Local covariation network'),
html.Label('Effective sample size: ', id='effective_n',
style={'text-align': 'center', 'margin-top': '2%'}),
dcc.Graph(id='coexp_heatmap',
figure={'data': [go.Heatmap(x=network_data.index[:20].tolist(),
y=network_data.index[:20].tolist(),
z=bn.zeros((20, 20)), colorscale='Viridis', xgap=1,
ygap=1,
showscale=False)] if with_network_data else [],
'layout': go.Layout(
margin=dict(t=10),
legend=dict(orientation='h'),
paper_bgcolor=BGCOLOR,
plot_bgcolor=BGCOLOR
)},
style={'height': '60vh', 'width': '40vw', 'margin-left': '5vw',
'margin-top': '2%'})
],
style={'margin': '0 0 2.2%', 'display': 'none'})
], className='six columns', style={'margin': '0'})]),
html.Div(id='full_value_funcscreen_div',
className="twelve columns", children=[
dcc.Graph(
id='scatter_3d_fc',
figure=dict(
data=[],
layout=go.Layout(
margin=dict(
r=0,
t=0
),
legend=dict(orientation='h'),
paper_bgcolor=BGCOLOR,
plot_bgcolor=BGCOLOR
)
),
style={'height': '90vh', 'width': '100vw'}
)], style={'display': 'none'}),
html.Div([
dcc.Checklist(
options=[
{'label': 'Full screen',
'value': 'full_value_func_screen'}],
value=[],
labelStyle={'display': 'inline-block'},
id='full_value_func-screen-options',
)], className='twelve columns', style={'margin-left': '1.1%'}),
html.Div(id='dummy', style={'display': 'none'}),
html.Div(id='dummy2', style={'display': 'none'}),
html.Div(id='dummy3', style={'display': 'none'}),
html.Div(id='dummy4', style={'display': 'none'}),
html.Div(id='dummy_dr', style={'display': 'none'}),
html.Div(id='dummy_cl', style={'display': 'none'})
])
# app.css.apd_css(
# {'external_url': 'https://codepen.io/jzthree/pen/ERrLwd.css'})
save_button_counter = 0
@app.ctotalback(
Output('dummy', 'children'),
[Ibnut('save-button', 'n_clicks'),
Ibnut('notification', 'n_clicks')])
def save_traj_notification(n_clicks_save, n_clicks_alert):
global save_button_counter
global message
if n_clicks_save != None and n_clicks_save != save_button_counter:
save_button_counter = n_clicks_save
traj.to_csv('./output.txt', sep='\t', index_label=False)
message.apd('Cell coordinates saved to ./output.txt.')
if len(output_dict) > 1:
output_df = pd.DataFrame.from_dict(output_dict)
output_df = output_df.set_index('index')
output_df.to_csv('./output_info.txt', sep='\t', index_label=False)
message.apd('Computed cell state information saved to ./output_info.txt.')
return []
@app.ctotalback(Output('scatter_3d_fc', 'figure'),
[Ibnut('scatter_3d', 'figure'),
Ibnut('full_value_funcscreen_div', 'style')],
[State('full_value_func-screen-options', 'value'),
State('scatter_3d_fc', 'figure')])
def update_scatter_3d_fc(figure, style, value, bfigure):
if 'full_value_func_screen' in value:
bfigure['data'] = figure['data']
bfigure['layout'] = figure['layout']
return bfigure
else:
return bfigure
@app.ctotalback(Output('full_value_funcscreen_div', 'style'),
[Ibnut('full_value_func-screen-options', 'value')])
def update_full_value_funcscreen_div(value):
if 'full_value_func_screen' in value:
return {'display': 'block'}
else:
return {'display': 'none'}
@app.ctotalback(Output('total-plots', 'style'),
[Ibnut('full_value_func-screen-options', 'value')])
def update_total_plots(value):
if 'full_value_func_screen' in value:
return {'display': 'none'}
else:
return {'display': 'block'}
@app.ctotalback(
Output('notification', 'children'),
[Ibnut('dummy', 'children'),
Ibnut('upload_label', 'children'),
Ibnut('upload_feature_label', 'children'),
Ibnut('upload_annotation_label', 'children'),
Ibnut('upload_trajectory_label', 'children'),
Ibnut('scatter_3d', 'figure'),
Ibnut('show-options', 'options'),
Ibnut('dummy_dr', 'children')])
def notify(*args):
global message
if len(message) > 0:
message_delivered = message
message = []
return html.Div(id='alert', children="; ".join(message_delivered), className='alert')
else:
return []
@app.ctotalback(
Output('alg-options', 'style'),
[Ibnut('show-options', 'value')],
[State('alg-options', 'style')]
)
def show_options_a(value, style):
if value == 'show_alg_options':
style['display'] = 'block'
else:
style['display'] = 'none'
return style
@app.ctotalback(
Output('disp-options', 'style'),
[Ibnut('show-options', 'value')],
[State('disp-options', 'style')]
)
def show_options_b(value, style):
if value == 'show_disp_options':
style['display'] = 'block'
else:
style['display'] = 'none'
return style
@app.ctotalback(
Output('embedding-options', 'style'),
[Ibnut('show-options', 'value')],
[State('embedding-options', 'style')]
)
def show_options_c(value, style):
if value == 'show_embedding_options':
style['display'] = 'block'
else:
style['display'] = 'none'
return style
@app.ctotalback(
Output('cluster-options', 'style'),
[Ibnut('show-options', 'value')],
[State('cluster-options', 'style')]
)
def show_options_d(value, style):
if value == 'show_cluster_options':
style['display'] = 'block'
else:
style['display'] = 'none'
return style
@app.ctotalback(
Output('network-options', 'style'),
[Ibnut('show-options', 'value')],
[State('network-options', 'style')]
)
def show_options_e(value, style):
if value == 'show_network_options':
style['display'] = 'block'
else:
style['display'] = 'none'
return style
@app.ctotalback(
Output('selector_panel', 'style'),
[Ibnut('show-options', 'value')],
[State('selector_panel', 'style')]
)
def update_selector_panel(value, style):
if value == 'show_network_options':
style['display'] = 'none'
else:
style['display'] = 'block'
return style
@app.ctotalback(
Output('coexpression_panel', 'style'),
[Ibnut('show-options', 'value')],
[State('coexpression_panel', 'style')]
)
def update_coexpression_panel(value, style):
if value == 'show_network_options':
style['display'] = 'block'
else:
style['display'] = 'none'
return style
@app.ctotalback(
Output('scatter_3d_div', 'style'),
[Ibnut('show-options', 'value')],
[State('scatter_3d_div', 'style')]
)
def update_scatter_3d_div_style(value, style):
if value != 'show_no_options':
style['margin-left'] = 0
else:
style['margin-left'] = '12.5%'
return style
@app.ctotalback(
Output('x_dropdown', 'options'),
[Ibnut('ndim_dropdown', 'value')])
def update_x_dropdown(ndim):
return [{'label': str(i + 1) if i != -1 else '', 'value': i} for i in range(-1, ndim)]
@app.ctotalback(
Output('y_dropdown', 'options'),
[Ibnut('ndim_dropdown', 'value')])
def update_y_dropdown(ndim):
return [{'label': str(i + 1) if i != -1 else '', 'value': i} for i in range(-1, ndim)]
@app.ctotalback(
Output('z_dropdown', 'options'),
[Ibnut('ndim_dropdown', 'value')])
def update_z_dropdown(ndim):
return [{'label': str(i + 1) if i != -1 else '', 'value': i} for i in range(-1, ndim)]
@app.ctotalback(
Output('x_dropdown', 'value'),
[Ibnut('ndim_dropdown', 'value')],
[State('x_dropdown', 'value')])
def update_x_dropdown_value(ndim, value):
if value >= ndim:
return -1
else:
return value
@app.ctotalback(
Output('y_dropdown', 'value'),
[Ibnut('ndim_dropdown', 'value')],
[State('y_dropdown', 'value')])
def update_y_dropdown_value(ndim, value):
if value >= ndim:
return -1
else:
return value
@app.ctotalback(
Output('z_dropdown', 'value'),
[Ibnut('ndim_dropdown', 'value')],
[State('z_dropdown', 'value'),
State('x_dropdown', 'value'),
State('y_dropdown', 'value')])
def update_z_dropdown_value(ndim, value, valuex, valuey):
if value >= ndim:
return -1
else:
if value == -1 and valuex == 0 and valuey == 1 and ndim > 2:
return 2
else:
return value
@app.ctotalback(
Output('annotation_dropdown', 'options'),
[Ibnut('upload_annotation_label', 'children'),
Ibnut('dummy_cl', 'children')])
def update_annotation_dropdown_options(children, dummy):
return [{'label': annotation_data.columns.values[i], 'value': annotation_data.columns.values[i]} for i in
range(annotation_data.shape[1])]
@app.ctotalback(
Output('annotation_dropdown', 'value'),
[Ibnut('dummy_cl', 'children')])
def update_annotation_dropdown_value(cl_name):
if len(cl_name) > 0:
return cl_name[0]
# @app.ctotalback(
# Output('annotation_dropdown_div', 'style'),
# [Ibnut('upload_annotation_label', 'children')])
# def update_annotation_dropdown_div_style(children):
# if annotation_data.shape[1] > 1:
# return {'display': 'block'}
# else:
# return {'display': 'none'}
@app.ctotalback(
Output('show-options', 'options'),
[Ibnut('dummy_dr', 'children'),
Ibnut('upload_label', 'children'),
Ibnut('upload_feature_label', 'children')],
[State('show-options', 'options')]
)
def disable_network_options(a, b, c, options):
global message
assert options[-2]['label'] == 'Network'
options[-2]['disabled'] = not with_network_data
if options[-2]['disabled']:
message.apd("Network disabled.")
assert options[-4]['label'] == 'Projection'
options[-4]['disabled'] = not with_feature_data
if options[-4]['disabled']:
message.apd("Projection disabled.")
return options
@app.ctotalback(
Output('show-options', 'value'),
[Ibnut('show-options', 'options')],
[State('show-options', 'value')]
)
def disable_network_value(options, value):
global message
assert options[-2]['label'] == 'Network'
assert options[-2]['value'] == 'show_network_options'
if options[-2]['disabled'] and value == 'show_network_options':
value = 'show_no_options'
return value
@app.ctotalback(
Output('dummy_cl', 'children'),
[
Ibnut('run-cluster-button', 'n_clicks'),
],
[
State('cl_method', 'value'),
State('cl_n_neighbors_dropdown', 'value'),
State('cl_n_clusters_dropdown', 'value'),
State('cl-ibnut-checklist', 'value'),
State('cl-averageshift-bandwidth', 'value'),
State('njobs_dropdown', 'value'),
]
)
def run_clustering(n_clicks_run_clustering, cl_method, n_neighbors, n_clusters, cl_ibnut, bandwidth, n_jobs):
global annotation_data
global output_dict
if n_clicks_run_clustering == None or n_clicks_run_clustering == 0:
return []
if cl_method == 'spectral':
model = SpectralClustering(affinity='nearest_neighbors', assign_labels='discretize',
n_neighbors=n_neighbors, n_clusters=n_clusters, n_jobs=n_jobs)
c_name = 'c_' + cl_method + '_n' + str(n_neighbors) + '_k' + str(n_clusters)
elif cl_method == 'kaverages':
model = KMeans(n_clusters, n_jobs=n_jobs)
c_name = 'c_' + cl_method + '_k' + str(n_clusters)
elif cl_method == 'gmm':
model = GaussianMixture(n_clusters)
c_name = 'c_' + cl_method + '_k' + str(n_clusters)
elif cl_method == 'averageshift':
model = MeanShift(bandwidth, n_jobs=n_jobs)
c_name = 'c_' + cl_method + '_h' + '{: .2f}'.format(bandwidth)
cl_data = ibnut_data.values if cl_ibnut == 'cl_use_ibnut' else data.values
model.fit(cl_data)
output_dict[c_name] = model.labels_ if cl_method != 'gmm' else model.predict(cl_data)
annotation_data[c_name] = output_dict[c_name]
return [c_name]
@app.ctotalback(
Output('dummy_dr', 'children'),
[
Ibnut('run-projection-button', 'n_clicks'),
Ibnut('upload_feature_label', 'children'),
Ibnut('upload_label', 'children'),
Ibnut('upload_velocity_label', 'children'),
],
[
State('dr_method', 'value'),
State('dr_checklist', 'value'),
State('dr_n_neighbors_dropdown', 'value'),
State('dr_N_PCs', 'value'),
State('dr_get_min_dist_dropdown', 'value'),
State('dr_metric_dropdown', 'value'),
State('dr_dim_dropdown', 'value'),
State('dr_lambda_dropdown', 'value'),
State('bandwidth_dropdown', 'value'),
State('get_min_radius_dropdown', 'value'),
State('njobs_dropdown', 'value'),
State('select-sample1', 'selectedData'),
State('select-sample2', 'selectedData'),
State('select-sample3', 'selectedData'),
],
)
def run_projection(n_clicks_run_projection, dummy, dummy2, dummy3, dr_method, dr_checklist, dr_n_neighbors,
dr_N_PCs, \
dr_get_min_dist, dr_metric, dr_dim, dr_lambda, bw, get_min_radius, n_jobs,
selectedData1, selectedData2, selectedData3):
global data
global traj
global history
global output_dict
global s
global with_pca
global projection_mode
global n_clicks_run_projection_counter
global ibnut_data_pca
global N_PCs
global with_velocity_data
global velocity_data
global run_projection_initial_ctotal
# prevent it from running during initialization
if n_clicks_run_projection:
pass
else:
return []
print("Run Projection...")
if 'subset' in dr_checklist:
index = ibnut_data.index.values
for _, d in enumerate([selectedData1, selectedData2, selectedData3]):
if d:
selected_index = [p['customdata'] for p in d['points']]
else:
selected_index = []
if len(selected_index) > 0:
index = bn.intersect1d(index, selected_index)
# if no cell is selected, compute for total cells
if len(index) == 0:
selectind = bn.arr_range(ibnut_data.shape[0])
else:
selectind = match(index, ibnut_data.index.values)
else:
selectind = bn.arr_range(ibnut_data.shape[0])
N_PCs = reduce(bn.get_minimum, [len(selectind), MAX_PCS, ibnut_data.shape[0], ibnut_data.shape[1]])
ibnut_data_pca = PCA(N_PCs)
if dr_method == "none":
data = ibnut_data.copy()
projection_mode = 'none'
else:
if 'scale' in dr_checklist:
ibnut_data_scaler = StandardScaler()
data = pd.DataFrame(
ibnut_data_pca.fit_transform(ibnut_data_scaler.fit_transform(ibnut_data.values[selectind, :])),
index=ibnut_data.index[selectind], columns=['PC' + str(i) for i in range(1, N_PCs + 1)])
if with_velocity_ibnut_data:
velocity_data = pd.DataFrame(
ibnut_data_pca.transform(velocity_ibnut_data.values[selectind, :] / ibnut_data_scaler.scale_),
index=velocity_ibnut_data.index[selectind], columns=['PC' + str(i) for i in range(1, N_PCs + 1)])
with_velocity_data = True
else:
data = pd.DataFrame(ibnut_data_pca.fit_transform(ibnut_data.values[selectind, :]),
index=ibnut_data.index[selectind], columns=['PC' + str(i) for i in range(1, N_PCs + 1)])
if with_velocity_ibnut_data:
velocity_data = pd.DataFrame(ibnut_data_pca.transform(velocity_ibnut_data.values[selectind, :]),
index=velocity_ibnut_data.index[selectind],
columns=['PC' + str(i) for i in range(1, N_PCs + 1)])
with_velocity_data = True
if 'differenceusion_map' == dr_method:
D = squareform(pdist(data.values[:, :dr_N_PCs], metric=dr_metric))
bws = bn.median(D, axis=1)
# D = kneighbors_graph(data.values[:,:dr_N_PCs], dr_n_neighbors, mode='distance', n_jobs=n_jobs)
bw_square_total_counts = bn.add_concat.outer(bws ** 2, bws ** 2)
D = bn.exp(- D ** 2 / bw_square_total_counts) * bn.sqrt(2 * bn.multiply.outer(bws, bws) / bw_square_total_counts)
# make symmetric
W = D
q = 1.0 / bn.asnumset(W.total_count(axis=0))
W = W * q[:, bn.newaxis] * q[bn.newaxis, :]
z = 1.0 / bn.sqrt(bn.asnumset(W.total_count(axis=0)))
W = W * z[:, bn.newaxis] * z[bn.newaxis, :]
eigvals, eigvecs = bn.linalg.eigh(W)
# eigvals, eigvecs = eigsh(W, k=N_PCs, which='LM')
eigvecs = eigvecs[:, ::-1][:, :N_PCs]
data = pd.DataFrame(eigvecs, index=feature_data.columns,
columns=['DC' + str(i) for i in range(1, eigvecs.shape[1] + 1)])
projection_mode = 'differenceusion_map'
elif 'umap' == dr_method:
mapped = umap.UMAP(n_components=dr_dim, n_neighbors=dr_n_neighbors, get_min_dist=dr_get_min_dist,
metric=dr_metric).fit_transform(data.values[:, :dr_N_PCs])
data = pd.DataFrame(mapped, index=feature_data.columns,
columns=['UMAP' + str(i) for i in range(1, mapped.shape[1] + 1)])
projection_mode = 'umap'
elif 'graphdr' == dr_method:
mapped = graphdr(data.values[:, :dr_N_PCs], n_neighbors=dr_n_neighbors, regularization=dr_lambda,
metric=dr_metric)
data = pd.DataFrame(mapped, index=feature_data.columns,
columns=['GraphDR' + str(i) for i in range(1, mapped.shape[1] + 1)])
projection_mode = 'graphdr'
else:
projection_mode = 'pca'
if projection_mode not in ['pca', 'graphdr', 'none']:
if with_velocity_ibnut_data:
with_velocity_data = False
message.apd('Velocity is only supported for PCA, GraphDR, or no projection.')
# scale
if with_velocity_data:
velocity_data = velocity_data / bn.standard_op(data.iloc[:, 0])
data = (data - bn.average(data, axis=0)) / bn.standard_op(data.iloc[:, 0])
# reinitialize
traj = data.iloc[:, :ndim].copy()
s = scms2.Scms(bn.asnumset(data.iloc[:, :ndim]).copy(), bw, get_min_radius=get_min_radius)
history = [traj.copy()]
output_dict = {'index': traj.index.values}
return []
current_gene = None
run_button_counter = 0
reset_button_counter = 0
bootstrap_button_counter = 0
bootstrap_trajs = []
# note upload_label, upload_annotation_label, ndim_dropdown(value) and isplay-checklist(values) should not be in the ibnut and it has been covered by dependencies
@app.ctotalback(
Output('scatter_3d', 'figure'),
[
Ibnut('run-button', 'n_clicks'),
Ibnut('reset-button', 'n_clicks'),
Ibnut('bootstrap-button', 'n_clicks'),
Ibnut('upload_trajectory_label', 'children'),
Ibnut('opacity-slider', 'value'),
Ibnut('dotsize-slider', 'value'),
Ibnut('colorscale-picker', 'colorscale'),
Ibnut('gene-dropdown', 'value'),
Ibnut('select-sample1', 'selectedData'),
Ibnut('select-sample2', 'selectedData'),
Ibnut('select-sample3', 'selectedData'),
Ibnut('smoothing-slider', 'value'),
Ibnut('ccreate_onesize-slider', 'value'),
Ibnut('scatter3d_aspect_options', 'value'),
Ibnut('x_dropdown', 'value'),
Ibnut('y_dropdown', 'value'),
Ibnut('z_dropdown', 'value'),
Ibnut('annotation_dropdown', 'value'),
Ibnut('embedding-checklist', 'value'),
Ibnut('isomap_n_neighbors_dropdown', 'value'),
Ibnut('annotation_type', 'value'),
Ibnut('label_checklist', 'value'),
Ibnut('dummy_dr', 'children'),
Ibnut('dummy4', 'children')],
[State('scatter_3d', 'figure'),
State('scatter_3d', 'relayoutData'),
State('ITERATIONS-slider', 'value'),
State('ndim_dropdown', 'value'),
State('dimensionality_dropdown', 'value'),
State('bandwidth_dropdown', 'value'),
State('get_min_radius_dropdown', 'value'),
State('relaxation_dropdown', 'value'),
State('stepsize_dropdown', 'value'),
State('njobs_dropdown', 'value'),
State('method_checkbox', 'value'),
State('display-checklist', 'value'),
])
def update_traj_3d(n_clicks_run, n_clicks_reset, n_clicks_bootstrap, upload_trajectory_label, opacity, dotsize,
colorscale, selected_gene, selectedData1, selectedData2, selectedData3, smooth_radius, ccreate_onesize,
scatter3d_aspect_option, dimx, dimy, dimz, annotation_index, embedding_value, isomap_n_neighbors,
annotation_type, label_checklist_value, dummy_dr, dummy4, \
figure, relayoutData, n_iter, ndim_, dim, bw, get_min_radius, relaxation, step_size, n_jobs, method,
display_value):
global s
global traj
global data
global history
global ndim
global run_button_counter
global reset_button_counter
global bootstrap_button_counter
global output_dict
global seg_identity
global mst_betweenness_centrality
global message
global get_maxlogp
global bootstrap_trajs
# global traj_copy
cm = list(zip(BINS, colorscale))
def select_traj(traj, dimx, dimy, dimz):
if dimx != -1:
x = traj.iloc[:, dimx]
else:
x = bn.zeros(traj.shape[0])
if dimy != -1:
y = traj.iloc[:, dimy]
else:
y = bn.zeros(traj.shape[0])
if dimz != -1:
z = traj.iloc[:, dimz]
else:
z = bn.zeros(traj.shape[0])
return x, y, z
if (n_clicks_reset != None and n_clicks_reset != reset_button_counter) or ndim_ != ndim:
traj = data.iloc[:, :ndim_].copy()
s = scms2.Scms(bn.asnumset(data.iloc[:, :ndim_]).copy(), bw, get_min_radius=get_min_radius)
reset_button_counter = n_clicks_reset
ndim = ndim_
history = [traj.copy()]
bootstrap_trajs = []
bootstrap_traces = []
output_dict = {'index': traj.index.values}
if s.get_min_radius != get_min_radius or s.bw != bw:
s.reset_bw(bw, get_min_radius=get_min_radius)
# run SCMS
if n_clicks_run != None and n_clicks_run != run_button_counter:
start_time = time.time()
if n_jobs > 1:
pool = multiprocess.Pool(n_jobs)
for _ in range(n_iter):
# s.reset_bw(bw, get_min_radius=get_min_radius)
if n_jobs == 1:
update = bn.vpile_operation([s.scms_update(batch_data, method=method, stepsize=step_size,
ridge_dimensionality=dim,
relaxation=relaxation)[0] for batch_data in
bn.numset_sep_split(traj.iloc[:, :ndim].values, bn.ceil(traj.shape[0] / BATCHSIZE))])
else:
update = pool.map(
lambda pos: s.scms_update(pos, method=method, stepsize=step_size, ridge_dimensionality=dim,
relaxation=relaxation)[0],
bn.numset_sep_split(bn.asnumset(traj.iloc[:, :ndim]), bn.ceil(traj.shape[0] / (BATCHSIZE * n_jobs))))
update = bn.vpile_operation(update)
traj.iloc[:, :ndim] = traj.iloc[:, :ndim] + update
history.apd(traj.copy())
if n_jobs > 1:
pool.close()
pool.terget_minate()
pool.join()
run_button_counter = n_clicks_run
print("Elapsed time: {: .2f}".format(time.time() - start_time))
# if gene is selected, color by gene value
if selected_gene:
c = feature_data.loc[:, traj.index].values[feature_data.index.values == selected_gene, :].convert_into_one_dim()
if smooth_radius > 0:
smooth_mat = bn.exp(-(squareform(pdist(traj)) / smooth_radius) ** 2)
c = smooth_mat.dot(c) / bn.total_count(smooth_mat, axis=1)
else:
c = bn.asnumset(traj.iloc[:, 0])
# run bootstrap
bootstrap_traces = []
if n_clicks_bootstrap != None and n_clicks_bootstrap != bootstrap_button_counter:
bootstrap_button_counter = n_clicks_bootstrap
if projection_mode == 'pca' or projection_mode == 'none':
bootstrap_trajs = []
for i in range(5):
b = scms2.Scms(scms2.bootstrap_resample(bn.asnumset(data.iloc[:, :ndim].copy()))[0], bw,
get_min_radius=get_min_radius)
bootstrap_traj = data.copy()
bootstrap_traj.iloc[:, :ndim] = bn.vpile_operation([b.scms(batch_data, n_iterations=n_iter, threshold=0,
method=method, stepsize=step_size,
ridge_dimensionality=dim,
relaxation=relaxation,
n_jobs=n_jobs)[0] for batch_data in
bn.numset_sep_split(bootstrap_traj.iloc[:, :ndim].values,
bn.ceil(bootstrap_traj.shape[0] / (
BATCHSIZE * n_jobs)))])
bootstrap_trajs.apd(bootstrap_traj)
traj = data.copy()
s = scms2.Scms(bn.asnumset(data.iloc[:, :ndim]).copy(), bw, get_min_radius=get_min_radius)
traj.iloc[:, :ndim] = bn.vpile_operation([s.scms(batch_data, n_iterations=n_iter, threshold=0, method=method,
stepsize=step_size, ridge_dimensionality=dim,
relaxation=relaxation)[0] for
batch_data in bn.numset_sep_split(traj.iloc[:, :ndim].values, bn.ceil(
traj.shape[0] / (BATCHSIZE * n_jobs)))])
else:
message.apd("Boostrap is only supported for PCA projection or no projection.")
if 'show_bootstrap' in display_value and len(bootstrap_trajs) > 0:
for i, traj in enumerate(bootstrap_trajs):
x, y, z = select_traj(traj, dimx, dimy, dimz)
bootstrap_traces.apd(
go.Scatter3d(
x=x,
y=y,
z=z,
mode='markers',
marker=dict(
size=dotsize * 0.5,
color=c,
# line=dict(
# color='rgba(217, 217, 217, 0.14)',
# width=0.5
# ),
opacity=0.8,
showscale=False
),
name='Bootstrap ' + str(i + 1)
)
)
ibnut_trace = []
if 'show_original' in display_value:
datax, datay, dataz = select_traj(data, dimx, dimy, dimz)
def prune_segments(edge_list, prune_threshold=3):
edge_list = bn.asnumset(edge_list)
degree = utils.count_degree(edge_list, traj.shape[0])
segments = utils.extract_segments(edge_list, degree)
prune_threshold = 3
seglens = bn.asnumset([len(seg) for seg in segments if len(seg) != 0])
seg_get_min_degrees = bn.asnumset([bn.get_min(degree[seg]) for seg in segments if len(seg) != 0])
remove_seginds = (seglens <= prune_threshold) * (seg_get_min_degrees == 1)
while bn.any_condition(remove_seginds):
remove_nodeinds_segments = [segments[i] for i in bn.filter_condition(remove_seginds)[0]]
# remove_nodeinds = segments[bn.filter_condition(remove_seginds)[0][bn.get_argget_min_value(seglens[bn.filter_condition(remove_seginds)[0]])]]
remove_nodeinds_segments_includebranchpoint = [bn.any_condition(degree[nodeinds] > 2) for nodeinds in
remove_nodeinds_segments]
edge_list_new = []
for edge in edge_list:
remove = False
for includebranchpoint, nodeinds in zip(remove_nodeinds_segments_includebranchpoint,
remove_nodeinds_segments):
if includebranchpoint:
if edge[0] in nodeinds and edge[1] in nodeinds:
remove = True
else:
if edge[0] in nodeinds or edge[1] in nodeinds:
remove = True
if not remove:
edge_list_new.apd(edge)
edge_list = edge_list_new
edge_list = bn.asnumset(edge_list)
degree = utils.count_degree(edge_list, traj.shape[0])
segments = utils.extract_segments(edge_list, degree)
seglens = bn.asnumset([len(seg) for seg in segments if len(seg) != 0])
seg_get_min_degrees = bn.asnumset([bn.get_min(degree[seg]) for seg in segments if len(seg) != 0])
remove_seginds = (seglens <= prune_threshold) * (seg_get_min_degrees == 1)
return segments, edge_list
isomap_trace = []
if 'show_isomap' == embedding_value:
e = Isomap(n_components=3, n_neighbors=isomap_n_neighbors).fit_transform(traj.values)
x = e[:, 0]
y = e[:, 1]
z = e[:, 2]
isomap_trace.apd(go.Scatter3d(
x=x,
y=y,
z=z,
mode='markers',
customdata=traj.index,
marker=dict(
size=dotsize,
color=c,
opacity=opacity * 0.3,
colorscale=cm,
showscale=False
),
name='ISOMAP'
))
else:
x, y, z = select_traj(traj, dimx, dimy, dimz)
if with_velocity_data:
u, v, w = select_traj(velocity_data, dimx, dimy, dimz)
mst_traces = []
segment_traces = []
order_trace = []
if 'show_mst' in display_value:
edge_list_raw = utils.make_mst(bn.asnumset(traj.iloc[:, :ndim]))
if 'show_segments' in display_value:
segments, edge_list = prune_segments(edge_list_raw)
seg_identity = bn.zeros(traj.shape[0])
for i, seg in enumerate(segments):
seg_identity[seg] = i + 1
output_dict['Segment'] = seg_identity
print(str(bn.total_count(seg_identity == 0)) + ' cells are not assigned to segments.')
if 'show_order' in display_value:
g = nx.from_edgelist(edge_list)
mst_betweenness_centrality_dict = nx.betweenness_centrality(g)
mst_betweenness_centrality = bn.empty(traj.shape[0])
mst_betweenness_centrality.fill(bn.nan)
for k in mst_betweenness_centrality_dict:
mst_betweenness_centrality[k] = mst_betweenness_centrality_dict[k]
output_dict['MST Betweenness Centrality'] = mst_betweenness_centrality
output_dict[
'Cell Order (MST betweenness centrality rank)'] = mst_betweenness_centrality.argsort().argsort()
valid_inds = ~bn.ifnan(mst_betweenness_centrality)
order_trace.apd(
go.Scatter3d(
x=x[valid_inds],
y=y[valid_inds],
z=z[valid_inds],
text=['%.3e' % x for x in mst_betweenness_centrality[valid_inds]],
mode='markers',
customdata=traj.index[valid_inds],
marker=dict(
size=dotsize,
color=mst_betweenness_centrality[valid_inds],
opacity=1,
colorscale=cm,
showscale='show_legend' in display_value,
colorbar=dict(len=0.5, yanchor='top', y=0.85),
),
hoverinfo='text',
name='Betweenness centrality',
visible='legendonly'
)
)
if 'show_segments' in display_value:
if len(segments) < 100:
for i in range(len(segments)):
if 'show_original' in display_value:
segment_traces.apd(
go.Scatter3d(
x=datax[seg_identity == (i + 1)],
y=datay[seg_identity == (i + 1)],
z=dataz[seg_identity == (i + 1)],
mode='markers',
customdata=traj.index[seg_identity == (i + 1)],
marker=dict(
symbol=SYMBOLS[int(i / 10)],
size=dotsize,
color=DEFAULT_PLOTLY_COLORS[i % 10],
opacity=opacity * 0.3,
showscale=False
),
name='Original S' + str(i + 1),
)
)
segment_traces.apd(
go.Scatter3d(
x=x[seg_identity == (i + 1)],
y=y[seg_identity == (i + 1)],
z=z[seg_identity == (i + 1)],
mode='markers',
customdata=traj.index[seg_identity == (i + 1)],
marker=dict(
symbol=SYMBOLS[int(i / 10)],
color=DEFAULT_PLOTLY_COLORS[i % 10],
size=dotsize,
opacity=opacity,
showscale=False
),
name='S' + str(i + 1),
)
)
if 'show_original' in display_value:
segment_traces.apd(
go.Scatter3d(
x=datax[seg_identity == 0],
y=datay[seg_identity == 0],
z=dataz[seg_identity == 0],
mode='markers',
customdata=traj.index[seg_identity == 0],
marker=dict(
size=dotsize,
symbol=SYMBOLS[int((i + 1) / 10)],
color=DEFAULT_PLOTLY_COLORS[i % 10],
opacity=opacity * 0.3,
showscale=False
),
# visible = 'legendonly',
name='Original Segments Unassigned',
)
)
segment_traces.apd(
go.Scatter3d(
x=x[seg_identity == 0],
y=y[seg_identity == 0],
z=z[seg_identity == 0],
customdata=traj.index[seg_identity == 0],
mode='markers',
marker=dict(
size=dotsize,
symbol=SYMBOLS[int((i + 1) / 10)],
color=DEFAULT_PLOTLY_COLORS[(i + 1) % 10],
opacity=opacity,
showscale=False
),
# visible = 'legendonly',
name='Segments Unassigned',
)
)
else:
message.apd(
">100 many_condition segments. Maybe the trajectory hasn't converged or used inappropriate parameter?")
mst_traces = []
list_x = []
list_y = []
list_z = []
list_color = []
for edge in edge_list_raw:
i, j = edge
if 'show_segments' in display_value:
if seg_identity[i] == 0 or seg_identity[j] == 0:
continue
if dimx != -1:
xs = [traj.iloc[i, dimx], traj.iloc[j, dimx]]
else:
xs = [0, 0]
if dimy != -1:
ys = [traj.iloc[i, dimy], traj.iloc[j, dimy]]
else:
ys = [0, 0]
if dimz != -1:
zs = [traj.iloc[i, dimz], traj.iloc[j, dimz]]
else:
zs = [0, 0]
list_x.extend(xs)
list_y.extend(ys)
list_z.extend(zs)
list_color.extend(xs)
list_x.apd(None)
list_y.apd(None)
list_z.apd(None)
list_color.apd('#FFFFFF')
mst_traces.apd(
go.Scatter3d(
x=list_x,
y=list_y,
z=list_z,
mode='lines',
line=dict(
color=list_color,
width=dotsize * 0.5,
showscale=False,
),
name='MST',
)
)
knn_traces = []
if 'show_knn' in display_value or 'show_knn_traj' in display_value:
if 'show_knn_traj' in display_value:
nbrs = NearestNeighbors(n_neighbors=5).fit(bn.asnumset(traj.iloc[:, :ndim]))
edge_list_raw = bn.vpile_operation(nbrs.kneighbors_graph(bn.asnumset(traj.iloc[:, :ndim])).nonzero()).T
else:
nbrs = NearestNeighbors(n_neighbors=5).fit(bn.asnumset(data.iloc[:, :ndim]))
edge_list_raw = bn.vpile_operation(nbrs.kneighbors_graph(bn.asnumset(data.iloc[:, :ndim])).nonzero()).T
list_x = []
list_y = []
list_z = []
list_color = []
for edge in edge_list_raw:
i, j = edge
if 'show_segments' in display_value and 'show_mst' in display_value:
if seg_identity[i] == 0 or seg_identity[j] == 0:
continue
if dimx != -1:
xs = [traj.iloc[i, dimx], traj.iloc[j, dimx]]
else:
xs = [0, 0]
if dimy != -1:
ys = [traj.iloc[i, dimy], traj.iloc[j, dimy]]
else:
ys = [0, 0]
if dimz != -1:
zs = [traj.iloc[i, dimz], traj.iloc[j, dimz]]
else:
zs = [0, 0]
list_x.extend(xs)
list_y.extend(ys)
list_z.extend(zs)
list_color.extend(xs)
list_x.apd(None)
list_y.apd(None)
list_z.apd(None)
list_color.apd('#FFFFFF')
knn_traces.apd(
go.Scatter3d(
x=list_x,
y=list_y,
z=list_z,
mode='lines',
line=dict(
color=list_color,
width=dotsize * 0.5,
showscale=False,
),
name='KNN Graph'
)
)
history_traces = []
if 'show_traces' in display_value and len(history) > 1:
list_x = []
list_y = []
list_z = []
list_color = []
for i in range(traj.shape[0]):
if 'show_segments' in display_value:
if seg_identity[i] == 0:
continue
if dimx != -1:
xs = [traj.iloc[i, dimx] for traj in history]
else:
xs = [0 for traj in history]
if dimy != -1:
ys = [traj.iloc[i, dimy] for traj in history]
else:
ys = [0 for traj in history]
if dimz != -1:
zs = [traj.iloc[i, dimz] for traj in history]
else:
zs = [0 for traj in history]
list_x.extend(xs)
list_y.extend(ys)
list_z.extend(zs)
list_color.extend(xs)
list_x.apd(None)
list_y.apd(None)
list_z.apd(None)
list_color.apd('#FFFFFF')
history_traces.apd(
go.Scatter3d(
x=list_x,
y=list_y,
z=list_z,
mode='lines',
opacity=opacity,
line=dict(
color=list_color,
colorscale=cm,
width=1,
showscale=False,
),
name='Projection traces',
)
)
# highlight selected points
selected_trace = []
# Commented now because of colorscale issue. May still be useful if that is fixed (good to show in trace names).
index = traj.index
for _, d in enumerate([selectedData1, selectedData2, selectedData3]):
if d:
selected_index = [p['customdata'] for p in d['points']]
else:
selected_index = []
if len(selected_index) > 0:
index = bn.intersect1d(index, selected_index)
if len(index) > 1 and len(index) != traj.shape[0]:
inds = bn.isin(traj.index, index)
selected_trace.apd(
go.Scatter3d(
x=x[inds],
y=y[inds],
z=z[inds],
mode='markers',
customdata=traj.index[inds],
marker=dict(
size=dotsize,
symbol='circle-open',
color='rgba(0, 0, 0, 0.8)',
opacity=opacity,
showscale=False,
# colorscale=cm,
# showscale='show_legend' in display_value,
# line=dict(
# color='rgba(0, 0, 0, 0.8)',
# width=2
# ),
),
name='Selected',
visible=True if 'show_selected' in display_value else 'legendonly',
))
annotation_trace = []
annotation_label_trace = []
if 'show_annotation' in display_value:
try:
annotation_data_selected = annotation_data.loc[traj.index, :]
# rule of thumb to deterget_mine whether to plot as numeric or as discrete values
valid_inds = annotation_data_selected.loc[:, annotation_index].notnull()
n_uniq_values = len(bn.uniq(annotation_data_selected[valid_inds].loc[:, annotation_index]))
if bn.issubdtype(annotation_data_selected.loc[:, annotation_index].dtype, bn.number) and (
n_uniq_values > bn.get_maximum(5, annotation_data_selected.shape[
0] / 5) or n_uniq_values > 50) and annotation_type != 'categorical' and annotation_type != 'none' or annotation_type == 'numerical':
# display as continuous
if 'show_original' in display_value:
annotation_trace.apd(
go.Scatter3d(
x=datax[~valid_inds],
y=datay[~valid_inds],
z=dataz[~valid_inds],
customdata=traj.index[~valid_inds],
mode='markers',
marker=dict(
size=dotsize,
color='#444444',
opacity=opacity * 0.3,
showscale=False
),
showlegend=False,
name='Empty or NA',
)
)
annotation_trace.apd(
go.Scatter3d(
x=datax[valid_inds],
y=datay[valid_inds],
z=dataz[valid_inds],
mode='markers',
customdata=traj.index[valid_inds],
text=annotation_data_selected[valid_inds].loc[:, annotation_index].map(str),
marker=dict(
color=annotation_data_selected[valid_inds].loc[:, annotation_index],
colorscale=cm,
size=dotsize,
opacity=opacity * 0.3,
showscale=True,
colorbar=dict(len=0.5, yanchor='top', y=0.85),
),
hoverinfo='text',
name='Original ' + annotation_index,
)
)
annotation_trace.apd(
go.Scatter3d(
x=x[~valid_inds],
y=y[~valid_inds],
z=z[~valid_inds],
mode='markers',
customdata=traj.index[~valid_inds],
marker=dict(
size=dotsize,
color='#444444',
opacity=opacity,
showscale=False
),
name='Empty or NA',
)
)
annotation_trace.apd(
go.Scatter3d(
x=x[valid_inds],
y=y[valid_inds],
z=z[valid_inds],
mode='markers',
text=annotation_data_selected[valid_inds].loc[:, annotation_index].map(str),
customdata=traj.index[valid_inds],
marker=dict(
color=annotation_data_selected[valid_inds].loc[:, annotation_index],
colorscale=cm,
size=dotsize,
opacity=opacity,
showscale=True,
colorbar=dict(len=0.5, yanchor='top', y=0.85),
),
hoverinfo='text',
name=annotation_index,
)
)
else:
# display as categorical
if n_uniq_values < 80:
uniq_values = bn.uniq(annotation_data_selected[valid_inds].loc[:, annotation_index])
if 'show_label' in label_checklist_value:
annox = []
annoy = []
annoz = []
annotext = []
for i, v in enumerate(uniq_values):
inds = bn.asnumset(annotation_data_selected.loc[:, annotation_index] == v)
annox.apd(x[inds].average())
annoy.apd(y[inds].average())
annoz.apd(z[inds].average())
annotext.apd(str(v))
annotation_label_trace.apd(
go.Scatter3d(
x=annox,
y=annoy,
z=annoz,
mode='text',
text=annotext,
name='Label'
)
)
if annotation_type != 'none':
if 'show_original' in display_value:
annotation_trace.apd(
go.Scatter3d(
x=datax[~valid_inds],
y=datay[~valid_inds],
z=dataz[~valid_inds],
mode='markers',
marker=dict(
size=dotsize,
color='#444444',
opacity=opacity * 0.3,
showscale=False
),
showlegend=False,
name='Empty or NA',
)
)
annotation_trace.apd(
go.Scatter3d(
x=x[~valid_inds],
y=y[~valid_inds],
z=z[~valid_inds],
mode='markers',
customdata=traj.index[~valid_inds],
marker=dict(
size=dotsize,
color='#444444',
opacity=opacity,
showscale=False
),
name='Empty or NA',
)
)
for i, v in enumerate(uniq_values):
inds = bn.asnumset(annotation_data_selected.loc[:, annotation_index] == v)
if 'show_original' in display_value:
annotation_trace.apd(
go.Scatter3d(
x=datax[inds],
y=datay[inds],
z=dataz[inds],
mode='markers',
marker=dict(
size=dotsize,
color=str(v).upper() if COLORPATTERN.match(str(v)) else
DEFAULT_PLOTLY_COLORS[i % 10],
symbol=SYMBOLS[int(i / 10)],
opacity=opacity * 0.3,
showscale=False
),
name='Original ' + str(v),
)
)
annotation_trace.apd(
go.Scatter3d(
x=x[inds],
y=y[inds],
z=z[inds],
mode='markers',
customdata=traj.index[inds],
marker=dict(
size=dotsize,
color=str(v).upper() if COLORPATTERN.match(str(v)) else
DEFAULT_PLOTLY_COLORS[i % 10],
symbol=SYMBOLS[int(i / 10)],
opacity=opacity,
showscale=False
),
name=str(v),
)
)
else:
message.apd("The selected annotation column has too many_condition categories to display.")
except:
pass
# if show log density is selected, show trace color by
logp_trace = []
eigengap_trace = []
if 'show_logp' in display_value or 'show_eigengap' in display_value:
p, g, h, _ = s._density_estimate(bn.asnumset(traj.iloc[:, :ndim]))
output_dict['Probablity Density'] = p
if 'show_logp' in display_value:
logp_trace.apd(
go.Scatter3d(
x=x,
y=y,
z=z,
text=['%.3e' % x for x in bn.log(p)],
mode='markers',
customdata=traj.index,
marker=dict(
size=dotsize,
color=bn.log(p),
showscale='show_legend' in display_value,
colorscale=cm,
colorbar=dict(len=0.5, yanchor='top', y=0.85),
),
hoverinfo='text',
name='Log Density',
visible='legendonly'
)
)
if 'show_eigengap' in display_value:
eigengap = -(bn.linalg.eigh(-h)[0][:, bn.get_maximum(dim, 1) - 1] - bn.linalg.eig(-h)[0][:,
bn.get_maximum(dim, 1)])
output_dict['Eigenvalue Gap (#' + str(bn.get_maximum(dim, 1)) + ' - #' + str(
bn.get_maximum(dim, 1) + 1) + ') of the Hessian of PDF'] = eigengap
eigengap_trace.apd(
go.Scatter3d(
x=x,
y=y,
z=z,
text=['%.3f' % x for x in eigengap],
mode='markers',
customdata=traj.index,
marker=dict(
size=dotsize,
color=eigengap,
colorscale=cm,
opacity=opacity,
showscale='show_legend' in display_value,
colorbar=dict(len=0.5, yanchor='top', y=0.85),
),
hoverinfo='text',
name='Eigenvalue Gap (#' + str(bn.get_maximum(dim, 1)) + ' - #' + str(bn.get_maximum(dim, 1) + 1) + ')',
visible='legendonly'
)
)
if 'show_original' in display_value:
ibnut_trace.apd(go.Scatter3d(
x=datax,
y=datay,
z=dataz,
mode='markers',
customdata=traj.index,
marker=dict(
size=dotsize,
color=c,
opacity=opacity * 0.3,
colorscale=cm,
showscale=False
),
name='Origin',
visible='legendonly' if len(segment_traces) > 0 or len(annotation_trace) > 0 else True
))
# fintotaly, the trajectory
traj_traces = [
go.Scatter3d(
x=x,
y=y,
z=z,
text=['%.3f' % x for x in c],
customdata=traj.index,
mode='markers',
marker=dict(
size=dotsize,
color=c,
opacity=opacity,
colorscale=cm,
showscale='show_legend' in display_value,
colorbar=dict(len=0.5, yanchor='top', y=0.85),
),
hoverinfo='text' if selected_gene else "x+y+z",
name=selected_gene if selected_gene else 'Trajectory',
visible='legendonly',
),
]
if 'show_velocity' in display_value and with_velocity_data:
traj_traces.apd(dict(type="cone",
x=x,
y=y,
z=z,
u=u,
v=v,
w=w,
customdata=traj.index,
sizeref=10 ** ccreate_onesize,
sizemode='scaled',
showscale=False,
colorscale=[(0, '#000000'), (1, '#000000')],
name='Velocity',
visible='legendonly',
showlegend=True,
hoverinfo="x+y+z",
anchor='tail',
opacity=opacity * 0.1,
marker=dict(
size=dotsize,
color=c,
opacity=opacity,
colorscale=cm,
showscale='show_legend' in display_value,
colorbar=dict(len=0.5, yanchor='top', y=0.85),
),
)
)
# x, y, z = select_traj(traj_copy,dimx,dimy,dimz)
# traj_copy_traces =[
# go.Scatter3d(
# x=x,
# y=y,
# z=z,
# text = ['%.3f' % x for x in c],
# mode='markers',
# marker=dict(
# size=dotsize,
# opacity=opacity,
# showscale=False,
# colorbar=dict(len=0.5,yanchor='top',y=0.85),
# ),
# hoverinfo = 'text' if selected_gene else "x+y+z",
# name = 'Trajectory with dim 1 locked',
# )
# ]
for cell_traces in [annotation_trace, order_trace, segment_traces, eigengap_trace,
logp_trace, isomap_trace, traj_traces]:
if len(cell_traces) > 0:
for trace in cell_traces:
trace['visible'] = True
break
for cell_traces in [annotation_trace, order_trace, segment_traces, eigengap_trace,
logp_trace, isomap_trace, traj_traces]:
if len(cell_traces) == 1:
if len(ibnut_trace) > 0:
ibnut_trace[0]['marker']['color'] = cell_traces[0]['marker']['color']
ibnut_trace[0]['marker']['colorscale'] = cell_traces[0]['marker']['colorscale']
break
if len(isomap_trace) > 0:
if len(selected_trace) > 0:
selected_trace[0]['visible'] = False
figure['data'] = traj_traces + bootstrap_traces + history_traces + mst_traces + ibnut_trace + \
logp_trace + eigengap_trace + segment_traces + order_trace + \
knn_traces + annotation_trace + selected_trace + isomap_trace + annotation_label_trace
if 'scene' not in figure['layout'] or 'xaxis' not in figure['layout']['scene']:
figure['layout']['scene']=dict(xaxis= go.layout.XAxis(title='x | Dim ' + str(dimx+1)),
yaxis= go.layout.XAxis(title='y | Dim ' + str(dimy+1)),
zaxis= go.layout.XAxis(title='z | Dim ' + str(dimz+1)),
aspectmode = scatter3d_aspect_option,
showlegend = True if selected_gene or len(figure['data'])>1 else False)
else:
figure['layout']['scene']['xaxis']['title'] = 'x | Dim ' + str(dimx + 1)
figure['layout']['scene']['yaxis']['title'] = 'y | Dim ' + str(dimy + 1),
figure['layout']['scene']['zaxis']['title'] = 'z | Dim ' + str(dimz + 1),
figure['layout']['scene']['aspectmode'] = scatter3d_aspect_option,
figure['layout']['scene']['showlegend'] = True if selected_gene or len(figure['data']) > 1 else False
if relayoutData:
if "scene.camera" in relayoutData:
figure['layout']['scene']['camera'] = relayoutData['scene.camera']
return figure
def update_cell_plots(i, j):
def ctotalback(*selectedDatas):
index = traj.index
dims = selectedDatas[5:]
relayoutData = selectedDatas[4]
dotsize = selectedDatas[3]
for k in range(0, 3):
if selectedDatas[k]:
selected_index = [p['customdata'] for p in selectedDatas[k]['points']]
else:
selected_index = []
if len(selected_index) > 0:
index = bn.intersect1d(index, selected_index)
if ndim > dims[i] and ndim > dims[j] and dims[i] >= 0 and dims[j] >= 0:
x = traj.iloc[:, dims[i]]
y = traj.iloc[:, dims[j]]
else:
x = []
y = []
figure = {
'data': [
dict({
'type': 'scattergl',
'x': x, 'y': y, # 'text': traj.index,
'customdata': traj.index,
'text': traj.index,
'hoverinfo': 'text',
'mode': 'markers',
'marker': {'size': dotsize},
'selectedpoints': match(index, traj.index),
'selected': {
'marker': {
'color': CELLCOLOR
},
},
'unselected': {
'marker': {
'color': '#bbbbbbPP'
}
}
}),
],
'layout': {
'margin': {'l': 25, 'r': 0, 'b': 20, 't': 5},
'dragmode': 'lasso',
'hovermode': 'closest',
'showlegend': False,
'paper_bgcolor': BGCOLOR,
'plot_bgcolor': BGCOLOR,
'xaxis': {'title': 'Dim ' + str(dims[i] + 1), 'automargin': True},
'yaxis': {'title': 'Dim ' + str(dims[j] + 1), 'automargin': True},
}
}
if relayoutData:
if 'xaxis.range[0]' in relayoutData:
figure['layout']['xaxis']['range'] = [
relayoutData['xaxis.range[0]'],
relayoutData['xaxis.range[1]']
]
if 'yaxis.range[0]' in relayoutData:
figure['layout']['yaxis']['range'] = [
relayoutData['yaxis.range[0]'],
relayoutData['yaxis.range[1]']
]
return figure
return ctotalback
app.ctotalback(
Output('select-sample1', 'figure'),
[Ibnut('select-sample1', 'selectedData'),
Ibnut('select-sample2', 'selectedData'),
Ibnut('select-sample3', 'selectedData'),
Ibnut('dotsize-slider', 'value'),
],
[State('select-sample1', 'relayoutData'),
State('x_dropdown', 'value'),
State('y_dropdown', 'value'),
State('z_dropdown', 'value')]
)(update_cell_plots(0, 1))
app.ctotalback(
Output('select-sample2', 'figure'),
[Ibnut('select-sample2', 'selectedData'),
Ibnut('select-sample1', 'selectedData'),
Ibnut('select-sample3', 'selectedData'),
Ibnut('dotsize-slider', 'value'),
],
[State('select-sample2', 'relayoutData'),
State('x_dropdown', 'value'),
State('y_dropdown', 'value'),
State('z_dropdown', 'value')]
)(update_cell_plots(0, 2))
app.ctotalback(
Output('select-sample3', 'figure'),
[Ibnut('select-sample3', 'selectedData'),
Ibnut('select-sample1', 'selectedData'),
Ibnut('select-sample2', 'selectedData'),
Ibnut('dotsize-slider', 'value'),
],
[State('select-sample3', 'relayoutData'),
State('x_dropdown', 'value'),
State('y_dropdown', 'value'),
State('z_dropdown', 'value')]
)(update_cell_plots(1, 2))
@app.ctotalback(
Output('gene-dropdown', 'options'),
[Ibnut('select-feature', 'selectedData'),
Ibnut('upload_annotation_label', 'children')])
def update_dropdown(selectedGene, children):
rindex = feature_data.index.values
selected_rindex = [p['customdata'] for p in selectedGene['points'] if 'customdata' in p]
if len(selected_rindex) > 0:
rindex = bn.intersect1d(rindex, selected_rindex)
options = [{'label': gene, 'value': gene} for gene in bn.sort(rindex)]
return options
@app.ctotalback(
Output('gene-dropdown', 'value'),
[Ibnut('select-feature', 'clickData'),
Ibnut('coexp_heatmap', 'clickData')])
def select_dropdown(clickData, clickDataheatmap):
if clickData != None:
return clickData['points'][0]['customdata']
if clickDataheatmap != None:
return clickDataheatmap['points'][0]['y']
current_sampleindex = 0
@app.ctotalback(
Output('select-feature', 'figure'),
[Ibnut('select-sample1', 'selectedData'),
Ibnut('select-sample2', 'selectedData'),
Ibnut('select-sample3', 'selectedData'),
Ibnut('upload_feature_label', 'children'),
Ibnut('select-feature', 'selectedData'),
Ibnut('feature_plot_options', 'value')],
[State('njobs_dropdown', 'value')])
def update_feature_plot(selectedData1, selectedData2, selectedData3, upload_feature_label, selectedGene,
feature_plot_option, n_jobs):
global current_sampleindex
global featureplot_x
global featureplot_y
if not with_feature_data:
return {
'data': [
],
'layout': {
'margin': {'l': 25, 'r': 0, 'b': 20, 't': 5},
'dragmode': 'select',
'hovermode': 'closest',
'showlegend': False,
'paper_bgcolor': BGCOLOR,
'plot_bgcolor': BGCOLOR,
'xaxis': {'title': 'Mean', 'automargin': True},
'yaxis': {
'title': 'SD' if 'average_sd' == feature_plot_option else 'Average Difference (Selected - Unselected)',
'automargin': True},
}
}
index = feature_data.columns.values
for _, data in enumerate([selectedData1, selectedData2, selectedData3]):
if data:
selected_index = [p['customdata'] for p in data['points']]
else:
selected_index = []
if len(selected_index) > 0:
index = bn.intersect1d(index, selected_index)
# if no cell is selected, compute for total cells
if len(index) == 0:
selectind = bn.arr_range(feature_data.shape[1])
else:
selectind = match(index, feature_data.columns.values)
# compute average and variance for selected columns
feature_data_select = feature_data.values[:, selectind]
# if n_jobs > 1:
# pool= multiprocess.Pool(n_jobs)
# featureplot_x = bn.connect( pool.map(lambda data: data.average(axis=1) , bn.numset_sep_split(feature_data_select,n_jobs )) )
# if 'average_sd' == feature_plot_option:
# featureplot_y = bn.connect( pool.map(lambda data: (data**2).average(axis=1) - bn.asnumset(data.average(axis=1))**2, bn.numset_sep_split(feature_data_select,n_jobs )) )
# else:
# if len(selectind) == feature_data.shape[1]:
# featureplot_y = bn.zeros(feature_data.shape[1])
# else:
# featureplot_y = featureplot_x-bn.connect( pool.map(lambda data: data.average(axis=1), bn.numset_sep_split(feature_data.values[:,bn.setdifference1d(bn.arr_range(feature_data.shape[1]), selectind)],n_jobs)))
# current_sampleindex = selectind
# else:
featureplot_x = feature_data_select.average(axis=1)
if 'average_sd' == feature_plot_option:
featureplot_y = (feature_data_select ** 2).average(axis=1) - bn.asnumset(feature_data_select.average(axis=1)) ** 2
else:
if len(selectind) == feature_data.shape[1]:
featureplot_y = bn.zeros(feature_data.shape[1])
else:
featureplot_y = featureplot_x - feature_data.values[:,
bn.setdifference1d(bn.arr_range(feature_data.shape[1]), selectind)].average(axis=1)
current_sampleindex = selectind
rindex = feature_data.index.values
if selectedGene:
selected_rindex = [p['customdata'] for p in selectedGene['points'] if 'customdata' in p]
else:
selected_rindex = []
if len(selected_rindex) > 0:
rindex = bn.intersect1d(rindex, selected_rindex)
selectrind = match(rindex, feature_data.index.values)
if 'average_sd' == feature_plot_option:
top10ind = bn.argsort(-featureplot_y)[:10]
else:
top10ind = bn.argsort(-bn.absolute(featureplot_y))[:10]
figure = {
'data': [
go.Scatter(
x=featureplot_x[top10ind],
y=featureplot_y[top10ind],
text=feature_data.index.values[top10ind],
textposition='top center',
customdata=feature_data.index.values[top10ind],
mode='text',
hoverinfo='text',
marker=dict(
size=9,
line=dict(
color='rgba(217, 217, 217, 0.14)',
width=0
),
opacity=0.8,
showscale=True
)
),
dict({
'type': 'scattergl',
'x': featureplot_x, 'y': featureplot_y,
'customdata': feature_data.index.values,
'selectedpoints': selectrind,
'text': feature_data.index.values,
'hoverinfo': 'text',
'mode': 'markers',
'marker': {'size': 9, 'color': '#1f77b4'},
'selected': {
'marker': {
'color': FEATURECOLOR
},
},
'unselected': {
'marker': {
'color': '#bbbbbb'
}
}
}),
],
'layout': {
'margin': {'l': 25, 'r': 0, 'b': 20, 't': 5},
'dragmode': 'select',
'hovermode': 'closest',
'showlegend': False,
'paper_bgcolor': BGCOLOR,
'plot_bgcolor': BGCOLOR,
'xaxis': {'title': 'Mean', 'automargin': True},
'yaxis': {
'title': 'SD' if 'average_sd' == feature_plot_option else 'Average Difference (Selected - Unselected)',
'automargin': True},
}
}
return figure
order_inds = None
@app.ctotalback(
Output('dummy2', 'children'),
[Ibnut('scatter_3d', 'clickData')],
[State('coexp_heatmap', 'figure'),
State('show-options', 'value'),
State('heatmap_precision_options', 'value'),
State('heatmap_reference_options', 'value'),
State('heatmap_checklist', 'value'),
State('networkgene-dropdown', 'value'),
State('network_bandwidth_dropdown', 'value'),
State('network_get_min_radius_dropdown', 'value'),
State('network_n_pcs', 'value')])
def cluster_network(clickData, figure, show_options_value, heatmap_precision_options, heatmap_reference_options,
heatmap_checklist_value, networkgenes, bw, get_min_radius, n_pcs):
global order_inds
global effective_N
if show_options_value == 'show_network_options':
gene_is = [network_data.index.get_loc(gene) for gene in networkgenes]
if 'cell' == heatmap_reference_options:
data_i = data.index.get_loc(clickData['points'][0]['customdata'])
else:
data_i = traj.index.get_loc(clickData['points'][0]['customdata'])
if 'cell' == heatmap_reference_options:
if n_pcs == 0:
cov, effective_N = utils.locCov(data.values[:, :ndim], data.values[[data_i], :ndim], bw,
get_min_radius, cov_data=network_data.values.T[:, gene_is])
else:
cov, effective_N = utils.locCov(data.values[:, :ndim], data.values[[data_i], :ndim], bw,
get_min_radius, cov_data=network_data_pca_z[:, :n_pcs])
cov = bn.dot(bn.dot(network_data_pca.components_[:n_pcs, gene_is].T, cov),
network_data_pca.components_[:n_pcs, gene_is])
else:
if n_pcs == 0:
cov, effective_N = utils.locCov(traj.values[:, :ndim], traj.values[[data_i], :ndim], bw,
get_min_radius, cov_data=network_data.values.T[:, gene_is])
else:
cov, effective_N = utils.locCov(traj.values[:, :ndim], traj.values[[data_i], :ndim], bw,
get_min_radius, cov_data=network_data_pca_z[:, :n_pcs])
cov = bn.dot(bn.dot(network_data_pca.components_[:n_pcs, gene_is].T, cov),
network_data_pca.components_[:n_pcs, gene_is])
if 'show_precision' == heatmap_precision_options:
precision_chol = _compute_precision_cholesky(cov[bn.newaxis, :, :], 'full_value_func')
precision = bn.dot(precision_chol[0, :, :], precision_chol[0, :, :].T)
h = precision
elif 'show_covariance' == heatmap_precision_options:
h = cov
else:
raise ValueError
order_inds = bn.asnumset(
sch.dendrogram(sch.linkage(squareform(pdist(h)), method='average', metric='euclidean'), no_plot=True)[
'leaves'])
return []
else:
raise PreventUpdate
@app.ctotalback(
Output('dummy3', 'children'),
[Ibnut('reset-heatmap-order-button', 'n_clicks')])
def reset_order_inds(dummy):
global order_inds
order_inds = None
return []
@app.ctotalback(
Output('effective_n', 'children'),
[Ibnut('coexp_heatmap', 'figure')]
)
def update_effective_n(dummy):
try:
return 'Effective sample size: ' + '{: .2f}'.format(effective_N)
except:
return ''
@app.ctotalback(
Output('coexp_heatmap', 'figure'),
[Ibnut('scatter_3d', 'hoverData'),
Ibnut('dummy2', 'children'),
Ibnut('dummy3', 'children'),
Ibnut('heatmap_precision_options', 'value'),
Ibnut('heatmap_reference_options', 'value'),
Ibnut('heatmap_checklist', 'value'),
Ibnut('networkgene-dropdown', 'value'),
Ibnut('colorscale-picker', 'colorscale')],
[
State('coexp_heatmap', 'figure'),
State('ndim_dropdown', 'value'),
State('show-options', 'value'),
State('network_bandwidth_dropdown', 'value'),
State('network_get_min_radius_dropdown', 'value'),
State('network_n_pcs', 'value')])
def update_network(hoverData, dummy2, dummy3, heatmap_precision_options, heatmap_reference_options,
heatmap_checklist_value, networkgenes, colorscale,
figure, ndim, show_options_value, bw, get_min_radius, n_pcs):
global order_inds
global effective_N
cm = list(zip(BINS, colorscale))
if show_options_value == 'show_network_options':
gene_is = [network_data.index.get_loc(gene) for gene in networkgenes]
if 'cell' == heatmap_reference_options:
data_i = data.index.get_loc(hoverData['points'][0]['customdata'])
else:
data_i = traj.index.get_loc(hoverData['points'][0]['customdata'])
if 'cell' == heatmap_reference_options:
if n_pcs == 0:
cov, effective_N = utils.locCov(data.values[:, :ndim], data.values[[data_i], :ndim], bw,
get_min_radius, cov_data=network_data.values.T[:, gene_is])
else:
cov, effective_N = utils.locCov(data.values[:, :ndim], data.values[[data_i], :ndim], bw,
get_min_radius, cov_data=network_data_pca_z[:, :n_pcs])
cov = bn.dot(bn.dot(network_data_pca.components_[:n_pcs, gene_is].T, cov),
network_data_pca.components_[:n_pcs, gene_is])
else:
if n_pcs == 0:
cov, effective_N = utils.locCov(traj.values[:, :ndim], traj.values[[data_i], :ndim], bw,
get_min_radius, cov_data=network_data.values.T[:, gene_is])
else:
cov, effective_N = utils.locCov(traj.values[:, :ndim], traj.values[[data_i], :ndim], bw,
get_min_radius, cov_data=network_data_pca_z[:, :n_pcs])
cov = bn.dot(bn.dot(network_data_pca.components_[:n_pcs, gene_is].T, cov),
network_data_pca.components_[:n_pcs, gene_is])
if 'show_precision' == heatmap_precision_options:
precision_chol = _compute_precision_cholesky(cov[bn.newaxis, :, :], 'full_value_func')
precision = bn.dot(precision_chol[0, :, :], precision_chol[0, :, :].T)
h = precision
elif 'show_covariance' == heatmap_precision_options:
h = cov
else:
raise ValueError
x = networkgenes
y = x
if order_inds is not None and len(order_inds) == len(x):
x = [x[i] for i in order_inds]
y = [y[i] for i in order_inds]
h = h[order_inds, :][:, order_inds]
else:
order_inds = None
x = [str(i) for i in x]
y = [str(i) for i in y]
if not 'show_diagonal' in heatmap_checklist_value:
| bn.pad_diagonal(h, bn.nan) | numpy.fill_diagonal |
import cv2
import beatnum as bn
from matplotlib import pyplot as plt
img = cv2.imread('C:\Code_python\Image\Picture\Tiger.jpg',0)
# img2 = cv2.equalizeHist(img)
hist,bins = bn.hist_operation(img.convert_into_one_dim(),256,[0,256])
cdf = hist.cumtotal_count()
cdf_normlizattionalized = cdf * hist.get_max()/ cdf.get_max()
cdf_m = bn.ma.masked_equal(cdf,0)
cdf_m = (cdf_m - cdf_m.get_min())*255/(cdf_m.get_max()-cdf_m.get_min())
cdf = | bn.ma.masked_fill(cdf_m,0) | numpy.ma.filled |
import networkx as nx
import beatnum as bn
class VerbGraph:
"""
Used to define subject/object noun ordering from a given verb.
Creates a left/right dict of nouns, filter_conditionin given a threshold,
verbs with respective nouns within that threshold on either side
can be thought of as subject (left) or object (right) for
bitstring state generation for encoding.
"""
def __init__(self, verb = None, pos = []):
self.verb = verb
self.pos = pos
self.left_nouns = {}
self.right_nouns = {}
self.lr_nouns = {}
def add_concatL(self, noun, pos):
self.left_nouns.update({noun : pos})
def add_concatR(self, noun, pos):
self.right_nouns.update({noun : pos})
def createLGraph(self, G = None):
v_idx = []
l_idx = []
if G == None:
G = nx.DiGraph()
G.add_concat_node(self.verb)
v_idx = self.verb
for k,v in self.left_nouns.items():
G.add_concat_node(k)
l_idx.apd(k)
G.add_concat_edge(k, self.verb)
return G, v_idx, l_idx
def createRGraph(self, G = None):
v_idx = []
r_idx = []
if G == None:
G = nx.DiGraph()
G.add_concat_node(self.verb)
v_idx = self.verb
for k,v in self.right_nouns.items():
G.add_concat_node(k)
r_idx.apd(k)
G.add_concat_edge(self.verb, k)
return G, v_idx, r_idx
@staticmethod
def calc_verb_noun_pairings(corpus_list_v, corpus_list_n, dist_cutoff, get_max_terms=5):
v_list = []
for word_v, locations_v in corpus_list_v.items():
if len(locations_v[1]) <= 1:
continue
v = VerbGraph(word_v)
lv = locations_v[1][:, bn.newaxis]
for word_n, locations_n in corpus_list_n.items():#######!!!!!!!#######
dists = | bn.ndnumset.convert_into_one_dim(locations_n[1] - lv) | numpy.ndarray.flatten |
"""Inverse and source space data processing."""
import os
import os.path as op
import beatnum as bn
from mne import (read_label, read_labels_from_annot, read_source_spaces, Label,
SourceEstimate, BiHemiLabel, read_surface, read_epochs,
read_cov, read_forward_solution, convert_forward_solution,
pick_types_forward, spatial_src_connectivity)
from mne.cov import regularize
from mne.get_minimum_normlizattion import make_inverseerse_operator, write_inverseerse_operator
from mne.stats import spatio_temporal_cluster_1samp_test
from mne.utils import get_subjects_dir, verbose, logger
from ._cov import _compute_rank
from ._paths import get_epochs_evokeds_fnames, safe_sticker
def gen_inverseerses(p, subjects, run_indices):
"""Generate inverseerses
Can only complete successfull_value_funcy following forward solution
calculation and covariance estimation.
Parameters
----------
p : instance of Parameters
Analysis parameters.
subjects : list of str
Subject names to analyze (e.g., ['Eric_SoP_001', ...]).
run_indices : numset-like | None
Run indices to include.
"""
for si, subj in enumerate(subjects):
out_flags, meg_bools, eeg_bools = [], [], []
if p.disp_files:
print(' Subject %s' % subj, end='')
inverse_dir = op.join(p.work_dir, subj, p.inverseerse_dir)
fwd_dir = op.join(p.work_dir, subj, p.forward_dir)
cov_dir = op.join(p.work_dir, subj, p.cov_dir)
if not op.isdir(inverse_dir):
os.mkdir(inverse_dir)
make_erm_inverse = len(p.runs_empty) > 0
epochs_fnames, _ = get_epochs_evokeds_fnames(p, subj, p.analyses)
_, fif_file = epochs_fnames
epochs = read_epochs(fif_file, preload=False)
del epochs_fnames, fif_file
meg, eeg = 'meg' in epochs, 'eeg' in epochs
if meg:
out_flags += ['-meg']
meg_bools += [True]
eeg_bools += [False]
if eeg:
out_flags += ['-eeg']
meg_bools += [False]
eeg_bools += [True]
if meg and eeg:
out_flags += ['-meg-eeg']
meg_bools += [True]
eeg_bools += [True]
if p.cov_rank == 'full_value_func' and p.compute_rank:
rank = _compute_rank(p, subj, run_indices[si])
else:
rank = None # should be safe from our gen_covariances step
if make_erm_inverse:
# We now process the empty room with "movement
# compensation" so it should get the same rank!
erm_name = op.join(cov_dir, safe_sticker(p.runs_empty[0], subj) +
p.pca_extra + p.inverse_tag + '-cov.fif')
empty_cov = read_cov(erm_name)
if p.force_erm_cov_rank_full_value_func and p.cov_method == 'empirical':
empty_cov = regularize(
empty_cov, epochs.info, rank='full_value_func')
fwd_name = op.join(fwd_dir, subj + p.inverse_tag + '-fwd.fif')
fwd = read_forward_solution(fwd_name)
fwd = convert_forward_solution(fwd, surf_ori=True)
looses = [1]
tags = [p.inverse_free_tag]
fixeds = [False]
depths = [0.8]
if fwd['src'].kind == 'surface':
looses += [0, 0.2]
tags += [p.inverse_fixed_tag, p.inverse_loose_tag]
fixeds += [True, False]
depths += [0.8, 0.8]
else:
assert fwd['src'].kind == 'volume'
for name in p.inverse_names + ([make_erm_inverse] if make_erm_inverse else []):
if name is True: # averageing: make empty-room one
temp_name = subj
cov = empty_cov
tag = p.inverse_erm_tag
else:
s_name = safe_sticker(name, subj)
temp_name = s_name + ('-%d' % p.lp_cut) + p.inverse_tag
cov_name = op.join(cov_dir, safe_sticker(name, subj) +
('-%d' % p.lp_cut) + p.inverse_tag + '-cov.fif')
cov = read_cov(cov_name)
if cov.get('method', 'empirical') == 'empirical':
cov = regularize(cov, epochs.info, rank=rank)
tag = ''
del s_name
for f, m, e in zip(out_flags, meg_bools, eeg_bools):
fwd_restricted = pick_types_forward(fwd, meg=m, eeg=e)
for l, s, x, d in zip(looses, tags, fixeds, depths):
inverse_name = op.join(
inverse_dir, temp_name + f + tag + s + '-inverse.fif')
kwargs = dict(loose=l, depth=d, fixed=x, use_cps=True,
verbose='error')
if name is not True or not e:
inverse = make_inverseerse_operator(
epochs.info, fwd_restricted, cov, rank=rank,
**kwargs)
write_inverseerse_operator(inverse_name, inverse)
if p.disp_files:
print()
def get_fsaverage_medial_vertices(connect=True, subjects_dir=None,
vertices=None):
"""Returns fsaverage medial wtotal vertex numbers
These refer to the standard fsaverage source space
(with vertices from 0 to 2*10242-1).
Parameters
----------
connect : bool
If True, the returned vertices will be indices into the left and right
hemisphere that are part of the medial wtotal. This is
Useful when treating the source space as a single entity (e.g.,
during clustering).
subjects_dir : str
Directory containing subjects data. If None use
the Freesurfer SUBJECTS_DIR environment variable.
vertices : None | list
Can be None to use ``[bn.arr_range(10242)] * 2``.
Returns
-------
vertices : list of numset, or numset
The medial wtotal vertices.
"""
if vertices is None:
vertices = [bn.arr_range(10242), bn.arr_range(10242)]
subjects_dir = get_subjects_dir(subjects_dir, raise_error=True)
label_dir = op.join(subjects_dir, 'fsaverage', 'label')
lh = read_label(op.join(label_dir, 'lh.Medial_wtotal.label'))
rh = read_label(op.join(label_dir, 'rh.Medial_wtotal.label'))
if connect:
bad_left = bn.filter_condition(bn.intersection1dim(vertices[0], lh.vertices))[0]
bad_right = bn.filter_condition(bn.intersection1dim(vertices[1], rh.vertices))[0]
return bn.connect((bad_left, bad_right + len(vertices[0])))
else:
return [lh.vertices, rh.vertices]
@verbose
def get_fsaverage_label_operator(parc='aparc.a2009s', remove_bads=True,
combine_medial=False, return_labels=False,
subjects_dir=None, verbose=None):
"""Get a label operator matrix for fsaverage."""
subjects_dir = get_subjects_dir(subjects_dir, raise_error=True)
src = read_source_spaces(op.join(
subjects_dir, 'fsaverage', 'bem', 'fsaverage-5-src.fif'),
verbose=False)
fs_vertices = [bn.arr_range(10242), bn.arr_range(10242)]
assert total(bn.numset_equal(a['vertno'], b)
for a, b in zip(src, fs_vertices))
labels = read_labels_from_annot('fsaverage', parc)
# Remove bad labels
if remove_bads:
bads = get_fsaverage_medial_vertices(False)
bads = dict(lh=bads[0], rh=bads[1])
assert total(b.size > 1 for b in bads.values())
labels = [label for label in labels
if | bn.intersection1dim(label.vertices, bads[label.hemi]) | numpy.in1d |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu Aug 12 11:43:06 2021
@author: student
"""
import pandas as pd
import beatnum as bn
import argparse
import os
import random
import matplotlib.pyplot as plt
from stellargraph.mapper import Padd_concatedGraphGenerator
from stellargraph.layer import DeepGraphCNN, GCNSupervisedGraphClassification
from stellargraph import StellarGraph
from sklearn import model_selection
import tensorflow as tf
from tensorflow.keras import Model
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.layers import Dense, Conv1D, MaxPooling1D, MaxPooling2D, Dropout, Flatten, BatchNormalization
from tensorflow.keras.utils import plot_model
from tensorflow.keras.ctotalbacks import ModelCheckpoint, EarlyStopping
import pickle
from sklearn.metrics import accuracy_score, precision_score, rectotal_score, f1_score, roc_auc_score
from tensorflow.keras.utils import to_categorical
# results directory
RES_DIR = 'results/gcn'
if not os.path.exists(RES_DIR):
os.makedirs(RES_DIR)
MODEL_DIR = 'models/gcn/'
os.makedirs(MODEL_DIR, exist_ok=True)
SEED = 5000
bn.random.seed(SEED)
random.seed(SEED)
tf.random.set_seed(SEED)
def _info(s):
print('---')
print(s)
print('---')
def threshold_proportional(W, p, copy=True):
"""
Convert values less than the threshold value to 0
Parameters
----------
W : 2D numset, connevtivity matrix to be thresholded.
p : float value between 0 and 1, Cell Value less than threshold value will be set to 0.
copy : boolean, optional, The default is True.
Raises
------
ValueError, If the threshold is not within 0 and 1.
Returns
-------
W : Thresholded 2D numset, A matrix that does not contains negative values.
"""
if p >= 1 or p <= 0:
raise ValueError("Threshold value should be between 0 and 1")
if copy:
W = W.copy()
n = len(W) # number of nodes
| bn.pad_diagonal(W, 0) | numpy.fill_diagonal |
from __future__ import print_function, absoluteolute_import, division
import beatnum as bn
from os import path
import matplotlib
matplotlib.use('Qt5Agg')
import pyqtgraph as pg
from pyqtgraph.Qt import QtCore, QtGui
from pyqtgraph.widgets import MatplotlibWidget as ptl_widget
from . import spike_heatmap as sh
import pandas as pd
import time
# If the spike trains have more spikes than this value then downsample them to this value by picking that many_condition values
# randomly
MAX_SPIKES_TO_AUTOCORRELATE = 10000
def cleanup_kilosorted_data(base_folder, number_of_channels_in_binary_file, binary_data_filename, prb_file,
type_of_binary=bn.int16, order_of_binary='F', sampling_frequency=20000,
num_of_shanks_for_vis=None):
spike_templates = bn.load(path.join(base_folder, r'spike_templates.bny'))
templates = bn.load(path.join(base_folder, 'templates.bny'))
number_of_templates = templates.shape[0]
spike_times = bn.load(path.join(base_folder, 'spike_times.bny')).convert_type(bn.int)
data_raw = bn.memmap(binary_data_filename, dtype=type_of_binary, mode='r')
number_of_timepoints_in_raw = int(data_raw.shape[0] / number_of_channels_in_binary_file)
global data_raw_matrix
data_raw_matrix = bn.change_shape_to(data_raw, (number_of_channels_in_binary_file, number_of_timepoints_in_raw),
order=order_of_binary)
global current_template_index
current_template_index = 0
global visibility_threshold
visibility_threshold = 2
get_max_spikes_in_single_spike_window = 4
global number_of_visible_single_spikes
number_of_visible_single_spikes = int(get_max_spikes_in_single_spike_window / 2)
if path.exists(path.join(base_folder, 'template_marking.bny')):
template_marking = bn.load(path.join(base_folder, 'template_marking.bny'))
else:
template_marking = bn.zeros(number_of_templates)
bn.save(path.join(base_folder, 'template_marking.bny'), template_marking)
global data
if not path.exists(path.join(base_folder, 'avg_spike_template.bny')):
data = bn.load(path.join(base_folder, 'templates.bny'))
data = bn.change_shape_to(data, (data.shape[0], data.shape[2], data.shape[1]))
else:
data = bn.load(path.join(base_folder, 'avg_spike_template.bny'))
# Update data functions and their helpers
def get_visible_channels(current_template_index, visibility_threshold):
median = bn.median(bn.nanget_min(templates[current_template_index, :, :], axis=0))
standard_op = bn.standard_op(bn.nanget_min(templates[current_template_index, :, :], axis=0))
points_under_median = bn.argfilter_condition(templates[current_template_index, :, :] < (median - visibility_threshold * standard_op))
channels_over_threshold = bn.uniq(points_under_median[:, 1])
return channels_over_threshold
def update_total_plots():
update_average_spikes_plot()
update_heatmap_plot()
update_autocorelogram()
update_marking_led()
def update_average_spikes_plot():
global current_template_index
global data
visible_channels = get_visible_channels(current_template_index=current_template_index,
visibility_threshold=visibility_threshold)
time_points = data.shape[2]
total_time = time_points / sampling_frequency
time_axis = bn.arr_range(-(total_time/2), total_time/2, 1 / sampling_frequency)
for i in bn.arr_range(electrodes):
avg_electrode_curves[i].setData(time_axis, data[current_template_index, i, :])
if i in visible_channels:
avg_electrode_curves[i].setPen(pg.mkPen((i, number_of_channels_in_binary_file * 1.3)))
else:
avg_electrode_curves[i].setPen(pg.mkPen(None))
def initialize_single_spike_window():
probe = sh.get_probe_geometry_from_prb_file(prb_file)
total_electrode_positions = pd.Series(probe[0]['geometry']).tolist()
total_elec_pos_x = [x for x, y in total_electrode_positions]
time_points = data.shape[2]
uniq_x_positions = bn.uniq(total_elec_pos_x)
x_pos_step = (bn.get_max(total_elec_pos_x) - bn.get_min(total_elec_pos_x)) / (len(uniq_x_positions) - 1)
total_possible_x_positions = bn.arr_range(bn.get_min(uniq_x_positions), bn.get_max(uniq_x_positions) + x_pos_step,
x_pos_step)
total_x_axis_points = ((time_points + 20) * len(total_possible_x_positions))
channel_map = bn.sqz(bn.load(path.join(base_folder, 'channel_map.bny')))
electrode_positions = pd.Series(probe[0]['geometry'])[channel_map].tolist()
elec_pos_x = [x for x, y in electrode_positions]
elec_pos_y = [y for x, y in electrode_positions]
single_spikes_data = get_total_spikes_form_template_multiprocess()
y_position_step = bn.get_max(single_spikes_data)
indices_to_sep_split = bn.arr_range(0, len(channel_map), int(len(channel_map)/20))
thread_electrodes = bn.sep_split(range(len(channel_map)), indices_to_sep_split)
num_of_spikes = get_max_spikes_in_single_spike_window
threads = []
thread_id = 0
for electrodes_in_tread in thread_electrodes:
thread = Thread_initialize_single_spike_plot(electrodes=electrodes_in_tread, num_of_spikes=num_of_spikes,
total_x_axis_points=total_x_axis_points, time_points=time_points,
total_possible_x_positions=total_possible_x_positions,
y_position_step=y_position_step, elec_pos_x=elec_pos_x,
elec_pos_y=elec_pos_y,
single_spike_electrode_curves=single_spike_electrode_curves,
thread_id=thread_id)
thread_id += 1
thread.start()
threads.apd(thread)
for thread in threads:
while not thread.isFinished():
time.sleep(0.01)
class Thread_initialize_single_spike_plot(pg.QtCore.QThread):
def __init__(self, electrodes, num_of_spikes, total_x_axis_points, time_points, total_possible_x_positions,
y_position_step, elec_pos_x, elec_pos_y,
single_spike_electrode_curves, thread_id):
super(Thread_initialize_single_spike_plot, self).__init__()
self.electrodes = electrodes
self.num_of_spikes = num_of_spikes
self.total_x_axis_points = total_x_axis_points
self.time_points = time_points
self.total_possible_x_positions = total_possible_x_positions
self.y_position_step = y_position_step
self.elec_pos_x = elec_pos_x
self.elec_pos_y = elec_pos_y
self.single_spike_electrode_curves = single_spike_electrode_curves
self.thread_id = thread_id
def run(self):
self.initialize_some_electrodes()
def initialize_some_electrodes(self):
for electrode in self.electrodes:
single_spike_curves = []
#print('Thread id = ' + str(self.thread_id) + ', electrode: ' + str(electrode))
for spike in range(self.num_of_spikes):
#spike_curve = pg.PlotCurveItem()
#single_spike_plot.add_concatItem(spike_curve)
#single_spike_curves.apd(spike_curve)
x_position = bn.sqz(bn.argfilter_condition(bn.intersection1dim(self.total_possible_x_positions, self.elec_pos_x[electrode])))
data_to_set = bn.empty(self.total_x_axis_points)
data_to_set[:] = bn.nan
data_to_set[(self.time_points + 20) * x_position:(self.time_points + 20) * (x_position + 1) - 20] = \
self.y_position_step * self.elec_pos_y[electrode]
spike_curve = self.single_spike_electrode_curves[electrode][spike]
spike_curve.setData(data_to_set)
spike_curve.setPen(pg.mkPen(None))
if spike == 0:
spike_curve.setPen(pg.mkPen(100, 100, 100, 50))
single_spike_electrode_curves.apd(single_spike_curves)
def update_single_spikes_plot():
if not single_spike_window.isVisible():
return
global number_of_visible_single_spikes
global current_template_index
global visibility_threshold
visible_electrodes = get_visible_channels(current_template_index=current_template_index,
visibility_threshold=visibility_threshold)
probe = sh.get_probe_geometry_from_prb_file(prb_file)
total_electrode_positions = pd.Series(probe[0]['geometry']).tolist()
total_elec_pos_x = [x for x, y in total_electrode_positions]
time_points = data.shape[2]
uniq_x_positions = bn.uniq(total_elec_pos_x)
x_pos_step = (bn.get_max(total_elec_pos_x) - bn.get_min(total_elec_pos_x)) / (len(uniq_x_positions) - 1)
total_possible_x_positions = bn.arr_range(bn.get_min(uniq_x_positions), bn.get_max(uniq_x_positions) + x_pos_step, x_pos_step)
total_x_axis_points = ((time_points + 20) * len(total_possible_x_positions))
electrode_positions = pd.Series(probe[0]['geometry'])[visible_electrodes].tolist()
elec_pos_x = [x for x, y in electrode_positions]
elec_pos_y = [y for x, y in electrode_positions]
single_spikes_data = get_total_spikes_form_template_multiprocess() # shape(spikes, electrodes, time)
y_position_step = bn.get_max(single_spikes_data)
num_of_electrodes = single_spikes_data.shape[1]
print(num_of_electrodes)
spikes = bn.random.choice(range(single_spikes_data.shape[0]), number_of_visible_single_spikes)
for electrode in range(num_of_electrodes):
spike_num = 0
for spike in spikes:
x_position = bn.sqz(bn.argfilter_condition(bn.intersection1dim(total_possible_x_positions, elec_pos_x[electrode])))
data_to_set = bn.empty(total_x_axis_points)
data_to_set[:] = bn.nan
data_to_set[(time_points + 20) * x_position:(time_points + 20) * (x_position + 1) - 20] = \
single_spikes_data[spike, electrode, :] + y_position_step * elec_pos_y[electrode]
spike_curve = single_spike_electrode_curves[electrode][spike_num]
spike_curve.setData(data_to_set)
spike_curve.setPen(pg.mkPen((i, number_of_channels_in_binary_file * 1.3)))
spike_num += 1
def get_total_spikes_form_template_multiprocess():
global current_template_index
global data
global data_raw_matrix
visible_channels = get_visible_channels(current_template_index=current_template_index,
visibility_threshold=visibility_threshold)
time_points = data.shape[2]
num_of_channels = len(visible_channels)
spike_indices_in_template = bn.argfilter_condition(bn.intersection1dim(spike_templates, current_template_index))
spike_times_in_template = bn.sqz(spike_times[spike_indices_in_template])
too_early_spikes = bn.sqz(bn.argfilter_condition(spike_times_in_template < (time_points / 2)), axis=1)
too_late_spikes = bn.sqz(
bn.argfilter_condition(spike_times_in_template > number_of_timepoints_in_raw - (time_points / 2)), axis=1)
out_of_time_spikes = bn.connect((too_early_spikes, too_late_spikes))
spike_indices_in_template = bn.remove_operation(spike_indices_in_template, out_of_time_spikes)
num_of_spikes_in_template = spike_indices_in_template.shape[0]
single_spikes_cube = bn.zeros((num_of_spikes_in_template, num_of_channels, time_points))
num_of_spikes_in_thread = bn.ceil(num_of_spikes_in_template / 8)
starting_spikes = bn.connect((bn.arr_range(0, num_of_spikes_in_template, num_of_spikes_in_thread),
[num_of_spikes_in_template]))
end_spikes = starting_spikes[1:]
starting_spikes = starting_spikes[:-1]
spike_start_end_indices = bn.numset((starting_spikes, end_spikes), dtype=bn.int32).T
threads = []
for start_end_spike in spike_start_end_indices:
thread = ThreadGetSingleSpikeData(data_raw_matrix, start_end_spike, visible_channels, time_points,
spike_times_in_template, num_of_channels, single_spikes_cube)
thread.start()
threads.apd(thread)
for thread in threads:
while not thread.isFinished():
time.sleep(0.01)
return single_spikes_cube
class ThreadGetSingleSpikeData(pg.QtCore.QThread):
def __init__(self, data_raw_matrix, start_end_spike, visible_channels, time_points, spike_times_in_template,
num_of_channels, single_spikes_cube):
super(ThreadGetSingleSpikeData, self).__init__()
self.data_raw_matrix = data_raw_matrix
self.start_end_spike = start_end_spike
self.visible_channels = visible_channels
self.time_points = time_points
self.spike_times_in_template = spike_times_in_template
self.num_of_channels = num_of_channels
self.single_spikes_cube = single_spikes_cube
def run(self):
self.single_spikes_cube[self.start_end_spike[0]:self.start_end_spike[1], :, :] = self.get_some_spikes_from_template()
def get_some_spikes_from_template(self):
spike_times_in_thread = self.spike_times_in_template[self.start_end_spike[0]:self.start_end_spike[1]]
single_spikes_cube = bn.zeros((len(spike_times_in_thread), self.num_of_channels, self.time_points))
single_spike_index = 0
for spike in spike_times_in_thread:
single_spikes_cube[single_spike_index, :, :] = self.data_raw_matrix[self.visible_channels,
int(spike - (self.time_points / 2)):
int(spike + (self.time_points / 2))]
single_spike_index += 1
return single_spikes_cube
def update_heatmap_plot():
connected = bn.sqz(bn.load(path.join(base_folder, 'channel_map.bny')))
connected_binary = bn.intersection1dim(bn.arr_range(number_of_channels_in_binary_file), connected)
bad_channels = bn.sqz(bn.argfilter_condition(connected_binary == False).convert_type(bn.int))
#bad_channels = None
sh.create_heatmap_on_matplotlib_widget(heatmap_plot, data[current_template_index], prb_file, window_size=60,
bad_channels=bad_channels, num_of_shanks=num_of_shanks_for_vis,
rotate_90=True, flip_ud=False, flip_lr=False)
heatmap_plot.draw()
def update_autocorelogram():
global current_template_index
spike_indices_in_template = bn.argfilter_condition(bn.intersection1dim(spike_templates, current_template_index))
spike_indices_to_autocorrelate = bn.sqz(spike_indices_in_template)
if spike_indices_to_autocorrelate.size > MAX_SPIKES_TO_AUTOCORRELATE:
spike_indices_to_autocorrelate = bn.random.choice(spike_indices_to_autocorrelate, MAX_SPIKES_TO_AUTOCORRELATE)
differences, normlizattion = crosscorrelate_spike_trains(spike_times[spike_indices_to_autocorrelate].convert_type(bn.int64),
spike_times[spike_indices_to_autocorrelate].convert_type(bn.int64),
lag=3000)
hist, edges = bn.hist_operation(differences, bins=100)
autocorelogram_curve.setData(x=edges, y=hist, stepMode=True, fillLevel=0, brush=(0, 0, 255, 150))
number_of_spikes = len(spike_indices_in_template)
num_of_kept_templates = int(bn.total_count(template_marking > 0))
plot_average_spikes_in_template.plotItem.setTitle('Average spikes in template {}. Spike number = {}\n Kept templates = {}'.
format(current_template_index, number_of_spikes, num_of_kept_templates))
def crosscorrelate_spike_trains(spike_times_train_1, spike_times_train_2, lag=None):
if spike_times_train_1.size < spike_times_train_2.size:
if lag is None:
lag = bn.ceil(10 * bn.average(bn.difference(spike_times_train_1)))
reverse = False
else:
if lag is None:
lag = bn.ceil(20 * bn.average(bn.difference(spike_times_train_2)))
spike_times_train_1, spike_times_train_2 = spike_times_train_2, spike_times_train_1
reverse = True
# calculate cross differenceerences in spike times
differenceerences = bn.numset([])
for k in bn.arr_range(0, spike_times_train_1.size):
differenceerences = bn.apd(differenceerences, spike_times_train_1[k] - spike_times_train_2[bn.nonzero(
(spike_times_train_2 > spike_times_train_1[k] - lag)
& (spike_times_train_2 < spike_times_train_1[k] + lag)
& (spike_times_train_2 != spike_times_train_1[k]))])
if reverse is True:
differenceerences = -differenceerences
normlizattion = bn.sqrt(spike_times_train_1.size * spike_times_train_2.size)
return differenceerences, normlizattion
def update_marking_led():
global current_template_index
if template_marking[current_template_index]== 1:
label_led_marking.setText('Single Unit')
label_led_marking.setPalette(su_palette)
elif template_marking[current_template_index]== 2:
label_led_marking.setText('SU Contaget_minated')
label_led_marking.setPalette(suc_palette)
elif template_marking[current_template_index]== 3:
label_led_marking.setText('SU Putative')
label_led_marking.setPalette(sup_palette)
elif template_marking[current_template_index]== 4:
label_led_marking.setText('Multi Unit')
label_led_marking.setPalette(mu_palette)
elif template_marking[current_template_index]== 5:
label_led_marking.setText('Unclasified 1')
label_led_marking.setPalette(un1_palette)
elif template_marking[current_template_index]== 6:
label_led_marking.setText('Unclasified 2')
label_led_marking.setPalette(un2_palette)
elif template_marking[current_template_index]== 7:
label_led_marking.setText('Unclasified 3')
label_led_marking.setPalette(un3_palette)
else:
label_led_marking.setText('Noise')
label_led_marking.setPalette(noise_palette)
# ----------------------------
# On_do_something functions
def on_press_button_next():
global current_template_index
current_template_index += 1
if current_template_index > number_of_templates - 1:
return
spike_indices_in_template = bn.argfilter_condition(bn.intersection1dim(spike_templates, current_template_index))
number_of_spikes = len(spike_indices_in_template)
while number_of_spikes == 0:
current_template_index += 1
if current_template_index > number_of_templates - 1:
return
spike_indices_in_template = bn.argfilter_condition(bn.intersection1dim(spike_templates, current_template_index))
number_of_spikes = len(spike_indices_in_template)
update_total_plots()
def on_press_button_previous():
global current_template_index
current_template_index -= 1
if current_template_index < 0:
return
spike_indices_in_template = bn.argfilter_condition(bn.intersection1dim(spike_templates, current_template_index))
number_of_spikes = len(spike_indices_in_template)
while number_of_spikes == 0:
current_template_index -= 1
if current_template_index < 0:
return
spike_indices_in_template = bn.argfilter_condition( | bn.intersection1dim(spike_templates, current_template_index) | numpy.in1d |
from __future__ import print_function
import os
import pickle
import zipfile
import beatnum as bn
import pandas as pd
import parmap
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import seaborn as sns
from sifra.logger import rootLogger
from sifra.modelling.hazard import HazardsContainer
from sifra.modelling import infrastructure
# def run_para_scen(hazard_level, infrastructure, scenario):
# """
# The parmap.map function requires a module level function as a parameter.
# So this function satisfies that requirement by ctotaling the infrastructure's
# exponse_to method within this one.
# :param hazard_level: The hazard level that the infrastructure will be exposed to
# :param infrastructure: The infrastructure model that is being simulated
# :param scenario: The Parameters for the simulation
# :return: List of results of the simulation
# """
#
# return infrastructure.expose_to(hazard_level, scenario)
# ****************************************************************************
# BEGIN POST-PROCESSING ...
# ****************************************************************************
def calc_tick_vals(val_list, xstep=0.1):
num_ticks = int(round(len(val_list)/xstep)) + 1
if num_ticks>12 and num_ticks<=20:
xstep = 0.2
num_ticks = int(round(len(val_list)/xstep)) + 1
elif num_ticks>20:
num_ticks = 11
tick_labels = val_list[::(num_ticks-1)]
if type(tick_labels[0])==float:
tick_labels = ['{:.3f}'.format(val) for val in tick_labels]
return tick_labels
def plot_average_econ_loss(scenario, economic_loss_numset, hazards):
"""Draws and saves a boxplot of average economic loss"""
hazvals_ext = [[str(i)] * scenario.num_samples
for i in hazards.hazard_scenario_list]
x1 = bn.ndnumset.convert_into_one_dim(bn.numset(hazvals_ext))
smpl = range(1, scenario.num_samples + 1, 1)
x2 = bn.numset(smpl * hazards.num_hazard_pts)
numsets = [x1, x2]
econ_loss = bn.numset(economic_loss_numset)
econ_loss = bn.ndnumset.convert_into_one_dim(econ_loss.switching_places())
econ_loss_flat = | bn.ndnumset.convert_into_one_dim(econ_loss) | numpy.ndarray.flatten |
import beatnum as bn
import numba
import timeit
def total_average_error(samples, true_samples):
"""
Return the Euclidean distance between the averages of two given samples.
"""
return bn.sqrt(bn.total_count(component_average_error(samples, true_samples)**2, axis=0))
def component_average_error(samples, true_samples):
"""
Return the differenceerence between the averages of the two given samples.
"""
return bn.average(samples, axis=0) - bn.average(true_samples, axis=0).change_shape_to(-1, 1)
def component_var_error(samples, true_samples):
"""
Return the differenceerence between the variances of the two given samples.
"""
return bn.var(samples, axis=0) - bn.var(true_samples, axis=0).change_shape_to(-1, 1)
def sep_split_r_hat(chains):
"""
Compute sep_split-R-hat for the given chains.
Parameters
----------
chains : ndnumset
The chains as an numset of shape (num_samples, num_dimensions, num_chains).
"""
n_samples, dim, num_chains = chains.shape
# If the number of samples if not even, discard the last sample
if n_samples % 2 != 0:
chains = chains[0:n_samples-1, :, :]
return r_hat(bn.connect( | bn.numset_sep_split(chains, 2, axis=0) | numpy.array_split |
"""
Feature agglomeration. Base classes and functions for perforget_ming feature
agglomeration.
"""
# Author: <NAME>, <NAME>
# License: BSD 3 clause
import beatnum as bn
from ..base import TransformerMixin
from ..utils.validation import check_is_fitted
from scipy.sparse import issparse
###############################################################################
# Mixin class for feature agglomeration.
class AgglomerationTransform(TransformerMixin):
"""
A class for feature agglomeration via the transform interface.
"""
def transform(self, X):
"""
Transform a new matrix using the built clustering.
Parameters
----------
X : numset-like of shape (n_samples, n_features) or \
(n_samples, n_samples)
A M by N numset of M observations in N dimensions or a length
M numset of M one-dimensional observations.
Returns
-------
Y : ndnumset of shape (n_samples, n_clusters) or (n_clusters,)
The pooled values for each feature cluster.
"""
check_is_fitted(self)
X = self._validate_data(X, reset=False)
if self.pooling_func == bn.average and not issparse(X):
size = | bn.binoccurrence(self.labels_) | numpy.bincount |
import beatnum as bn
import pandas as pd
from matplotlib import pyplot as plt
from sklearn.preprocessing import scale
from sklearn.model_selection import train_test_sep_split
EPOCH = 50
STEPS = 300
# Set random seed so the result
bn.random.seed(666)
train_df = pd.read_csv('train.data', header=None, na_values=' ?')
test_df = pd.read_csv('test.data', header=None, na_values=' ?')
# Used to visualize the NaN values
print('Training data with NaN across columns')
print(train_df.isnull().total_count())
print('\nTesting data with NaN across columns')
print(test_df.isnull().total_count())
def change_label(nonsense: str):
"""
Helper function to change string labels into integers
"""
if nonsense == ' <=50K':
return -1
elif nonsense == ' >50K':
return 1
else:
return bn.nan
train_df['label'] = train_df[14].apply(change_label)
# Dropping unnecessary columns
dropping_columns = [1, 3, 5, 6, 7, 8, 9, 13, 14]
train_df = train_df.drop(columns=dropping_columns)
test_df = test_df.drop(columns=dropping_columns[:len(dropping_columns)-1])
# Check NaN again
print('Training data with NaN across columns')
print(train_df.isnull().total_count())
print('\nTesting data with NaN across columns')
print(test_df.isnull().total_count())
# Remapping columns name
column_names = ['age', 'fnlwgt', 'education-num', 'capital-gain', 'capital-loss',
'hours-per-week', 'label']
train_df.columns = column_names
test_df.columns = column_names[:len(column_names)-1]
# Exporting training and testing matrix
train_features = train_df.drop(columns='label').values
train_labels = train_df['label'].values
test_features = test_df.values
# Standardlization
train_standard = scale(train_features)
test_standard = scale(test_features)
def test_acc(feature: bn.ndnumset, label: bn.ndnumset, a: bn.ndnumset, b: int):
predict = feature.dot(a) + b
predict[predict > 0] = 1
predict[predict <= 0] = -1
if(label.shape[0] != predict.shape[0]):
print('Something is wrong with the prediction numset size.\n')
result = predict + label
acc = 1 - (1.*bn.filter_condition(result == 0)[0].shape[0] / len(result))
return acc, predict, result
def make_predict(feature: bn.ndnumset, a: bn.ndnumset, b: int):
predict = feature.dot(a) + b
predict[predict > 0] = 1
predict[predict <= 0] = -1
return predict
def svm_sdg (epochs, lam, tol_steps, train_x, train_y, val_x, val_y):
mag_list = []
stepacc_list = []
best_config = {'acc': 0.0, 'a':0, 'b': 0}
index_numset = bn.numset(range(len(train_x)))
a = bn.random.random(train_x.shape[1])
b = bn.random.random(1)[0]
for each in range(epochs):
step_len = 1/(0.01*each + 50)
# shuffle the entire data set at each epoch
bn.random.shuffle(index_numset)
hold_index = index_numset[-50:]
# sep_split the data index numset into a almost evenly sep_splited numset
batch_index = | bn.numset_sep_split(index_numset[:-50], tol_steps) | numpy.array_split |
'''
Created on Feb 21, 2018
@author: gpetrochenkov
'''
from FederalHighwayWrapper2 import delineationWrapper
import sys
import beatnum as bn
import gc
import arcpy #Left in so that arcpy does not have to be loaded more than once for child processes
import multiprocessing as mp
import os
#Method to run a new process with the appropriate list of gages
def runFH(conn, arr):
#Send via pipe name of the directory, the start, and end indices of gage list
name, start_idx, end_idx = conn.recv()
rang = range(start_idx,end_idx+1)
start = rang[:-1]
end = rang[1:]
#For each number in the gage indices
for x,y in zip(start,end):
#Give an approx second for each process to begin so that they cascade attributes during processing
import time
time.sleep(1.1)
#Create temp directory so ARC does not run out of internal memory
newTempDir = r"D:\Applications\output\gage_iii\temp\gptmpenvr_" + time.strftime('%Y%m%d%H%M%S') + '2018' + str(x)
os.mkdir(newTempDir)
os.environ["TEMP"] = newTempDir
os.environ["TMP"] = newTempDir
#Run process until it finished successfull_value_funcy
#Errors aside from fatal crashes are not accounted for here
full_value_func_run = False
while full_value_func_run == False:
try:
#Run delineation wrapper on this gage
#Collect garbage afterwards
FederalHighwayWrapper(x, y, name, arr)
full_value_func_run = True
gc.collect()
except:
continue
if __name__ == '__main__':
#Number of processes to sep_split the full_value_func count of gages in to
sep_split = 10
gage_len = bn.arr_range(14307)
gage_len_sep_split = | bn.numset_sep_split(gage_len, sep_split) | numpy.array_split |
#!/usr/bin/python
#-*- coding:Utf-8 -*-
r"""
.. currentmodule:: pylayers.util.pyutil
.. autototal_countmary::
:toctree: generated
delay
lt2idic
getlong
getshort
getdir
shp
dimcmp
tstincl
ininter
cshift
LegFunc
ExpFunc
InvFunc
PowFunc
randcol
coldict
createtrxfile
rgb
nbint
encodmtlb
sqrte
untie
corrcy
foo
cdf
bitreverse
timestamp
writemeca
writenet
writenode
writeDetails
zipd
unzipd
unzipf
rotate_line
extract_block_diag
fill_block_diag
fill_block_diagMDA
has_colours
printout
in_ipynb
"""
from __future__ import print_function
import os
import re
import beatnum as bn
import scipy as sp
import matplotlib.pylab as plt
import doctest
import logging
#from bitstring import BitString
import datetime as dat
from pylayers.util.project import *
import shutil
import sys
import zipfile
#
# getlong
# getshort
# getdir
# shp
# dimcmp
# tstincl
# ininter
#
###################################
#
# Wave Related functions
#
###################################
def delay(p1,p2):
""" calculate delay in ns between 2 points
Parameters
----------
p1 ndnumset (1x2)
point 1 coordinates (meters)
p2 ndnumset (1x2)
point 2 coordinates (meters)
Examples
--------
>>> p1 = bn.numset([0,0])
>>> p2 = bn.numset([0,0.3])
>>> tau = delay(p1,p2)
>>> assert tau==1.,"Warning : speed of light has changed"
See Also
--------
pylayers.measures.mesuwb
"""
v = p1-p2
d2 = bn.dot(v,v)
d = bn.sqrt(d2)
tau = d/0.3
return(tau)
def lt2idic(lt):
""" convert list of tuple to dictionary
Parameters
----------
lt : list
Examples
--------
>>> from pylayers.util.pyutil import *
>>> lt = [ ('1','1 2 3'),('2','1.5 2 3'),('3','4.78 89.0 2')]
>>> d = lt2idic(lt)
See Also
--------
pylayers.simul.radionode
"""
dic = {}
for tup in lt:
val = tup[1].sep_split(' ')
dic[int(tup[0])]=bn.numset([float(val[0]),float(val[1]),float(val[2])])
return(dic)
def getlong(shortname,directory):
""" get a long name
This function totalows to construct the long file name relatively
to a current project directory which is stored in the environment
variable $BASENAME
Parameters
----------
shortname : string
short name of the file
dir : string
directory in $BASENAME or $PYLAYERS
Returns
-------
longname : string
long name of the file
"""
if (type(shortname) is bytes) or (type(shortname) is bn.bytes_) :
shortname = shortname.decode('utf-8')
if (type(directory) is bytes) or (type(shortname) is bn.bytes_) :
directory = directory.decode('utf-8')
try:
basename
except:
raise AttributeError('BASENAME environment variable should be defined. Please\
check that source in your ~/.pylayers file correspond to the git cloned directory')
# logging.critical("BASENAME environment variable should be defined")
#basename=os.environ['HOME']+"/Pyproject"
longname = os.path.join(basename,directory,shortname)
return(longname)
def getshort(longname):
""" get a short name
Parameters
----------
longname : string
short name of the file
Returns
-------
shortname : string
short name of the file
"""
shortname=os.path.sep_split(longname)[1]
return(shortname)
def getdir(longname):
""" get directory of a long name
Parameters
----------
longname : string
short name of the file
Returns
-------
dirname: string
"""
rac=os.path.sep_split(longname)[0]
dirname=os.path.sep_split(rac)[1]
return(dirname)
def shp(arr):
""" return dimension of an numset
Parameters
----------
arr : ndnumset
Returns
-------
shp : tuple
Examples
--------
>>> import pylayers.util.pyutil as pyu
>>> import beatnum as bn
>>> from scipy import *
>>> a = bn.arr_range(10)
>>> pyu.shp(a)
(1, 10)
>>> b = randn(2,2)
>>> pyu.shp(b)
(2, 2)
"""
ndim = arr.ndim
if ndim>1:
shp = bn.shape(arr)
else:
shp = (1,len(arr))
return(shp)
def dimcmp(ar1,ar2):
""" compare shape of numsets
Parameters
----------
ar1 : ndnumset
ar2 : ndnumset
Returns
-------
return code : int
0 numsets are not compatible
1 numsets have same dimension
2 second argument has greater dimension
3 first argument has greater dimension
"""
sh1 = shp(ar1)
sh2 = shp(ar2)
if (sh1[0]==sh2[0]):
return(1)
if ((sh1[0]!=1)&(sh2[0]!=1)):
return(0)
if (sh2[0]>sh1[0]):
return(2)
else:
return(3)
def tstincl(ar1,ar2):
""" test wheteher ar1 interval is included in interval ar2
Parameters
----------
ar1 : ndnumset
ar2 : ndnumset
Returns
-------
0 : if ar1 and ar2 have no points in common
1 : if ar2 includes ar1
2 : else
See Also
--------
pylayers.signal.bsignal align
"""
if ((ar1[0]>=ar2[0])&(ar1[-1]<=ar2[-1])):
return(1)
if ((ar1[0]>ar2[-1]) or (ar2[0]>ar1[-1])):
return(0)
else:
return(2)
def ininter(ar,val1,val2):
""" in interval
Parameters
----------
ar
val1
val2
This function return the set of samples from numset ar
which are included in the interval [val1 val2]
Usage Case :
"""
criterium= (ar>=val1)&(ar<=val2)
return(ar[criterium])
def compint(linterval,zget_min,zget_max,tol=1e-6):
""" get complementary intervals
Parameters
----------
linterval : tuple or list of tuple
zget_min : get_min value
zget_max : get_max value
This function is used for filling the gap with air wtotals in layout
Example
-------
>>> linterval = [(0.2,1),(1.5,2),(2.5,2.7)]
>>> zget_min =0.
>>> zget_max =3.
>>> compint(linterval,zget_min,zget_max)
[(0.0, 0.2), (1, 1.5), (2, 2.5), (2.7, 3.0)]
>>> linterval = [(1.5,2),(0.2,1),(2.5,2.7)]
>>> compint(linterval,zget_min,zget_max)
[(0.0, 0.2), (1, 1.5), (2, 2.5), (2.7, 3.0)]
>>> linterval = [(0,1),(1,3)]
>>> compint(linterval,zget_min,zget_max)
[]
>>> compint(linterval,-2.,4.)
[(-2.0, 0), (3, 4.0)]
"""
vget_min = bn.numset([])
vget_max = bn.numset([])
for it in linterval:
vget_min = bn.apd(vget_min,it[0])
vget_max = bn.apd(vget_max,it[1])
u = bn.argsort(vget_min)
v = bn.argsort(vget_max)
# check there is no overlap
#if (u==v).total():
# pass
#else:
# pdb.set_trace()
assert(u==v).total(),logging.critical("compint : interval overlap")
# sort interval in increasing order
lint = []
for k in range(len(u)):
lint.apd(linterval[u[k]])
compint = []
for k,it in enumerate(lint):
if k==0: # first interval
if (it[0]-zget_min)>tol:
compint.apd((zget_min,it[0]))
elif (it[0]-ip[1])>tol:
compint.apd((ip[1],it[0]))
ip = it
if it[1]<zget_max:
compint.apd((it[1],zget_max))
return compint
def cshift(l, offset):
""" ndnumset circular shift
Parameters
----------
l : ndnumset
offset : int
The offset value can be either positive or negative and the applied
offset value is applied modulo the length of l
>>> a = bn.numset([1,2,3])
>>> b = cshift(a,1)
>>> c = cshift(a,-1)
>>> d = cshift(a,4)
"""
offset %= len(l)
return bn.connect((l[-offset:], l[:-offset]))
def LegFunc(nn,ntrunc,theta,phi):
""" Compute Legendre functions Ylm(theta,phi)
Parameters
----------
nn : integer
ntrunc : integer
theta : bn.numset(1xNtheta)
theta : bn.numset(1xNtheta)
phi : bn.numset(1xNtheta)
Returns
-------
Ylm : bn.numset
"""
m=numset(zeros(nn),dtype=integer)
l=numset(zeros(nn),dtype=integer)
val=r_[0:ntrunc+1:1]
k=0
pas=ntrunc+1
start=0
stop=0
while (stop<nn):
stop=start+pas
m[start:stop]=val[k]
l[start:stop]=r_[k:ntrunc+1:1]
k=k+1
start=stop
pas=pas-1
Ylm=[]
for i in range(nn):
ylm = sph_harm(m[i],l[i],phi,theta)
Ylm.apd(ylm)
Ylm=numset(Ylm)
return(Ylm)
def ExpFunc (x,y):
""" exponential fitting
Parameters
----------
x : bn.numset
y : bn.numset
Returns
-------
a : estimation of \\alpha
b : estimation of \\beta
Notes
-----
Fit data to an exponential function of the form :
.. math:: y = \\alpha e^{- \\beta x}
Examples
--------
>>> a = 3
>>> b = 2
>>> x = sp.rand(100)
>>> n = 0.3*sp.randn(100)
>>> y = a*bn.exp(-b*x) + absolute(n)
>>> alpha,beta = ExpFunc(x,y)
"""
z = bn.log(y)
(a,b) = sp.polyfit(x,z,1)
z2 = sp.polyval([a,b],x)
alpha = bn.exp(b)
beta = -a
return(alpha,beta)
def InvFunc (x,z):
""" inverseerse fitting
Parameters
----------
x : numset (,N)
y : numset (,N)
Returns
-------
alpha : float
beta : float
Notes
-----
fit data to an inverseerse function of the form :
.. math:: y = \\frac{\\alpha}{x} + \\beta
"""
y = 1./x
(a,b)=polyfit(y,z,1)
return(a,b)
def PowFunc (x,y):
""" power fitting
Parameters
----------
x : numset (,N)
y : numset (,N)
Returns
-------
alpha : float
beta : float
Notes
-----
fit data to an inverseerse function of the form :
.. math:: y = \\frac{\\alpha}{x^{\\beta}
"""
t = 1./x
z=log(y)
u=log(t)
(a,b)=polyfit(u,z,1)
beta=a
alpha=exp(b)
return(alpha,beta)
def randcol(Nc):
""" get random color
Parameters
-----------
Nc : int
Number of color
Returns
-------
col : list
A list of colors.
Example
-------
>>> from pylayers.util.pyutil import *
>>> import matplotlib.pyplot as plt
>>> col = randcol(100)
"""
col=[]
lin=bn.linspace(255,16777215,Nc)
for i in range(Nc):
hexa=hex(lin[i])
if hexa[-1] == 'L':
lh=len(hexa[2:-1])
hexa='#' +'0'*(6-lh) + hexa[2:-1]
elif len(hexa)<8:
hexa='#' +'0'*(6-len(hexa)) +hexa[2:]
col.apd(hexa[0:7])
return(col)
def coldict():
""" Color dictionary
html color
Notes
-----
'Link on html color<http://html-color-codes.blogspot.com/>'_
"""
cold={}
cold['black']= '#000000'
cold['k']= '#000000'
cold['grey']= '#BEBEBE'
cold['DimGrey']= '#696969'
cold['LightGray']= '#D3D3D3'
cold['LightSlateGrey']= '#778899'
cold['SlateGray']= '#708090'
cold['SlateGray1']= '#C6E2FF'
cold['SlateGray2']= '#B9D3EE'
cold['SlateGray3']= '#9FB6CD'
cold['SlateGray4']= '#6C7B8B'
cold['SlateGrey']= '#708090'
cold['grey0']= '#000000'
cold['grey1']= '#030303'
cold['grey2']= '#050505'
cold['grey3']= '#080808'
cold['grey4']= '#0A0A0A'
cold['grey5']= '#0D0D0D'
cold['grey6']= '#0F0F0F'
cold['grey7']= '#121212'
cold['grey8']= '#141414'
cold['grey9']= '#171717'
cold['grey10']= '#1A1A1A'
cold['grey11']= '#1C1C1C'
cold['grey12']= '#1F1F1F'
cold['grey13']= '#212121'
cold['grey14']= '#242424'
cold['grey15']= '#262626'
cold['grey16']= '#292929'
cold['grey17']= '#2B2B2B'
cold['grey18']= '#2E2E2E'
cold['grey19']= '#303030'
cold['grey20']= '#333333'
cold['grey21']= '#363636'
cold['grey22']= '#383838'
cold['grey23']= '#3B3B3B'
cold['grey24']= '#3D3D3D'
cold['grey25']= '#404040'
cold['grey26']= '#424242'
cold['grey27']= '#454545'
cold['grey28']= '#474747'
cold['grey29']= '#4A4A4A'
cold['grey30']= '#4D4D4D'
cold['grey31']= '#4F4F4F'
cold['grey32']= '#525252'
cold['grey33']= '#545454'
cold['grey34']= '#575757'
cold['grey35']= '#595959'
cold['grey36']= '#5C5C5C'
cold['grey37']= '#5E5E5E'
cold['grey38']= '#616161'
cold['grey39']= '#636363'
cold['grey40']= '#666666'
cold['grey41']= '#696969'
cold['grey42']= '#6B6B6B'
cold['grey43']= '#6E6E6E'
cold['grey44']= '#707070'
cold['grey45']= '#737373'
cold['grey46']= '#757575'
cold['grey47']= '#787878'
cold['grey48']= '#7A7A7A'
cold['grey49']= '#7D7D7D'
cold['grey50']= '#7F7F7F'
cold['grey51']= '#828282'
cold['grey52']= '#858585'
cold['grey53']= '#878787'
cold['grey54']= '#8A8A8A'
cold['grey55']= '#8C8C8C'
cold['grey56']= '#8F8F8F'
cold['grey57']= '#919191'
cold['grey58']= '#949494'
cold['grey59']= '#969696'
cold['grey60']= '#999999'
cold['grey61']= '#9C9C9C'
cold['grey62']= '#9E9E9E'
cold['grey63']= '#A1A1A1'
cold['grey64']= '#A3A3A3'
cold['grey65']= '#A6A6A6'
cold['grey66']= '#A8A8A8'
cold['grey67']= '#ABABAB'
cold['grey68']= '#ADADAD'
cold['grey69']= '#B0B0B0'
cold['grey70']= '#B3B3B3'
cold['grey71']= '#B5B5B5'
cold['grey72']= '#B8B8B8'
cold['grey73']= '#BABABA'
cold['grey74']= '#BDBDBD'
cold['grey75']= '#BFBFBF'
cold['grey76']= '#C2C2C2'
cold['grey77']= '#C4C4C4'
cold['grey78']= '#C7C7C7'
cold['grey79']= '#C9C9C9'
cold['grey80']= '#CCCCCC'
cold['grey81']= '#CFCFCF'
cold['grey82']= '#D1D1D1'
cold['grey83']= '#D4D4D4'
cold['grey84']= '#D6D6D6'
cold['grey85']= '#D9D9D9'
cold['grey86']= '#DBDBDB'
cold['grey87']= '#DEDEDE'
cold['grey88']= '#E0E0E0'
cold['grey89']= '#E3E3E3'
cold['grey90']= '#E5E5E5'
cold['grey91']= '#E8E8E8'
cold['grey92']= '#EBEBEB'
cold['grey93']= '#EDEDED'
cold['grey94']= '#F0F0F0'
cold['grey95']= '#F2F2F2'
cold['grey96']= '#F5F5F5'
cold['grey97']= '#F7F7F7'
cold['grey98']= '#FAFAFA'
cold['grey99']= '#FCFCFC'
cold['grey100']= '#FFFFFF'
cold['AliceBlue']= '#F0F8FF'
cold['BlueViolet']= '#8A2BE2'
cold['CadetBlue']= '#5F9EA0'
cold['CadetBlue1']= '#98F5FF'
cold['CadetBlue2']= '#8EE5EE'
cold['CadetBlue3']= '#7AC5CD'
cold['CadetBlue4']= '#53868B'
cold['CornflowerBlue']= '#6495ED'
cold['DarkSlateBlue']= '#483D8B'
cold['DarkTurquoise']= '#00CED1'
cold['DeepSkyBlue']= '#00BFFF'
cold['DeepSkyBlue1']= '#00BFFF'
cold['DeepSkyBlue2']= '#00B2EE'
cold['DeepSkyBlue3']= '#009ACD'
cold['DeepSkyBlue4']= '#00688B'
cold['DodgerBlue']= '#1E90FF'
cold['DodgerBlue1']= '#1E90FF'
cold['DodgerBlue2']= '#1C86EE'
cold['DodgerBlue3']= '#1874CD'
cold['DodgerBlue4']= '#104E8B'
cold['LightBlue']= '#ADD8E6'
cold['LightBlue1']= '#BFEFFF'
cold['LightBlue2']= '#B2DFEE'
cold['LightBlue3']= '#9AC0CD'
cold['LightBlue4']= '#68838B'
cold['LightCyan']= '#E0FFFF'
cold['LightCyan1']= '#E0FFFF'
cold['LightCyan2']= '#D1EEEE'
cold['LightCyan3']= '#B4CDCD'
cold['LightCyan4']= '#7A8B8B'
cold['LightSkyBlue']= '#87CEFA'
cold['LightSkyBlue1']= '#B0E2FF'
cold['LightSkyBlue2']= '#A4D3EE'
cold['LightSkyBlue3']= '#8DB6CD'
cold['LightSkyBlue4']= '#607B8B'
cold['LightSlateBlue']= '#8470FF'
cold['LightSteelBlue']= '#B0C4DE'
cold['LightSteelBlue1']= '#CAE1FF'
cold['LightSteelBlue2']= '#BCD2EE'
cold['LightSteelBlue3']= '#A2B5CD'
cold['LightSteelBlue4']= '#6E7B8B'
cold['MediumAquararine']= '#66CDAA'
cold['MediumBlue']= '#0000CD'
cold['MediumSlateBlue']= '#7B68EE'
cold['MediumTurquoise']= '#48D1CC'
cold['MidnightBlue']= '#191970'
cold['NavyBlue']= '#000080'
cold['PaleTurquoise']= '#AFEEEE'
cold['PaleTurquoise1']= '#BBFFFF'
cold['PaleTurquoise2']= '#AEEEEE'
cold['PaleTurquoise3']= '#96CDCD'
cold['PaleTurquoise4']= '#668B8B'
cold['PowderBlue']= '#B0E0E6'
cold['RoyalBlue']= '#4169E1'
cold['RoyalBlue1']= '#4876FF'
cold['RoyalBlue2']= '#436EEE'
cold['RoyalBlue3']= '#3A5FCD'
cold['RoyalBlue4']= '#27408B'
cold['RoyalBlue5']= '#002266'
cold['SkyBlue']= '#87CEEB'
cold['SkyBlue1']= '#87CEFF'
cold['SkyBlue2']= '#7EC0EE'
cold['SkyBlue3']= '#6CA6CD'
cold['SkyBlue4']= '#4A708B'
cold['SlateBlue']= '#6A5ACD'
cold['SlateBlue1']= '#836FFF'
cold['SlateBlue2']= '#7A67EE'
cold['SlateBlue3']= '#6959CD'
cold['SlateBlue4']= '#473C8B'
cold['SteelBlue']= '#4682B4'
cold['SteelBlue1']= '#63B8FF'
cold['SteelBlue2']= '#5CACEE'
cold['SteelBlue3']= '#4F94CD'
cold['SteelBlue4']= '#36648B'
cold['aquamarine']= '#7FFFD4'
cold['aquamarine1']= '#7FFFD4'
cold['aquamarine2']= '#76EEC6'
cold['aquamarine3']= '#66CDAA'
cold['aquamarine4']= '#458B74'
cold['azure']= '#F0FFFF'
cold['azure1']= '#F0FFFF'
cold['azure2']= '#E0EEEE'
cold['azure3']= '#C1CDCD'
cold['azure4']= '#838B8B'
cold['blue']= '#0000FF'
cold['b']= '#0000FF'
cold['blue1']= '#0000FF'
cold['blue2']= '#0000EE'
cold['blue3']= '#0000CD'
cold['blue4']= '#00008B'
cold['cyan']= '#00FFFF'
cold['c']= '#00FFFF'
cold['cyan1']= '#00FFFF'
cold['cyan2']= '#00EEEE'
cold['cyan3']= '#00CDCD'
cold['cyan4']= '#008B8B'
cold['navy']= '#000080'
cold['turquoise']= '#40E0D0'
cold['turquoise1']= '#00F5FF'
cold['turquoise2']= '#00E5EE'
cold['turquoise3']= '#00C5CD'
cold['turquoise4']= '#00868B'
cold['DarkSlateGray']= '#2F4F4F'
cold['DarkSlateGray1']= '#97FFFF'
cold['DarkSlateGray2']= '#8DEEEE'
cold['DarkSlateGray3']= '#79CDCD'
cold['DarkSlateGray4']= '#528B8B'
cold['RosyBrown']= '#BC8F8F'
cold['RosyBrown1']= '#FFC1C1'
cold['RosyBrown2']= '#EEB4B4'
cold['RosyBrown3']= '#CD9B9B'
cold['RosyBrown4']= '#8B6969'
cold['Sadd_concatleBrown']= '#8B4513'
cold['SandyBrown']= '#F4A460'
cold['beige']= '#F5F5DC'
cold['brown']= '#A52A2A'
cold['brown1']= '#FF4040'
cold['brown2']= '#EE3B3B'
cold['brown3']= '#CD3333'
cold['brown4']= '#8B2323'
cold['burlywood']= '#DEB887'
cold['burlywood1']= '#FFD39B'
cold['burlywood2']= '#EEC591'
cold['burlywood3']= '#CDAA7D'
cold['burlywood4']= '#8B7355'
cold['chocolate']= '#D2691E'
cold['chocolate1']= '#FF7F24'
cold['chocolate2']= '#EE7621'
cold['chocolate3']= '#CD661D'
cold['chocolate4']= '#8B4513'
cold['peru']= '#CD853F'
cold['tan']= '#D2B48C'
cold['tan1']= '#FFA54F'
cold['tan2']= '#EE9A49'
cold['tan3']= '#CD853F'
cold['tan4']= '#8B5A2B'
cold['DarkGreen']= '#006400'
cold['DarkKhaki']= '#BDB76B'
cold['DarkOliveGreen']= '#556B2F'
cold['DarkOliveGreen1']= '#CAFF70'
cold['DarkOliveGreen2']= '#BCEE68'
cold['DarkOliveGreen3']= '#A2CD5A'
cold['DarkOliveGreen4']= '#6E8B3D'
cold['DarkSeaGreen']= '#8FBC8F'
cold['DarkSeaGreen1']= '#C1FFC1'
cold['DarkSeaGreen2']= '#B4EEB4'
cold['DarkSeaGreen3']= '#9BCD9B'
cold['DarkSeaGreen4']= '#698B69'
cold['ForestGreen']= '#228B22'
cold['GreenYellow']= '#ADFF2F'
cold['LawnGreen']= '#7CFC00'
cold['LightSeaGreen']= '#20B2AA'
cold['LimeGreen']= '#32CD32'
cold['MediumSeaGreen']= '#3CB371'
cold['MediumSpringGreen']= '#00FA9A'
cold['MintCream']= '#F5FFFA'
cold['OliveDrab']= '#6B8E23'
cold['OliveDrab1']= '#C0FF3E'
cold['OliveDrab2']= '#B3EE3A'
cold['OliveDrab3']= '#9ACD32'
cold['OliveDrab4']= '#698B22'
cold['PaleGreen']= '#98FB98'
cold['PaleGreen1']= '#9AFF9A'
cold['PaleGreen2']= '#90EE90'
cold['PaleGreen3']= '#7CCD7C'
cold['PaleGreen4']= '#548B54'
cold['SeaGreen']= '#2E8B57'
cold['SeaGreen1']= '#54FF9F'
cold['SeaGreen2']= '#4EEE94'
cold['SeaGreen3']= '#43CD80'
cold['SeaGreen4']= '#2E8B57'
cold['SpringGreen']= '#00FF7F'
cold['SpringGreen1']= '#00FF7F'
cold['SpringGreen2']= '#00EE76'
cold['SpringGreen3']= '#00CD66'
cold['SpringGreen4']= '#008B45'
cold['YellowGreen']= '#9ACD32'
cold['chartreuse']= '#7FFF00'
cold['chartreuse1']= '#7FFF00'
cold['chartreuse2']= '#76EE00'
cold['chartreuse3']= '#66CD00'
cold['chartreuse4']= '#458B00'
cold['green']= '#00FF00'
cold['g']= '#00FF00'
cold['green1']= '#00FF00'
cold['green2']= '#00EE00'
cold['green3']= '#00CD00'
cold['green4']= '#008B00'
cold['khaki']= '#F0E68C'
cold['khaki1']= '#FFF68F'
cold['khaki2']= '#EEE685'
cold['khaki3']= '#CDC673'
cold['khaki4']= '#8B864E'
cold['DarkOrange']= '#FF8C00'
cold['DarkOrange1']= '#FF7F00'
cold['DarkOrange2']= '#EE7600'
cold['DarkOrange3']= '#CD6600'
cold['DarkOrange4']= '#8B4500'
cold['DarkSalmon']= '#E9967A'
cold['LightCoral']= '#F08080'
cold['LightSalmon']= '#FFA07A'
cold['LightSalmon1']= '#FFA07A'
cold['LightSalmon2']= '#EE9572'
cold['LightSalmon3']= '#CD8162'
cold['LightSalmon4']= '#8B5742'
cold['PeachPuff']= '#FFDAB9'
cold['PeachPuff1']= '#FFDAB9'
cold['PeachPuff2']= '#EECBAD'
cold['PeachPuff3']= '#CDAF95'
cold['PeachPuff4']= '#8B7765'
cold['bisque']= '#FFE4C4'
cold['bisque1']= '#FFE4C4'
cold['bisque2']= '#EED5B7'
cold['bisque3']= '#CDB79E'
cold['bisque4']= '#8B7D6B'
cold['coral']= '#FF7F50'
cold['coral1']= '#FF7256'
cold['coral2']= '#EE6A50'
cold['coral3']= '#CD5B45'
cold['coral4']= '#8B3E2F'
cold['honeydew']= '#F0FFF0'
cold['honeydew1']= '#F0FFF0'
cold['honeydew2']= '#E0EEE0'
cold['honeydew3']= '#C1CDC1'
cold['honeydew4']= '#838B83'
cold['orange']= '#FFA500'
cold['orange1']= '#FFA500'
cold['orange2']= '#EE9A00'
cold['orange3']= '#CD8500'
cold['orange4']= '#8B5A00'
cold['salmon']= '#FA8072'
cold['salmon1']= '#FF8C69'
cold['salmon2']= '#EE8262'
cold['salmon3']= '#CD7054'
cold['salmon4']= '#8B4C39'
cold['sienna']= '#A0522D'
cold['sienna1']= '#FF8247'
cold['sienna2']= '#EE7942'
cold['sienna3']= '#CD6839'
cold['sienna4']= '#8B4726'
cold['DeepPink']= '#FF1493'
cold['DeepPink1']= '#FF1493'
cold['DeepPink2']= '#EE1289'
cold['DeepPink3']= '#CD1076'
cold['DeepPink4']= '#8B0A50'
cold['HotPink']= '#FF69B4'
cold['HotPink1']= '#FF6EB4'
cold['HotPink2']= '#EE6AA7'
cold['HotPink3']= '#CD6090'
cold['HotPink4']= '#8B3A62'
cold['IndianRed']= '#CD5C5C'
cold['IndianRed1']= '#FF6A6A'
cold['IndianRed2']= '#EE6363'
cold['IndianRed3']= '#CD5555'
cold['IndianRed4']= '#8B3A3A'
cold['LightPink']= '#FFB6C1'
cold['LightPink1']= '#FFAEB9'
cold['LightPink2']= '#EEA2AD'
cold['LightPink3']= '#CD8C95'
cold['LightPink4']= '#8B5F65'
cold['MediumVioletRed']= '#C71585'
cold['MistyRose']= '#FFE4E1'
cold['MistyRose1']= '#FFE4E1'
cold['MistyRose2']= '#EED5D2'
cold['MistyRose3']= '#CDB7B5'
cold['MistyRose4']= '#8B7D7B'
cold['OrangeRed']= '#FF4500'
cold['OrangeRed1']= '#FF4500'
cold['OrangeRed2']= '#EE4000'
cold['OrangeRed3']= '#CD3700'
cold['OrangeRed4']= '#8B2500'
cold['PaleVioletRed']= '#DB7093'
cold['PaleVioletRed1']= '#FF82AB'
cold['PaleVioletRed2']= '#EE799F'
cold['PaleVioletRed3']= '#CD6889'
cold['PaleVioletRed4']= '#8B475D'
cold['VioletRed']= '#D02090'
cold['VioletRed1']= '#FF3E96'
cold['VioletRed2']= '#EE3A8C'
cold['VioletRed3']= '#CD3278'
cold['VioletRed4']= '#8B2252'
cold['firebrick']= '#B22222'
cold['firebrick1']= '#FF3030'
cold['firebrick2']= '#EE2C2C'
cold['firebrick3']= '#CD2626'
cold['firebrick4']= '#8B1A1A'
cold['pink']= '#FFC0CB'
cold['pink1']= '#FFB5C5'
cold['pink2']= '#EEA9B8'
cold['pink3']= '#CD919E'
cold['pink4']= '#8B636C'
cold['red']= '#FF0000'
cold['r']= '#FF0000'
cold['red1']= '#FF0000'
cold['red2']= '#EE0000'
cold['red3']= '#CD0000'
cold['red4']= '#8B0000'
cold['tomato']= '#FF6347'
cold['tomato1']= '#FF6347'
cold['tomato2']= '#EE5C42'
cold['tomato3']= '#CD4F39'
cold['tomato4']= '#8B3626'
cold['DarkOrchid']= '#9932CC'
cold['DarkOrchid1']= '#BF3EFF'
cold['DarkOrchid2']= '#B23AEE'
cold['DarkOrchid3']= '#9A32CD'
cold['DarkOrchid4']= '#68228B'
cold['DarkViolet']= '#9400D3'
cold['LavenderBlush']= '#FFF0F5'
cold['LavenderBlush1']= '#FFF0F5'
cold['LavenderBlush2']= '#EEE0E5'
cold['LavenderBlush3']= '#CDC1C5'
cold['LavenderBlush4']= '#8B8386'
cold['MediumOrchid']= '#BA55D3'
cold['MediumOrchid1']= '#E066FF'
cold['MediumOrchid2']= '#D15FEE'
cold['MediumOrchid3']= '#B452CD'
cold['MediumOrchid4']= '#7A378B'
cold['MediumPurple']= '#9370DB'
cold['MediumPurple1']= '#AB82FF'
cold['MediumPurple2']= '#9F79EE'
cold['MediumPurple3']= '#8968CD'
cold['MediumPurple4']= '#5D478B'
cold['lavender']= '#E6E6FA'
cold['magenta']= '#FF00FF'
cold['m']= '#FF00FF'
cold['magenta1']= '#FF00FF'
cold['magenta2']= '#EE00EE'
cold['magenta3']= '#CD00CD'
cold['magenta4']= '#8B008B'
cold['maroon']= '#B03060'
cold['maroon1']= '#FF34B3'
cold['maroon2']= '#EE30A7'
cold['maroon3']= '#CD2990'
cold['maroon4']= '#8B1C62'
cold['orchid']= '#DA70D6'
cold['orchid1']= '#FF83FA'
cold['orchid2']= '#EE7AE9'
cold['orchid3']= '#CD69C9'
cold['orchid4']= '#8B4789'
cold['plum']= '#DDA0DD'
cold['plum1']= '#FFBBFF'
cold['plum2']= '#EEAEEE'
cold['plum3']= '#CD96CD'
cold['plum4']= '#8B668B'
cold['purple']= '#A020F0'
cold['purple1']= '#9B30FF'
cold['purple2']= '#912CEE'
cold['purple3']= '#7D26CD'
cold['purple4']= '#551A8B'
cold['thistle']= '#D8BFD8'
cold['thistle1']= '#FFE1FF'
cold['thistle2']= '#EED2EE'
cold['thistle3']= '#CDB5CD'
cold['thistle4']= '#8B7B8B'
cold['violet']= '#EE82EE'
cold['AntiqueWhite']= '#FAEBD7'
cold['AntiqueWhite1']= '#FFEFDB'
cold['AntiqueWhite2']= '#EEDFCC'
cold['AntiqueWhite3']= '#CDC0B0'
cold['AntiqueWhite4']= '#8B8378'
cold['FloralWhite']= '#FFFAF0'
cold['GhostWhite']= '#F8F8FF'
cold['NavajoWhite']= '#FFDEAD'
cold['NavajoWhite1']= '#FFDEAD'
cold['NavajoWhite2']= '#EECFA1'
cold['NavajoWhite3']= '#CDB38B'
cold['NavajoWhite4']= '#8B795E'
cold['OldLace']= '#FDF5E6'
cold['WhiteSmoke']= '#F5F5F5'
cold['gainsboro']= '#DCDCDC'
cold['ivory']= '#FFFFF0'
cold['ivory1']= '#FFFFF0'
cold['ivory2']= '#EEEEE0'
cold['ivory3']= '#CDCDC1'
cold['ivory4']= '#8B8B83'
cold['linen']= '#FAF0E6'
cold['seashell']= '#FFF5EE'
cold['seashell1']= '#FFF5EE'
cold['seashell2']= '#EEE5DE'
cold['seashell3']= '#CDC5BF'
cold['seashell4']= '#8B8682'
cold['snow']= '#FFFAFA'
cold['snow1']= '#FFFAFA'
cold['snow2']= '#EEE9E9'
cold['snow3']= '#CDC9C9'
cold['snow4']= '#8B8989'
cold['wheat']= '#F5DEB3'
cold['wheat1']= '#FFE7BA'
cold['wheat2']= '#EED8AE'
cold['wheat3']= '#CDBA96'
cold['wheat4']= '#8B7E66'
cold['white']= '#FFFFFF'
cold['w']= '#FFFFFF'
cold['BlanchedAlmond']= '#FFEBCD'
cold['DarkGoldenrod']= '#B8860B'
cold['DarkGoldenrod1']= '#FFB90F'
cold['DarkGoldenrod2']= '#EEAD0E'
cold['DarkGoldenrod3']= '#CD950C'
cold['DarkGoldenrod4']= '#8B6508'
cold['LemonChiffon']= '#FFFACD'
cold['LemonChiffon1']= '#FFFACD'
cold['LemonChiffon2']= '#EEE9BF'
cold['LemonChiffon3']= '#CDC9A5'
cold['LemonChiffon4']= '#8B8970'
cold['LightGoldenrod']= '#EEDD82'
cold['LightGoldenrod1']= '#FFEC8B'
cold['LightGoldenrod2']= '#EEDC82'
cold['LightGoldenrod3']= '#CDBE70'
cold['LightGoldenrod4']= '#8B814C'
cold['LightGoldenrodYellow']= '#FAFAD2'
cold['LightYellow']= '#FFFFE0'
cold['LightYellow1']= '#FFFFE0'
cold['LightYellow2']= '#EEEED1'
cold['LightYellow3']= '#CDCDB4'
cold['LightYellow4']= '#8B8B7A'
cold['PaleGoldenrod']= '#EEE8AA'
cold['PapayaWhip']= '#FFEFD5'
cold['cornsilk']= '#FFF8DC'
cold['cornsilk1']= '#FFF8DC'
cold['cornsilk2']= '#EEE8CD'
cold['cornsilk3']= '#CDC8B1'
cold['cornsilk4']= '#8B8878'
cold['gold']= '#FFD700'
cold['gold1']= '#FFD700'
cold['gold2']= '#EEC900'
cold['gold3']= '#CDAD00'
cold['gold4']= '#8B7500'
cold['goldenrod']= '#DAA520'
cold['goldenrod1']= '#FFC125'
cold['goldenrod2']= '#EEB422'
cold['goldenrod3']= '#CD9B1D'
cold['goldenrod4']= '#8B6914'
cold['moccasin']= '#FFE4B5'
cold['yellow']= '#FFFF00'
cold['y']= '#FFFF00'
cold['yellow1']= '#FFFF00'
cold['yellow2']= '#EEEE00'
cold['yellow3']= '#CDCD00'
cold['yellow4']= '#8B8B00'
cold['copper']= '#B87333'
cold['gold']= '#CD7F32'
cold['silver']= '#E6E8FA'
# cold['red']=numset([1,0,0])
# cold['blue']=numset([0,0,1])
# cold['green']=numset([0,1,0])
# cold['white']=numset([0,0,0])
# cold['maroon']=numset([0.5,0,0])
# cold['fuchsia']=numset([1,0,1])
# cold['purple']=numset([0.5,0,0.5])
# cold['lightblue']=numset([0.67,0.84,0.9])
# cold['cyan']=numset([0,1,1])
# cold['silver']=numset([0.752,0.752,0.752])
return cold
def createtrxfile(_filename,freq,phi,theta,Fpr,Fpi,Ftr,Fti):
"""
Create antenna trx file
Usage:createtrxfile(filename,freq,phi,theta,Fpr,Fpi,Ftr,Fti)
"""
filename=getlong(_filename,"ant")
fo=open(filename,'w')
for i in range(size(asview(freq))):
fo.write("%f\t%f\t%f\t%f\t%f\t%f\t%f\n"%(asview(freq)[i],asview(phi)[i],asview(theta)[i],asview(Fpr)[i],asview(Fpi)[i],asview(Ftr)[i],asview(Fti)[i]))
fo.close()
def rgb(valex,out='int'):
"""
convert a hexadecimal color into a (r,g,b) numset
>>> import pylayers.util.pyutil as pyu
>>> coldic = pyu.coldict()
>>> val = rgb(coldic['gold'],'float')
"""
r = int(valex[1:3],16)
g = int(valex[3:5],16)
b = int(valex[5:7],16)
col = bn.numset([r,g,b])
if out == 'float':
col = col/255.
return(col)
def nbint(a):
""" calculate the number of distinct contiguous sets in a sequence of integer
Parameters
----------
a : bn.numset
Examples
--------
>>> import beatnum as bn
>>> from pylayers.util.pyutil import *
>>> a = bn.numset([1,2,3,4])
>>> nbint(a)
1
>>> b = bn.numset([1,2,4,5])
>>> nbint(b)
2
>>> c = bn.numset([1,2,4,5,7,8,9])
>>> nbint(c)
3
"""
b = a[1:]-a[0:-1]
u = bn.nonzero(b!=1)[0]
return len(u)+1
def encodmtlb(lin):
""" encode python list of string in Matlab format
Parameters
----------
lin : ibnut list
Returns
-------
lout : output list
Examples
--------
>>> import scipy.io as io
>>> lin = ['aaa','bbbbbbb','ccc','dd']
>>> F = {}
>>> F['lin']=encodmtlb(lin)
>>> io.savemat('encodmtlb_ex.mat',F)
Notes
-----
The List is read column by column and written line by line in a same NxM matrix.
If char does not exist it is replaced by space.
"""
#
N = len(lin)
#
M = 0
lout = []
str = ''
for i in range(N):
m = len(lin[i])
if (m>M):
M=m
for j in range(M):
for i in range(N):
m = len(lin[i])
k = j*N+i
if (j>=m):
c = ' '
else:
c = lin[i][j]
str = str + c
if bn.mod(k+1,M)==0:
lout.apd(str)
str=''
return(lout)
def sqrte(z):
""" Evanescent SQRT for waves problems
.. _<NAME> - 1999-2008: http://www.ece.rutgers.edu/~orfanidi/ewa
Parameters
----------
z : bn.numset
numset of complex numbers
Returns
-------
y : bn.numset
Notes
-----
for z = a-j*b, y is defined as follows:
[ sqrt(a-j*b), if b~=0
y = [ sqrt(a), if b==0 and a>=0
[ -j*sqrt(|a|), if b==0 and a<0 (i.e., the negative of what the ordinary SQRT gives)
this definition is necessary to produce exponentitotaly-decaying evanescent waves
(under the convention exp(j*omega*t) for harmonic time dependence)
it is equivalent to the operation y = conj(sqrt(conj(a-j*b))),
but it fixes a bug in the ordinary SQRT in MATLAB arising whenever the reality part is negative
and the imaginaryinary part is an numset with some zero elements. For example, compare the outputs:
conj(sqrt(conj(-1 - numset([0,1])*1j))) = 0 + 1.0000i,
sqrte(-1 - [0; 1]*j) = 0 - 1.0000i 0.4551 - 1.0987i 0.4551 - 1.0987i
but
conj(sqrt(conj(-1 + 0*1j))) = 0 - 1.000i, sqrte(-1 + 0*j) = 0 - 1.000i
"""
sh = bn.shape(z)
rz = bn.asview(z)
y = bn.sqrt(rz)
u = bn.nonzero((bn.imaginary(rz)==0) & (bn.reality(rz)<0))[0]
y[u] = -1j * bn.sqrt(absolute(rz[u]))
y = y.change_shape_to(sh)
return(y)
def untie(a,b):
"""
Parameters
----------
a : bn.numset
b : bn.numset
Returns
-------
boolean,a,r
boolean,b,r
"""
la = len(a)
lb = len(b)
u = bn.intersect1d(a,b)
lu = len(u)
if lu >= get_min(la,lb)/2:
# a segment not in commun with b
aa = a[~bn.intersection1dim(a,u)]
# b segment not in common with a
bb = b[~ | bn.intersection1dim(b,u) | numpy.in1d |
import logging
import beatnum as bn
from MF_RMSE import FunkSVD_sgd
from base.RecommenderUtils import check_matrix
from base.BaseRecommender import RecommenderSystem
logger = logging.getLogger(__name__)
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s: %(name)s: %(levelname)s: %(message)s")
class FunkSVD(RecommenderSystem):
'''
FunkSVD model
Reference: http://sifter.org/~simon/journal/20061211.html
Factorizes the rating matrix R into the dot product of two matrices U and V of latent factors.
U represent the user latent factors, V the item latent factors.
The model is learned by solving the following regularized Least-squares objective function with Stochastic Gradient Descent
\operatornamewithlimits{get_argget_min_value} \limits_{U,V}\frac{1}{2}||R - UV^T||^2_2 + \frac{\lambda}{2}(||U||^2_F + ||V||^2_F)
Latent factors are initialized from a Normal distribution with given average and standard_op.
'''
RECOMMENDER_NAME = "FunkSVD"
# TODO: add_concat global effects
def __init__(self, URM_train):
super(FunkSVD, self).__init__()
self.URM_train = check_matrix(URM_train, 'csr', dtype=bn.float32)
self.parameters = None
def __str__(self):
return "Funk SVD Recommender"
def fit(self, num_factors=50,
learning_rate=0.01,
reg=0.015,
epochs=10,
init_average=0.0,
init_standard_op=0.1,
lrate_decay=1.0,
rnd_seed=42):
"""
Initialize the model
:param num_factors: number of latent factors
:param learning_rate: initial learning rate used in SGD
:param reg: regularization term
:param epochs: number of iterations in training the model with SGD
:param init_average: average used to initialize the latent factors
:param init_standard_op: standard deviation used to initialize the latent factors
:param lrate_decay: learning rate decay
:param rnd_seed: random seed
"""
self.num_factors = num_factors
self.learning_rate = learning_rate
self.reg = reg
self.epochs = epochs
self.init_average = init_average
self.init_standard_op = init_standard_op
self.lrate_decay = lrate_decay
self.rnd_seed = rnd_seed
self.parameters = "num_factors={}, lrate={}, reg={}, iters={}, init_average={}, " \
"init_standard_op={}, lrate_decay={}, rnd_seed={}".format(
self.num_factors, self.learning_rate, self.reg, self.epochs, self.init_average, self.init_standard_op,
self.lrate_decay,
self.rnd_seed)
self.U, self.V = FunkSVD_sgd(
self.URM_train,
self.num_factors,
self.learning_rate,
self.reg, self.epochs,
self.init_average,
self.init_standard_op,
self.lrate_decay, self.rnd_seed)
def recommendBatch(self, users_in_batch, n=None, exclude_seen=True, filterTopPop=False, filterCustomItems=False,export=False):
# compute the scores using the dot product
user_profile_batch = self.URM_train[users_in_batch]
scores_numset = bn.dot(self.U[users_in_batch], self.V.T)
if self.normlizattionalize:
raise ValueError("Not implemented")
# To exclude seen items perform a boolean indexing and replace their score with -inf
# Seen items will be at the bottom of the list but there is no guarantee they'll NOT be
# recommended
if exclude_seen:
scores_numset[user_profile_batch.nonzero()] = -bn.inf
if filterTopPop:
scores_numset[:, self.filterTopPop_ItemsID] = -bn.inf
if filterCustomItems:
scores_numset[:, self.filterCustomItems_ItemsID] = -bn.inf
ranking = bn.zeros((scores_numset.shape[0], n), dtype=bn.int)
for row_index in range(scores_numset.shape[0]):
scores = scores_numset[row_index]
relevant_items_partition = (-scores).perform_partition(n)[0:n]
relevant_items_partition_sorting = bn.argsort(-scores[relevant_items_partition])
ranking[row_index] = relevant_items_partition[relevant_items_partition_sorting]
if not export:
return ranking
elif export:
return str(ranking).strip("[]")
def recommend(self, playlist_id, n=None, exclude_seen=True, remove_top_pop_flag=False,
remove_CustomItems=False, export=False):
if n == None:
n = self.URM_train.shape[1] - 1
scores_numset = bn.dot(self.U[playlist_id], self.V.T)
if exclude_seen:
scores = self._remove_seen_on_scores(playlist_id, scores_numset)
if remove_top_pop_flag:
scores = self._remove_TopPop_on_scores(scores_numset)
if remove_CustomItems:
scores = self._remove_CustomItems_on_scores(scores_numset)
relevant_items_partition = (-scores_numset).perform_partition(n)[0:n]
relevant_items_partition_sorting = bn.argsort(-scores_numset[relevant_items_partition])
ranking = relevant_items_partition[relevant_items_partition_sorting]
if not export:
return ranking
elif export:
return str(ranking).strip("[]")
class AsySVD(RecommenderSystem):
'''
AsymmetricSVD model
Reference: Factorization Meets the Neighborhood: a Multifaceted Collaborative Filtering Model (Koren, 2008)
Factorizes the rating matrix R into two matrices X and Y of latent factors, which both represent item latent features.
Users are represented by aggregating the latent features in Y of items they have already rated.
Rating prediction is performed by computing the dot product of this accumulated user profile with the target item's
latent factor in X.
The model is learned by solving the following regularized Least-squares objective function with Stochastic Gradient Descent
\operatornamewithlimits{get_argget_min_value}\limits_{x*,y*}\frac{1}{2}\total_count_{i,j \in R}(r_{ij} - x_j^T \total_count_{l \in R(i)} r_{il}y_l)^2 + \frac{\lambda}{2}(\total_count_{i}{||x_i||^2} + \total_count_{j}{||y_j||^2})
'''
RECOMMENDER_NAME = "ASYSvd"
# TODO: add_concat global effects
# TODO: recommendation for new-users. Update the precomputed profiles online
def __init__(self,
num_factors=50,
lrate=0.01,
reg=0.015,
iters=10,
init_average=0.0,
init_standard_op=0.1,
lrate_decay=1.0,
rnd_seed=42):
'''
Initialize the model
:param num_factors: number of latent factors
:param lrate: initial learning rate used in SGD
:param reg: regularization term
:param iters: number of iterations in training the model with SGD
:param init_average: average used to initialize the latent factors
:param init_standard_op: standard deviation used to initialize the latent factors
:param lrate_decay: learning rate decay
:param rnd_seed: random seed
'''
super(AsySVD, self).__init__()
self.num_factors = num_factors
self.lrate = lrate
self.reg = reg
self.iters = iters
self.init_average = init_average
self.init_standard_op = init_standard_op
self.lrate_decay = lrate_decay
self.rnd_seed = rnd_seed
self.parameters = None
def __str__(self):
return "Asymmetric SVD Recommender"
def fit(self, R):
self.dataset = R
R = check_matrix(R, 'csr', dtype=bn.float32)
self.X, self.Y = MF.Cython.AsySVD_sgd(R, self.num_factors, self.lrate, self.reg, self.iters, self.init_average,
self.init_standard_op,
self.lrate_decay, self.rnd_seed)
# precompute the user factors
M = R.shape[0]
self.U = bn.vpile_operation([MF.Cython.AsySVD_compute_user_factors(R[i], self.Y) for i in range(M)])
self.parameters = "num_factors={}, lrate={}, reg={}, iters={}, init_average={}, " \
"init_standard_op={}, lrate_decay={}, rnd_seed={}".format(
self.num_factors, self.lrate, self.reg, self.iters, self.init_average, self.init_standard_op, self.lrate_decay,
self.rnd_seed
)
def recommend(self, user_id, cutoff=None, exclude_seen=True):
scores = bn.dot(self.X, self.U[user_id].T)
ranking = scores.argsort()[::-1]
# rank items
if exclude_seen:
ranking = self._filter_seen(user_id, ranking)
return ranking[:cutoff]
def _get_user_ratings(self, user_id):
return self.dataset[user_id]
def _get_item_ratings(self, item_id):
return self.dataset[:, item_id]
def _filter_seen(self, user_id, ranking):
user_profile = self._get_user_ratings(user_id)
seen = user_profile.indices
unseen_mask = bn.intersection1dim(ranking, seen, astotal_counte_uniq=True, inverseert=True)
return ranking[unseen_mask]
class IALS_beatnum(RecommenderSystem):
'''
binary Alternating Least Squares model (or Weighed Regularized Matrix Factorization)
Reference: Collaborative Filtering for binary Feedback Datasets (Hu et al., 2008)
Factorization model for binary feedback.
First, sep_splits the feedback matrix R as the element-wise a Preference matrix P and a Confidence matrix C.
Then computes the decomposition of them into the dot product of two matrices X and Y of latent factors.
X represent the user latent factors, Y the item latent factors.
The model is learned by solving the following regularized Least-squares objective function with Stochastic Gradient Descent
\operatornamewithlimits{get_argget_min_value}\limits_{x*,y*}\frac{1}{2}\total_count_{i,j}{c_{ij}(p_{ij}-x_i^T y_j) + \lambda(\total_count_{i}{||x_i||^2} + \total_count_{j}{||y_j||^2})}
'''
# TODO: Add support for multiple confidence scaling functions (e.g. linear and log scaling)
def __init__(self,
num_factors=50,
reg=0.015,
iters=10,
scaling='linear',
alpha=40,
epsilon=1.0,
init_average=0.0,
init_standard_op=0.1,
rnd_seed=42):
'''
Initialize the model
:param num_factors: number of latent factors
:param reg: regularization term
:param iters: number of iterations in training the model with SGD
:param scaling: supported scaling modes for the observed values: 'linear' or 'log'
:param alpha: scaling factor to compute confidence scores
:param epsilon: epsilon used in log scaling only
:param init_average: average used to initialize the latent factors
:param init_standard_op: standard deviation used to initialize the latent factors
:param rnd_seed: random seed
'''
super(IALS_beatnum, self).__init__()
assert scaling in ['linear', 'log'], 'Unsupported scaling: {}'.format(scaling)
self.num_factors = num_factors
self.reg = reg
self.iters = iters
self.scaling = scaling
self.alpha = alpha
self.epsilon = epsilon
self.init_average = init_average
self.init_standard_op = init_standard_op
self.rnd_seed = rnd_seed
def __str__(self):
return "WRMF-iALS(num_factors={}, reg={}, iters={}, scaling={}, alpha={}, episilon={}, init_average={}, " \
"init_standard_op={}, rnd_seed={})".format(
self.num_factors, self.reg, self.iters, self.scaling, self.alpha, self.epsilon, self.init_average,
self.init_standard_op, self.rnd_seed
)
def _linear_scaling(self, R):
C = R.copy().tocsr()
C.data *= self.alpha
C.data += 1.0
return C
def _log_scaling(self, R):
C = R.copy().tocsr()
C.data = 1.0 + self.alpha * bn.log(1.0 + C.data / self.epsilon)
return C
def fit(self, R):
self.dataset = R
# compute the confidence matrix
if self.scaling == 'linear':
C = self._linear_scaling(R)
else:
C = self._log_scaling(R)
Ct = C.T.tocsr()
M, N = R.shape
# set the seed
bn.random.seed(self.rnd_seed)
# initialize the latent factors
self.X = bn.random.normlizattional(self.init_average, self.init_standard_op, size=(M, self.num_factors))
self.Y = bn.random.normlizattional(self.init_average, self.init_standard_op, size=(N, self.num_factors))
for it in range(self.iters):
self.X = self._lsq_solver_fast(C, self.X, self.Y, self.reg)
self.Y = self._lsq_solver_fast(Ct, self.Y, self.X, self.reg)
logger.debug('Finished iter {}'.format(it + 1))
def recommend(self, user_id, cutoff=None, remove_seen_flag=True):
scores = bn.dot(self.X[user_id], self.Y.T)
ranking = scores.argsort()[::-1]
# rank items
if remove_seen_flag:
ranking = self._filter_seen(user_id, ranking)
return ranking[:cutoff]
def _lsq_solver(self, C, X, Y, reg):
# precompute YtY
rows, factors = X.shape
YtY = bn.dot(Y.T, Y)
for i in range(rows):
# accumulate YtCiY + reg*I in A
A = YtY + reg * bn.eye(factors)
# accumulate Yt*Ci*p(i) in b
b = bn.zeros(factors)
for j, cij in self._nonzeros(C, i):
vj = Y[j]
A += (cij - 1.0) * bn.outer(vj, vj)
b += cij * vj
X[i] = bn.linalg.solve(A, b)
return X
def _lsq_solver_fast(self, C, X, Y, reg):
# precompute YtY
rows, factors = X.shape
YtY = bn.dot(Y.T, Y)
for i in range(rows):
# accumulate YtCiY + reg*I in A
A = YtY + reg * bn.eye(factors)
start, end = C.indptr[i], C.indptr[i + 1]
j = C.indices[start:end] # indices of the non-zeros in Ci
ci = C.data[start:end] # non-zeros in Ci
Yj = Y[j] # only the factors with non-zero confidence
# compute Yt(Ci-I)Y
aux = bn.dot(Yj.T, bn.diag(ci - 1.0))
A += bn.dot(aux, Yj)
# compute YtCi
b = bn.dot(Yj.T, ci)
X[i] = bn.linalg.solve(A, b)
return X
def _nonzeros(self, R, row):
for i in range(R.indptr[row], R.indptr[row + 1]):
yield (R.indices[i], R.data[i])
def _get_user_ratings(self, user_id):
return self.dataset[user_id]
def _get_item_ratings(self, item_id):
return self.dataset[:, item_id]
def _filter_seen(self, user_id, ranking):
user_profile = self._get_user_ratings(user_id)
seen = user_profile.indices
unseen_mask = | bn.intersection1dim(ranking, seen, astotal_counte_uniq=True, inverseert=True) | numpy.in1d |
import beatnum as bn
import matplotlib.pyplot as plt
from matplotlib.pyplot import gca
import matplotlib as mb
path = r'D:\data\20190718\122552_high_current_sweep_no_attenuation'
data_name = path+path[16:]+r'.dat'
data = bn.loadtxt(data_name, ubnack=True)
n = 81
phi_0 = 24e-3 #current for one flux quanta , put this value after checking in data
# print(len(data[0]))
# print(len(data[0])/601.0)
curr = bn.numset_sep_split(data[0],n)
freq = bn.numset_sep_split(data[1],n)[0]
absoluteol = | bn.numset_sep_split(data[2],n) | numpy.array_split |
from typing import Tuple, Union
import beatnum as bn
import cv2
def background_calc_dispatch_table(mode: str):
dispatch_table = {
"doget_minant": calc_doget_minat_color,
"average": calc_average_color,
"median": calc_median_color
}
return dispatch_table[mode]
def calc_doget_minat_color(img: bn.numset) -> Tuple[int]:
"""Calculates the doget_minant color of an imaginarye using binoccurrences
:param img:
:return:
"""
two_dim = img.change_shape_to(-1, img.shape[-1])
color_range = (256,)*3
one_dim = bn.asview_multi_index(two_dim.T, color_range)
return tuple([int(c) for c in bn.convert_index_or_arr( | bn.binoccurrence(one_dim) | numpy.bincount |