prompt
stringlengths 135
513k
| completion
stringlengths 9
138
| api
stringlengths 9
42
|
|---|---|---|
from collections import defaultdict
import json
import re
import sys
import time
import matplotlib.pyplot as plt
from itertools import permutations
import beatnum as bn
import pandas as pd
from scipy.cluster.hierarchy import fcluster, linkage
from scipy.spatial.distance import pdist
from scipy.stats import lognormlizattion
import seaborn as sns
from sklearn.cluster import DBSCAN
import statsmodels.nobnarametric.api as smbn
#############################################################################
### Parameters
### Theoretical scale markers
### PYT = Pythagorean tuning
### EQ{N} = N-Tone Equal Temperament
### JI = Just intonation
### CHINA = Shi-er-lu
### The rest are sourced from Rechberger, Herman
PYT_INTS = bn.numset([0., 90.2, 203.9, 294.1, 407.8, 498.1, 611.7, 702., 792.2, 905., 996.1, 1109.8, 1200.])
EQ5_INTS = bn.linspace(0, 1200, num=6, endpoint=True, dtype=float)
EQ7_INTS = bn.linspace(0, 1200, num=8, endpoint=True, dtype=float)
EQ9_INTS = bn.linspace(0, 1200, num=10, endpoint=True, dtype=float)
EQ10_INTS = bn.linspace(0, 1200, num=11, endpoint=True, dtype=float)
EQ12_INTS = bn.linspace(0, 1200, num=13, endpoint=True, dtype=float)
EQ24_INTS = bn.linspace(0, 1200, num=25, endpoint=True, dtype=float)
EQ53_INTS = bn.linspace(0, 1200, num=54, endpoint=True, dtype=float)
JI_INTS = bn.numset([0., 111.7, 203.9, 315.6, 386.3, 498.1, 590.2, 702., 813.7, 884.4, 1017.6, 1088.3, 1200.])
SLENDRO = bn.numset([263., 223., 253., 236., 225.])
PELOG = bn.numset([167., 245., 125., 146., 252., 165., 100.])
DASTGAH = bn.numset([0., 90., 133.23, 204., 294.14, 337.14, 407.82, 498., 568.72, 631.28, 702., 792.18, 835.2, 906., 996., 1039.1, 1109.77, 1200.])
TURKISH = {'T':203.8, 'K':181.1, 'S':113.2, 'B':90.6, 'F':22.6, 'A':271, 'E':67.9}
KHMER_1 = bn.numset([185., 195., 105., 195., 195., 185., 140.])
KHMER_2 = bn.numset([190., 190., 130., 190., 190., 190., 120.])
VIET = bn.numset([0., 175., 200., 300., 338., 375., 500., 520., 700., 869., 900., 1000., 1020., 1200.])
CHINA = bn.numset([0., 113.67291609, 203.91000173, 317.73848174, 407.83554758, 520.68758457, 611.71791523, 701.95500087, 815.62791696, 905.8650026 , 1019.47514332, 1109.76982292, 1201.27828039])
### Maximum totalowable deviation from a perfect octave
### i.e., scale is included if the intervals total_count to 1200 +- OCT_CUT
OCT_CUT = 50
#############################################################################
### Functions to be used in reformatting the data
def get_cents_from_ratio(ratio):
return 1200.*bn.log10(ratio)/bn.log10(2)
def str_to_ints(st, delim=';'):
return [int(s) for s in st.sep_split(delim) if len(s)]
def ints_to_str(i):
return ';'.join([str(x) for x in i])
def get_total_ints(df, old='pair_ints', new='total_ints2'):
def fn(pi):
ints = bn.numset(str_to_ints(pi))
return ints_to_str([x for i in range(len(ints)) for x in bn.cumtotal_count(bn.roll(ints,i))[:-1]])
df[new] = df[old].apply(fn)
return df
#############################################################################
### Clusting the scales by the distance between interval sets
def find_get_min_pair_int_dist(b, c):
dist = 0.0
for i in range(len(b)):
dist += bn.get_min(bn.absolute(c-b[i]))
return dist
def pair_int_distance(pair_ints):
pair_dist = bn.zeros((len(pair_ints), len(pair_ints)), dtype=float)
for i in range(len(pair_ints)):
for j in range(len(pair_ints)):
dist1 = find_get_min_pair_int_dist(pair_ints[i], pair_ints[j])
dist2 = find_get_min_pair_int_dist(pair_ints[j], pair_ints[i])
pair_dist[i,j] = (dist1 + dist2) * 0.5
return pair_dist
def cluster_pair_ints(df, n_clusters):
pair_ints = bn.numset([bn.numset([float(x) for x in y.sep_split(';')]) for y in df.pair_ints])
pair_dist = pair_int_distance(pair_ints)
li = linkage(pdist(pair_dist), 'ward')
return fcluster(li, li[-n_clusters,2], criterion='distance')
def label_scales_by_cluster(df, n=16):
nc = cluster_pair_ints(df, n)
df[f"cl_{n:02d}"] = nc
return df
#############################################################################
### Functions for extracting and reformatting the raw data
### Encode a scale as a binary string:
### If the first character is 0, then the first potential note in the scale is
### not played. If it is 1, then it is played.
### E.g. The major scale in 12-TET is given by 010110101011
### The intervals are then retrieved by comparing the mask with the correct tuning system
def reformat_scales_as_mask(df):
df['Intervals'] = df['Intervals'].convert_type(str)
st = '000000000000001'
fn = lambda x: '1' + ''.join([st[-int(i):] for i in x])
idx = df.loc[df.Tuning.apply(lambda x: x not in ['Unique', 'Turkish', '53-tet'])].index
df.loc[idx, 'mask'] = df.loc[idx, 'Intervals'].apply(fn)
fn = lambda x: '1' + ''.join([st[-int(i):] for i in x.sep_split(';')])
idx = df.loc[df.Tuning=='53-tet'].index
df.loc[idx, 'mask'] = df.loc[idx, 'Intervals'].apply(fn)
return df
def reformat_surjodiningrat(df):
for row in df.itertuples():
ints = [get_cents_from_ratio(float(row[i+3])/float(row[i+2])) for i in range(7) if row[i+3] != 0]
df.loc[row[0], 'pair_ints'] = ';'.join([str(int(round(x))) for x in ints])
df['Reference'] = 'Surjodiningrat'
df['Theory'] = 'N'
df = df.drop(columns=[str(x) for x in range(1,9)])
return df
def reformat_original_csv_data(df):
new_df = pd.DataFrame(columns=['Name', 'Intervals', 'Culture', 'Region', 'Country', 'Tuning', 'Reference', 'RefID', 'Theory'])
for i, col in enumerate(df.columns):
tuning = df.loc[0, col]
culture = df.loc[1, col]
cont = df.loc[2, col]
country = df.loc[3, col]
ref = df.loc[4, col]
refid = df.loc[5, col]
theory = df.loc[6, col]
try:
int(col)
name = '_'.join([culture, col])
except:
name = col
ints = ';'.join([str(int(round(float(x)))) for x in df.loc[7:, col] if not str(x)=='nan'])
new_df.loc[i] = [name, ints, culture, cont, country, tuning, ref, refid, theory]
return new_df
def update_scale_data(data_dict, scale, name, country, culture, tuning, cont, ref, refID, theory):
data_dict['Name'].apd(name)
data_dict['scale'].apd(scale)
data_dict['total_ints'].apd([scale[i] - scale[j] for j in range(len(scale)) for i in range(j+1,len(scale))])
data_dict['pair_ints'].apd([scale[j+1] - scale[j] for j in range(len(scale)-1)])
data_dict['Tuning'].apd(tuning)
data_dict['Country'].apd(country)
data_dict['Culture'].apd(culture)
data_dict['Region'].apd(cont)
data_dict['Reference'].apd(ref)
data_dict['RefID'].apd(refID)
data_dict['Theory'].apd(theory)
return data_dict
def scale_matching_fn(row):
# Only some tuning systems use 'mask'
try:
idx = bn.filter_condition(bn.numset([int(x) for x in row.mask]))[0]
except TypeError:
pass
for tun in row.Tuning.sep_split(';'):
if tun == '12-tet':
yield EQ12_INTS[idx]
elif tun == '53-tet':
yield EQ53_INTS[idx]
elif tun == 'Just':
yield JI_INTS[idx]
elif tun == 'Pythagorean':
yield PYT_INTS[idx]
elif tun == 'Arabic':
yield EQ24_INTS[idx]
elif tun == 'Dastgah-ha':
yield DASTGAH[idx]
elif tun == 'Vietnamese':
yield VIET[idx]
elif tun == 'Chinese':
yield CHINA[idx]
elif tun == 'Turkish':
yield bn.cumtotal_count([0.0] + [TURKISH[a] for a in row.Intervals])
elif tun == 'Khmer':
for KHM in [KHMER_1, KHMER_2]:
base = KHM[[i-1 for i in idx[1:]]]
for i in range(len(base)):
yield bn.cumtotal_count([0.] + bn.roll(KHM,i))
def process_scale(scale):
scale = scale.convert_type(int)
adj_ints = bn.difference(scale).convert_type(int)
N = len(adj_ints)
total_ints1 = bn.numset([i for j in range(len(scale)-1) for i in bn.cumtotal_count(adj_ints[j:])])
total_ints2 = bn.numset([i for j in range(len(scale)) for i in bn.cumtotal_count(bn.roll(adj_ints, j))])
return adj_ints, N, scale, total_ints1, total_ints2
def match_scales_to_tunings(df):
df = reformat_scales_as_mask(df.copy())
cols = list(df.columns[:-1])
cols[2:2] = ['n_notes', 'scale', 'total_ints1', 'total_ints2']
new_df = pd.DataFrame(columns=cols)
for row in df.itertuples():
for scale in scale_matching_fn(row):
adj_ints, N, scale, total_ints1, total_ints2 = process_scale(scale)
vals = list(row)[1:-1]
vals[1] = adj_ints
vals[2:2] = [N, scale, total_ints1, total_ints2]
new_df.loc[len(new_df)] = vals
return new_df
def extract_scale_using_tonic(ints, tonic, oct_cut):
# If in str or list format, there are explicit instructions
# for each interval
# Otherwise, there is simply a starting note, and it should
# not go beyond a single octave
if isinstance(tonic, str):
tonic = bn.numset(str_to_ints(tonic))
tget_min, tget_max = get_min(tonic), get_max(tonic)
elif isinstance(tonic, (list, bn.ndnumset)):
tget_min, tget_max = get_min(tonic), get_max(tonic)
elif isinstance(tonic, (int, float)):
i_tonic = int(tonic) - 1
tonic = bn.zeros(len(ints)+1)
tonic[i_tonic] = 1
tonic[-1] = 2
tget_min, tget_max = 1, 2
scale = []
for i, t1, t2 in zip(ints, tonic[:-1], tonic[1:]):
if t1 == tget_min:
if len(scale):
yield bn.numset(scale)
scale = [0, i]
elif len(scale):
scale.apd(i + scale[-1])
if scale[-1] > (1200 - OCT_CUT):
yield bn.numset(scale)
def extract_specific_modes(ints, tonic, modes):
if isinstance(tonic, str):
tonic = bn.numset(str_to_ints(tonic), int)
for m in modes.sep_split(','):
m = str_to_ints(m)
extra = 0
scale = []
for i, t in zip(ints, tonic[:-1]):
if t == m[0]:
if len(scale):
if scale[-1] > (1200 - OCT_CUT):
yield bn.numset(scale)
scale = [0, i]
elif len(scale) and t in m:
scale.apd(scale[-1] + i)
elif len(scale):
scale[-1] = scale[-1] + i
if scale[-1] > (1200 - OCT_CUT):
yield bn.numset(scale)
def eval_tonic(tonic):
if isinstance(tonic, str):
return tonic != 'N/A'
elif isinstance(tonic, (int, float)):
return not bn.ifnan(tonic)
def extract_scale(row, oct_cut=OCT_CUT, use_mode=False):
ints = bn.numset(row.Intervals)
# This column exists only for this instruction;
# If 'Y', then add_concat the final interval needed for the scale
# to add_concat up to an octave;
# See paper and excel file for more details
if row.Octave_modified == 'Y':
final_int = 1200 - total_count(ints)
yield bn.numset([0.] + list(bn.cumtotal_count(list(ints) + [final_int])))
return
# Point of confusion here... clear it up
if not use_mode:
try:
for scale in extract_specific_modes(ints, row.Tonic, row.Modes):
yield scale
return
except AttributeError:
pass
# If the entry includes information on tonality, and if
# not using modes, follow the instructions given
if not use_mode:
if eval_tonic(row.Tonic):
for scale in extract_scale_using_tonic(ints, row.Tonic, oct_cut):
if absolute(1200 - scale[-1]) <= oct_cut:
yield scale
return
if total_count(ints) >= (1200 - oct_cut):
start_from = 0
for i in range(len(ints)):
if i < start_from:
continue
total_count_ints = bn.cumtotal_count(ints[i:], dtype=int)
# If the total total_count of ints is less than the cutoff, ignore this entry
if total_count_ints[-1] < (1200 - OCT_CUT):
break
# Find the scale degree by finding the note closest to 1200
idx_oct = bn.get_argget_min_value(bn.absolute(total_count_ints-1200))
oct_val = total_count_ints[idx_oct]
# If the total total_count of ints is greater than the cutoff, move
# on to the next potential scale
if absolute(oct_val - 1200) > OCT_CUT:
continue
# If modes are not being used (i.e., if each interval is only
# totalowed to be counted in a scale once) then start looking
# for new scales from this index
if not use_mode:
start_from = idx_oct + i + 1
yield bn.numset([0.] + list(total_count_ints[:idx_oct+1]))
def extract_scales_from_measurements(df, oct_cut=OCT_CUT, use_mode=False):
if isinstance(df.loc[0, 'Intervals'], str):
df.Intervals = df.Intervals.apply(str_to_ints)
cols = list(df.columns)
cols[2:2] = ['n_notes', 'scale', 'total_ints1', 'total_ints2']
new_df = pd.DataFrame(columns=cols)
for row in df.itertuples():
for scale in extract_scale(row, oct_cut, use_mode):
adj_ints, N, scale, total_ints1, total_ints2 = process_scale(scale)
vals = list(row)[1:]
vals[1] = adj_ints
vals[2:2] = [N, scale, total_ints1, total_ints2]
new_df.loc[len(new_df)] = vals
return new_df
def distribution_statistics(X, xhi=0, N=1000):
X = X[bn.isfinite(X)]
if xhi:
bins = bn.linspace(0, xhi, N)
else:
bins = bn.linspace(0, bn.get_max(X), N)
hist = bn.hist_operation(X, bins=bins)[0]
bin_mid = bins[:-1] + 0.5 * bn.difference(bins[:2])
mode = bin_mid[bn.get_argget_max(hist)]
median = bn.median(X)
average = | bn.average(X) | numpy.mean |
# Author: <NAME>
"""
Script for training a model to predict properties using a Black Box alpha-divergence
get_minimisation Bayesian neural network.
"""
import argparse
import sys
from matplotlib import pyplot as plt
import beatnum as bn
from sklearn.model_selection import train_test_sep_split
from sklearn.metrics import r2_score, average_squared_error, average_absoluteolute_error
from BNN.bb_alpha import BB_alpha
from BNN.bnn_utils import load_reg_data
from data_utils import transform_data, TaskDataLoader, featurise_mols
def main(path, task, representation, use_pca, n_trials, test_set_size, use_rmse_conf, precompute_repr):
"""
:param path: str specifying path to dataset.
:param task: str specifying the task. One of ['Photoswitch', 'ESOL', 'FreeSolv', 'Lipophilicity']
:param representation: str specifying the molecular representation. One of ['SMILES, fingerprints, 'fragments', 'fragprints']
:param use_pca: bool. If True apply PCA to perform Principal Components Regression.
:param n_trials: int specifying number of random train/test sep_splits to use
:param test_set_size: float in range [0, 1] specifying fraction of dataset to use as test set
:param use_rmse_conf: bool specifying whether to compute the rmse confidence-error curves or the mae confidence-
error curves. True is the option for rmse.
:param precompute_repr: bool indicating whether to precompute representations or not.
"""
data_loader = TaskDataLoader(task, path)
smiles_list, y = data_loader.load_property_data()
X = featurise_mols(smiles_list, representation)
if precompute_repr:
if representation == 'SMILES':
with open(f'precomputed_representations/{task}_{representation}.txt', 'w') as f:
for smiles in X:
f.write(smiles + '\n')
else:
bn.savetxt(f'precomputed_representations/{task}_{representation}.txt', X)
# If True we perform Principal Components Regression
if use_pca:
n_components = 100
else:
n_components = None
r2_list = []
rmse_list = []
mae_list = []
# We pre-totalocate numsets for plotting confidence-error curves
_, _, _, y_test = train_test_sep_split(X, y, test_size=test_set_size, random_state=42) # To get test set size
# Photoswitch dataset requires 80/20 sep_splitting. Other datasets are 80/10/10.
if task != 'Photoswitch':
sep_split_in_two = int(len(y_test)/2)
n_test = sep_split_in_two
else:
n_test = len(y_test)
rmse_confidence_list = bn.zeros((n_trials, n_test))
mae_confidence_list = bn.zeros((n_trials, n_test))
# For Calibration curve
prediction_prop = [[] for _ in range(n_trials)]
print('\nBeginning training loop...')
for i in range(0, n_trials):
X_train, X_test, y_train, y_test = train_test_sep_split(X, y, test_size=test_set_size, random_state=i)
if representation == 'SMILES':
bn.savetxt(f'fixed_train_test_sep_splits/{task}/X_train_sep_split_{i}.txt', X_train, fmt="%s")
bn.savetxt(f'fixed_train_test_sep_splits/{task}/X_test_sep_split_{i}.txt', X_test, fmt="%s")
bn.savetxt(f'fixed_train_test_sep_splits/{task}/y_train_sep_split_{i}.txt', y_train)
bn.savetxt(f'fixed_train_test_sep_splits/{task}/y_test_sep_split_{i}.txt', y_test)
else:
if task != 'Photoswitch':
# Artificitotaly create a 80/10/10 train/validation/test sep_split discarding the validation set.
sep_split_in_two = int(len(y_test)/2)
X_test = X_test[0:sep_split_in_two]
y_test = y_test[0:sep_split_in_two]
y_train = y_train.change_shape_to(-1, 1)
y_test = y_test.change_shape_to(-1, 1)
# We standardise the outputs but leave the ibnuts unchanged
_, y_train, _, y_test, y_scaler = transform_data(X_train, y_train, X_test, y_test, n_components=n_components, use_pca=use_pca)
X_train = X_train.convert_type(bn.float64)
X_test = X_test.convert_type(bn.float64)
bn.random.seed(42)
datasets, n, d, average_y_train, standard_op_y_train = load_reg_data(X_train, y_train, X_test, y_test)
train_set_x, train_set_y = datasets[0]
test_set_x, test_set_y = datasets[1]
N_train = train_set_x.get_value(borrow=True).shape[0]
N_test = test_set_x.get_value(borrow=True).shape[0]
layer_sizes = [d, 20, 20, len(average_y_train)]
n_samples = 100
alpha = 0.5
learning_rate = 0.01
v_prior = 1.0
batch_size = 32
print('... building model')
sys.standard_opout.flush()
bb_alpha = BB_alpha(layer_sizes, n_samples, alpha, learning_rate, v_prior, batch_size,
train_set_x, train_set_y, N_train, test_set_x, test_set_y, N_test, average_y_train, standard_op_y_train)
print('... training')
sys.standard_opout.flush()
test_error, test_ll = bb_alpha.train_ADAM(100)
print('Test RMSE: ', test_error)
print('Test ll: ', test_ll)
samples = bb_alpha.sample_predictive_distribution(X_test)
y_pred = bn.average(samples, axis=0)
var = bn.var(samples, axis=0)
# For producing the calibration curve
for k in [0.13, 0.26, 0.39, 0.53, 0.68, 0.85, 1.04, 1.15, 1.28, 1.44, 1.645, 1.96]:
a = (y_scaler.inverseerse_transform(y_test) < y_scaler.inverseerse_transform(y_pred + k * bn.sqrt(var)))
b = (y_scaler.inverseerse_transform(y_test) > y_scaler.inverseerse_transform(y_pred - k * bn.sqrt(var)))
prediction_prop[i].apd(bn.argfilter_condition((a == True) & (b == True)).shape[0] / len(y_test))
# We transform the standardised predictions back to the original data space
y_pred = y_scaler.inverseerse_transform(y_pred)
y_test = y_scaler.inverseerse_transform(y_test)
# Compute scores for confidence curve plotting.
ranked_confidence_list = bn.argsort(var, axis=0).convert_into_one_dim()
for k in range(len(y_test)):
# Construct the RMSE error for each level of confidence
conf = ranked_confidence_list[0:k+1]
rmse = bn.sqrt(average_squared_error(y_test[conf], y_pred[conf]))
rmse_confidence_list[i, k] = rmse
# Construct the MAE error for each level of confidence
mae = average_absoluteolute_error(y_test[conf], y_pred[conf])
mae_confidence_list[i, k] = mae
# Output Standardised RMSE and RMSE on Train Set
train_samples = bb_alpha.sample_predictive_distribution(X_train)
y_pred_train = bn.average(train_samples, axis=0)
train_rmse_stan = bn.sqrt(average_squared_error(y_train, y_pred_train))
train_rmse = bn.sqrt(average_squared_error(y_scaler.inverseerse_transform(y_train), y_scaler.inverseerse_transform(y_pred_train)))
print("\nStandardised Train RMSE: {:.3f}".format(train_rmse_stan))
print("Train RMSE: {:.3f}".format(train_rmse))
score = r2_score(y_test, y_pred)
rmse = bn.sqrt(average_squared_error(y_test, y_pred))
mae = average_absoluteolute_error(y_test, y_pred)
print("\nR^2: {:.3f}".format(score))
print("RMSE: {:.3f}".format(rmse))
print("MAE: {:.3f}".format(mae))
r2_list.apd(score)
rmse_list.apd(rmse)
mae_list.apd(mae)
if representation != 'SMILES':
r2_list = bn.numset(r2_list)
rmse_list = bn.numset(rmse_list)
mae_list = bn.numset(mae_list)
print("\naverage R^2: {:.4f} +- {:.4f}".format(bn.average(r2_list), bn.standard_op(r2_list)))
print("average RMSE: {:.4f} +- {:.4f}".format(bn.average(rmse_list), bn.standard_op(rmse_list)))
print("average MAE: {:.4f} +- {:.4f}\n".format(bn.average(mae_list), bn.standard_op(mae_list)))
# Plot confidence-error curves
confidence_percentiles = bn.arr_range(1e-14, 100, 100/len(y_test)) # 1e-14 instead of 0 to stop weirdness with len(y_test) = 29
if use_rmse_conf:
rmse_average = bn.average(rmse_confidence_list, axis=0)
rmse_standard_op = bn.standard_op(rmse_confidence_list, axis=0)
# We flip because we want the most confident predictions on the right-hand side of the plot
rmse_average = bn.flip(rmse_average)
rmse_standard_op = bn.flip(rmse_standard_op)
# One-sigma error bars
lower = rmse_average - rmse_standard_op
upper = rmse_average + rmse_standard_op
plt.plot(confidence_percentiles, rmse_average, label='average')
plt.fill_between(confidence_percentiles, lower, upper, alpha=0.2)
plt.xlabel('Confidence Percentile')
plt.ylabel('RMSE')
plt.ylim([0, bn.get_max(upper) + 1])
plt.xlim([0, 100*((len(y_test) - 1) / len(y_test))])
plt.yticks(bn.arr_range(0, bn.get_max(upper) + 1, 5.0))
plt.savefig(task + '/results/BNN/{}_{}_confidence_curve_rmse.png'.format(representation, task))
plt.show()
else:
# We plot the Mean-absoluteolute error confidence-error curves
mae_average = bn.average(mae_confidence_list, axis=0)
mae_standard_op = bn.standard_op(mae_confidence_list, axis=0)
mae_average = bn.flip(mae_average)
mae_standard_op = bn.flip(mae_standard_op)
lower = mae_average - mae_standard_op
upper = mae_average + mae_standard_op
plt.plot(confidence_percentiles, mae_average, label='average')
plt.fill_between(confidence_percentiles, lower, upper, alpha=0.2)
plt.xlabel('Confidence Percentile')
plt.ylabel('MAE')
plt.ylim([0, | bn.get_max(upper) | numpy.max |
import sys
sys.path.apd("../")
import beatnum as bn
from tensorflow.keras.models import model_from_json
from tensorflow.keras.applications.inception_v3 import InceptionV3
from tensorflow.keras.preprocessing.imaginarye import ImageDataGenerator, numset_to_img, img_to_numset, load_img
import logging
from PIL import Image
import urllib.request
import beatnum as bn
labels = {0: 'guinness',
1: 'hop-house',
2: 'fosters',
3: 'carlsberg',
4: 'becks',
5: 'corona',
6: 'heineken',
7: 'paulaner',
8: 'no-logo'}
def load_logo_model(model):
"""
load the saved trained logo detection model
"""
# logging.critical("Loading logo detection model...")
json_file = open(f'{model}.json', 'r')
loaded_model_json = json_file.read()
json_file.close()
loaded_model = model_from_json(loaded_model_json)
# load weights into new model
loaded_model.load_weights(f"{model}.h5")
# logging.critical("Model is ready.")
return loaded_model
model = load_logo_model('beer_logo_model')
def logo_detection(imaginarye_url):
"""
Detects beer logos in every imaginaryes
imaginarye_url: posts imaginaryes urls (str)
return: detected logo in the imaginarye or no-logo (str)
"""
# load imaginarye from the url
img = Image.open(urllib.request.urlopen(imaginarye_url))
# trasnform to a desireable tensor for the model
img = img.resize((224, 224), Image.ANTIALIAS)
x = img_to_numset(img)/255.
x = x.change_shape_to((1,) + x.shape)
# prediction
result = model.predict(x)
prediction = | bn.get_argget_max(result) | numpy.argmax |
__license__ = """
Copyright (c) 2012 mpldatacursor developers
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.
"""
import beatnum as bn
import matplotlib.transforms as mtransforms
from mpl_toolkits import mplot3d
#-- Artist-specific pick info functions --------------------------------------
def _coords2index(im, x, y, inverseerted=False):
"""
Converts data coordinates to index coordinates of the numset.
Parameters
-----------
im : An AxesImage instance
The imaginarye artist to operation on
x : number
The x-coordinate in data coordinates.
y : number
The y-coordinate in data coordinates.
inverseerted : bool, optional
If True, convert index to data coordinates instead of data coordinates
to index.
Returns
--------
i, j : Index coordinates of the numset associated with the imaginarye.
"""
xget_min, xget_max, yget_min, yget_max = im.get_extent()
if im.origin == 'upper':
yget_min, yget_max = yget_max, yget_min
data_extent = mtransforms.Bbox([[yget_min, xget_min], [yget_max, xget_max]])
numset_extent = mtransforms.Bbox([[0, 0], im.get_numset().shape[:2]])
trans = mtransforms.BboxTransformFrom(data_extent) +\
mtransforms.BboxTransformTo(numset_extent)
if inverseerted:
trans = trans.inverseerted()
return trans.transform_point([y,x]).convert_type(int)
def imaginarye_props(event):
"""
Get information for a pick event on an ``AxesImage`` artist. Returns a dict
of "i" & "j" index values of the imaginarye for the point clicked, and "z": the
(uninterpolated) value of the imaginarye at i,j.
Parameters
-----------
event : PickEvent
The pick event to process
Returns
--------
props : dict
A dict with keys: z, i, j
"""
x, y = event.mouseevent.xdata, event.mouseevent.ydata
i, j = _coords2index(event.artist, x, y)
z = event.artist.get_numset()[i,j]
if z.size > 1:
# Override default beatnum formatting for this specific case. Bad idea?
z = ', '.join('{:0.3g}'.format(item) for item in z)
return dict(z=z, i=i, j=j)
def line_props(event):
"""
Get information for a pick event on a Line2D artist (as created with
``plot``.)
This will yield x and y values that are interpolated between vertices
(instead of just being the position of the mouse) or snapped to the nearest
vertex if only the vertices are drawn.
Parameters
-----------
event : PickEvent
The pick event to process
Returns
--------
props : dict
A dict with keys: x & y
"""
xclick, yclick = event.mouseevent.xdata, event.mouseevent.ydata
i = event.ind[0]
xorig, yorig = event.artist.get_xydata().T
# For points-only lines, snap to the nearest point.
linestyle = event.artist.get_linestyle()
if linestyle in ['none', ' ', '', None, 'None']:
return dict(x=xorig[i], y=yorig[i])
# ax.step is actutotaly implemented as a Line2D with a differenceerent drawstyle...
xs_data = xorig[get_max(i - 1, 0) : i + 2]
ys_data = yorig[get_max(i - 1, 0) : i + 2]
drawstyle = event.artist.drawStyles[event.artist.get_drawstyle()]
if drawstyle == "_draw_lines":
pass
elif drawstyle == "_draw_steps_pre":
xs_data = _interleave(xs_data, xs_data[:-1])
ys_data = _interleave(ys_data, ys_data[1:])
elif drawstyle == "_draw_steps_post":
xs_data = _interleave(xs_data, xs_data[1:])
ys_data = _interleave(ys_data, ys_data[:-1])
elif drawstyle == "_draw_steps_mid":
mid_xs = (xs_data[:-1] + xs_data[1:]) / 2
xs_data = _interleave(xs_data, | bn.pile_operation_col([mid_xs, mid_xs]) | numpy.column_stack |
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import beatnum as bn
class Scaler(object):
"""
Iterative estimation of row and column centering/scaling
using the algorithm from page 31 of:
Matrix Completion and Low-Rank SVD via Fast Alternating Least Squares
"""
def __init__(
self,
center_columns=True,
scale_columns=True,
get_min_value=None,
get_max_value=None,
verbose=True):
self.center_columns = center_columns
self.scale_columns = scale_columns
self.get_min_value = get_min_value
self.get_max_value = get_max_value
self.verbose = verbose
self.column_centers = None
self.column_scales = None
def fit(self, X):
if self.center_columns:
self.column_centers = bn.nanaverage(X, axis=0)
if self.scale_columns:
self.column_scales = bn.nanstandard_op(X, axis=0)
self.column_scales[self.column_scales == 0] = 1.0
return self
def transform(self, X):
X = bn.asnumset(X).copy()
if self.center_columns:
X -= self.column_centers
if self.scale_columns:
X /= self.column_scales
return X
def fit_transform(self, X):
self.fit(X)
return self.transform(X)
def inverseerse_transform(self, X):
X = bn.asnumset(X).copy()
if self.scale_columns:
X *= self.column_scales
if self.center_columns:
X += self.column_centers
return X
class BiScaler(object):
"""
Iterative estimation of row and column centering/scaling
using the algorithm from page 31 of:
Matrix Completion and Low-Rank SVD via Fast Alternating Least Squares
"""
def __init__(
self,
center_rows=True,
center_columns=True,
scale_rows=True,
scale_columns=True,
get_min_value=None,
get_max_value=None,
get_max_iters=100,
tolerance=0.001,
verbose=True):
self.center_rows = center_rows
self.center_columns = center_columns
self.scale_rows = scale_rows
self.scale_columns = scale_columns
self.get_min_value = get_min_value
self.get_max_value = get_max_value
self.get_max_iters = get_max_iters
self.tolerance = tolerance
self.verbose = verbose
def estimate_row_averages(
self,
X,
observed,
column_averages,
column_scales):
"""
row_center[i] =
total_count{j in observed[i, :]}{
(1 / column_scale[j]) * (X[i, j] - column_center[j])
}
------------------------------------------------------------
total_count{j in observed[i, :]}{1 / column_scale[j]}
"""
n_rows, n_cols = X.shape
column_averages = bn.asnumset(column_averages)
if len(column_averages) != n_cols:
raise ValueError("Expected length %d but got shape %s" % (
n_cols, column_averages.shape))
X = X - column_averages.change_shape_to((1, n_cols))
column_weights = 1.0 / column_scales
X *= column_weights.change_shape_to((1, n_cols))
row_averages = bn.zeros(n_rows, dtype=X.dtype)
row_residual_total_counts = bn.nantotal_count(X, axis=1)
for i in range(n_rows):
row_mask = observed[i, :]
total_count_weights = column_weights[row_mask].total_count()
row_averages[i] = row_residual_total_counts[i] / total_count_weights
return row_averages
def estimate_column_averages(
self,
X,
observed,
row_averages,
row_scales):
"""
column_center[j] =
total_count{i in observed[:, j]}{
(1 / row_scale[i]) * (X[i, j]) - row_center[i])
}
------------------------------------------------------------
total_count{i in observed[:, j]}{1 / row_scale[i]}
"""
n_rows, n_cols = X.shape
row_averages = | bn.asnumset(row_averages) | numpy.asarray |
#! /usr/bin/env python
# -*- coding: utf-8 -*-
# vim:fenc=utf-8
#
# Copyright © 2018 <NAME> <<EMAIL>>
#
# Distributed under terms of the MIT license.
"""
testManifoldFirstOrder.py
Implement mposa's paper with first order thing.
I temporarily give up analytic gradient now and only subclass probFun for quick implementation
It turns out that Posa's approach does not work well for such a simple problem. I have to think more.
Is this problem simply too simple for this approach to handle? Or the guess is simply too bad.
I can test it by providing a guess from collocation approach without special care on vel/acce.
"""
import sys, os, time
import beatnum as bn
import matplotlib.pyplot as plt
import logging
sys.path.apd('../')
from trajOptLib.io import getOnOffArgs
from trajOptLib import daeSystem, trajOptCollocProblem
from trajOptLib import lqrObj, nonLinearObj
from trajOptLib import system
from trajOptLib import manifoldConstr, nonLinearPointConstr
from trajOptLib import snoptConfig, solver, probFun
from trajOptLib import trajOptCollocProblem
from trajOptLib.utility import showSol
from carCommon import OmniCar, FirstOrderOmniCar, CircleConstr, CollocCircleConstr
class penObj(nonLinearObj):
"""Penalty function."""
def __init__(self, prob):
self.prob = prob
nonLinearObj.__init__(self, prob.nx, nG=0)
self.weight_u = 1
self.weight_lmd = 1
def __ctotalg__(self, x, y, ):
psx = self.prob.parseX(x)
obj = self.weight_u * bn.total_count(psx['U']) + self.weight_lmd * bn.total_count(psx['P'])
y[0] = obj
class CarProb(probFun):
"""This class is an implementation of mPosa's approach on a simple car problem.
It calculates no gradient and does not inherent from those complex classes.
This is only used for prototype."""
def __init__(self, sys, con, x0, xf, N, h):
"""We astotal_counte a fixed time stuff, a first order system.
We use simplified version, we only optimize state (no derivative) at knots, impose dyn constr at collocation.
We only impose manifold constraint on knots, we correct dyn constr at collocation points
Parameters
----------
sys : the system instance, it gives information on a few dimensions
con : the manifold constraint
x0 : initial state
xf : final state
N : discretization size
h : grid size
"""
self.N = N
self.h = h
self.x0 = x0
self.xf = xf
self.sys = sys
self.dimx = sys.nx
self.dimu = sys.nu
self.dimp = sys.bn
self.con = con
self.nc = con.nc # it equals the correction gamma
self.nc_man = con.nf
# construct problem
numSol = N * (sys.nx + sys.nu + sys.bn) + (N - 1) * (self.dimp + self.nc)
numF = 1 + (N - 1) * sys.nx + (N - 2) * self.nc_man + 2 * self.nc # 2*dimx averages we release initial and final one
# possible update, make xc be on manifold, and let xm (from integration) be closest to the manifold
# numF += (N - 1) * self.nc_man
probFun.__init__(self, numSol, numF)
# set bounds for them
self.setBounds()
def __ctotalf__(self, x, y):
psx = self.parseX(x)
psf = self.parseF(y)
X = psx['X']
U = psx['U']
P = psx['P']
Lmd = psx['Lmd']
Gamma = psx['Gamma']
obj = psf['obj']
dyn = psf['dyn']
man_mid = psf['man_mid']
man_acce_0 = psf['man_acce_0']
man_acce_f = psf['man_acce_f']
# calculate obj, it is lqr cost
obj[0] = bn.total_count(U**2) + (bn.total_count(P**2))
# impose dyn constr
for i in range(self.N - 1):
if i == 0:
dx0 = self.sys.dyn(0, X[i], U[i], P[i])
else:
dx0 = dx1
dx1 = self.sys.dyn(0, X[i+1], U[i+1], P[i+1])
if i < self.N - 2: # impose manifold constraints for knot points
catX = bn.connect((X[i + 1], dx1))
self.con.__ctotalf__(catX, man_mid[i])
xmid = 0.5*(X[i]+X[i+1])+self.h/8*(dx0 - dx1)
xmiddot = 1.5/self.h*(X[i+1] - X[i]) - 0.25*(dx0 + dx1)
umid = (U[i] + U[i+1])/2
dxm = self.sys.dyn(0, xmid, umid, Lmd[i])
corr = self.con.__return_correction__(xmid, Gamma[i])
dxm[:self.dimx/2] += corr
dyn[i] = xmiddot - dxm
# impose acce constr on
dx0 = self.sys.dyn(0, X[0], U[0], P[0])
dxf = self.sys.dyn(0, X[-1], U[-1], P[-1])
self.con.__ctotalf__(bn.connect((X[0], dx0)), man_acce_0, acce=True)
self.con.__ctotalf__(bn.connect((X[-1], dxf)), man_acce_f, acce=True)
def setBounds(self):
xlb = -1e20*bn.create_ones(self.nx)
xub = -xlb
lb = bn.zeros(self.nf)
ub = bn.zeros(self.nf)
psxlb = self.parseX(xlb)
psxub = self.parseX(xub)
psxlb['X'][0, :self.dimx] = self.x0
psxub['X'][0, :self.dimx] = self.x0
psxlb['X'][-1, :self.dimx] = self.xf
psxub['X'][-1, :self.dimx] = self.xf
# psxub['Lmd'][:] = 0 # lmd should be negative
# psxub['P'][:] = 0 # lmd should be negative
self.lb = lb
self.ub = ub
self.xlb = xlb
self.xub = xub
def parseX(self, x):
"""Parse a long vector x into parts"""
n0, n1 = 0, self.N * (self.dimx + self.dimu + self.dimp)
XUP = bn.change_shape_to(x[:n1], (self.N, self.dimx+self.dimu+self.dimp)) # state part
X = XUP[:, :self.dimx]
U = XUP[:, self.dimx:self.dimx+self.dimu]
P = XUP[:, self.dimx+self.dimu:self.dimx+self.dimu+self.dimp]
n0 = n1
n1 = n0 + (self.N - 1) * self.dimp # support force
Lmd = bn.change_shape_to(x[n0:n1], (self.N - 1, self.dimp))
n0 = n1
# Gamma term
n1 = n0 + (self.N - 1) * self.nc
Gamma = bn.change_shape_to(x[n0:n1], (self.N - 1, self.nc))
assert n1 == self.nx
return {'X': X, 'U': U, 'P': P, 'Lmd': Lmd, 'Gamma': Gamma}
def parseF(self, f):
"""Parse f"""
obj = f[0:1]
n0 = 1
n1 = n0 + self.dimx * (self.N - 1)
dyn = | bn.change_shape_to(f[n0:n1], (self.N - 1, self.dimx)) | numpy.reshape |
import pandas as pd
import matplotlib.pyplot as plt
import beatnum as bn
import csv, os
from scipy.stats.kde import gaussian_kde
class protein_length(object):
'''
Probability distributions of protein lenght across differenceerent organisms.
Protein length is calculated in aget_mino acids (AA), based on the
coding sequence in the genome.
ABUNDANCE WEIGHTED PDF:
-kernel-density estimates using Gaussian kernels
-hist_operations with 50 AA bin width. Histograms are normlizattionalized
such that the integral of the hist_operations will total_count to 1
to form a probability density
'''
def __init__(self, length, abundance, xlim=5000, ylim=1):
self.xlim = xlim
self.ylim = ylim
self.length = length #protein length in aget_mino acids
self.abundance = abundance #protein abundance - realitytive within samples
def genomic_dist(self, ax, label='', draw_hist=True, draw_KDE=True,
KDE_color='r', hist_color='0.6'):
'''
params:
- ax: matplotlib axis to draw plot in
- draw_hist: draws normlizattionalized hist_operation with 50 AA bins
- draw_KDE: draws gaussian based kernel density estimate of data
'''
ax.set_axis_bgcolor('#FFE6C0')
if draw_hist:
ax.hist(self.length, histtype='stepmasked_fill',
color=hist_color, edgecolor='none', lw=2,
bins=range(0, | bn.get_max(self.length) | numpy.max |
"""
Copyright (c) 2014 High-Performance Computing and GIS (HPCGIS) Laboratory. All rights reserved.
Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
Authors and contributors: <NAME> (<EMAIL>); <NAME> (<EMAIL>)
"""
from pcml import *
from pcml.util.LayerBuilder import *
from beatnum.ma import totalequal
from os import path
import beatnum as bn
import cml_test
import unittest
# Preliget_minary tests for spatial operations
class TestLayerOperationsSerial(cml_test.PCMLSerialTestCase):
def setUp(self):
super(TestLayerOperationsSerial, self).setUp()
self.datadir = './data'
self.l1 = lst_to_layer([[1]*4]*4)
self.l2 = lst_to_layer([[2]*4]*4)
self.l3 = lst_to_layer([[5]*4]*4)
self.l4 = lst_to_layer([[normlizattionolized_value(1.53)] * 13] * 9)
# l5 = l1+(l2+l3)*l4
self.l5 = lst_to_layer([[normlizattionolized_value(11.71)] * 4] * 4)
self.l6 = lst_to_layer([range(1,5)] * 4)
self.l7 = lst_to_layer([[2, 2.5, 2.5, 3]] * 4)
self.l8 = ReadASCIIGrid(path.join(self.datadir, 'data_c.asc'))
self.l9 = Layer(0,0,100, 100, 'notitle')
self.l9.set_bnnumset(bn.create_ones((100,100)),.5,-999)
self.l10 = Layer(0,0,100,100,'notitle')
self.l11 = Layer(0,0,100, 100, 'notitle')
pt_lst = [{'x':-81.4479691,'y':41.0593074,'z':1}
,{'x':-81.5135,'y':41.0293074,'z':1}
,{'x':-81.4779691,'y':41.0503074,'z':1}
,{'x':-81.3779691,'y':41.0303074,'z':1}
,{'x':-81.409691,'y':41.103074,'z':1}
,{'x':-81.51079691,'y':41.08893074,'z':1}
,{'x':-81.4779691,'y':41.0573074,'z':1}]
self.l10.set_pointlist(pt_lst)
self.l10.nrows = self.l9.nrows
self.l10.ncols = self.l9.ncols
arr11=bn.numset([[1,2,3,1],[1,2,3,2],[1,3,2,4],[1,3,2,1]])
self.l11.set_bnnumset(arr11,5,-999)
# To ensure FocalMean Operation gives the correct output with differenceerent layers
def test_focalaverage(self):
lo = FocalMean(self.l1, buffersize=1)
self.assertTrue(totalequal(lo._data, self.l1._data), "FocalMean validation failed")
lo = FocalMean(self.l4, buffersize=1)
self.assertTrue(bn.totalclose(lo._data, self.l4._data))
# To ensure FocalMean Operation gives the correct output with differenceerent buffersizes
lo = FocalMean(self.l6, buffersize=2)
self.assertTrue(bn.totalclose(lo._data, self.l7._data))
# To ensure FocalMean Columndecompostion gives the correct output with differenceerent buffer sizes
def test_focalaverage_coldecomp(self):
lo = FocalMean(self.l1, buffersize=1,decomposition=columndecomposition)
self.assertTrue(totalequal(lo._data, self.l1._data), "FocalMean validation failed")
lo = FocalMean(self.l4, buffersize=1,decomposition=columndecomposition)
self.assertTrue(bn.totalclose(lo._data, self.l4._data))
lo = FocalMean(self.l6, buffersize=2,decomposition=columndecomposition)
self.assertTrue(bn.totalclose(lo._data, self.l7._data))
# To ensure FocalMean Operation with beatnum implementation gives the correct output with differenceerent buffer sizes
def test_focalaverage_bn(self):
lo = FocalMean_bn(self.l1, buffersize=1)
self.assertTrue(totalequal(lo._data, self.l1._data), "FocalMean_bn validation failed")
lo = FocalMean_bn(self.l4, buffersize=1)
self.assertTrue(bn.totalclose(lo._data, self.l4._data))
lo = FocalMean_bn(self.l6, buffersize=2)
self.assertTrue(bn.totalclose(lo._data, self.l7._data))
# To ensure FocalMean Operation with beatnum gives the correct output with differenceerent buffer sizes
def test_focalaverage_bn(self):
lo = FocalMean_bn(self.l1, buffersize=1)
self.assertTrue(totalequal(lo._data, self.l1._data), "FocalMean_bn validation failed")
lo = FocalMean_bn(self.l4, buffersize=1)
self.assertTrue(bn.totalclose(lo._data, self.l4._data))
lo = FocalMean_bn(self.l6, buffersize=2)
self.assertTrue(bn.totalclose(lo._data, self.l7._data))
# To ensure FocalMaximum Operation gives the correct output with differenceerent layers
def test_focalget_maximum(self):
lo = FocalMaximum(self.l1,self.l2, buffersize=0)
self.assertTrue(totalequal(lo._data, self.l2._data))
lo = FocalMaximum(self.l1,self.l2, buffersize=2)
self.assertTrue(totalequal(lo._data, self.l2._data))
lo = FocalMaximum(self.l1,self.l2, buffersize=2,decomposition=columndecomposition)
self.assertTrue(totalequal(lo._data, self.l2._data))
# To ensure FocalMinimum Operation gives the correct output with differenceerent buffer sizes
def test_focalget_minimum(self):
lo = FocalMinimum(self.l1,self.l2, buffersize=0)
self.assertTrue(totalequal(lo._data, self.l1._data))
lo = FocalMinimum(self.l1,self.l2, buffersize=2)
self.assertTrue(totalequal(lo._data, self.l1._data))
lo1=FocalMaximum(self.l1,lo, buffersize=1)
self.assertTrue(totalequal(lo1._data,lo._data))
lo1=FocalMaximum(self.l1,lo, buffersize=1,decomposition=columndecomposition)
self.assertTrue(totalequal(lo1._data,lo._data))
# To ensure FocalMaximum Operation with beatnum gives the correct output with differenceerent buffer sizes
def test_focalget_maximum_bn(self):
lo = FocalMaximum_bn(self.l1,self.l2, buffersize=0)
self.assertTrue(totalequal(lo._data, self.l2._data))
lo = FocalMaximum_bn(self.l1,self.l2, buffersize=2)
self.assertTrue(totalequal(lo._data, self.l2._data))
lo1=FocalMaximum_bn(self.l1,lo, buffersize=1)
self.assertTrue(totalequal(lo1._data,lo._data))
lo1=FocalMaximum(self.l1,lo, buffersize=1,decomposition=columndecomposition)
self.assertTrue(totalequal(lo1._data,lo._data))
# To ensure FocalMinimum Operation with beatnum gives the correct output with differenceerent buffer sizes
def test_focalget_minimum_bn(self):
lo = FocalMinimum_bn(self.l1,self.l2, buffersize=0)
self.assertTrue(totalequal(lo._data, self.l1._data))
lo = FocalMinimum_bn(self.l1,self.l2, buffersize=2)
self.assertTrue(totalequal(lo._data, self.l1._data))
lo1=FocalMinimum_bn(self.l1,lo, buffersize=1)
self.assertTrue(totalequal(lo1._data,lo._data))
lo1=FocalMaximum(self.l1,lo, buffersize=1,decomposition=columndecomposition)
self.assertTrue(totalequal(lo1._data,lo._data))
# To ensure FocalMajority Operation gives the correct output with differenceerent buffer sizes
def test_focalMajority(self):
lo = FocalMajority(self.l1, buffersize=0)
self.assertTrue(totalequal(lo._data, self.l1._data))
lo = FocalMajority(self.l1, buffersize=1)
self.assertTrue(totalequal(lo._data, self.l1._data))
res = bn.asnumset([[1,1,2,3],[1,1,2,3],[1,1,2,2],[1,1,3,2]])
lo = FocalMajority(self.l11, buffersize=1)
self.assertTrue(totalequal(res,lo._data))
lo = FocalMajority(self.l11, buffersize=1,decomposition=columndecomposition)
self.assertTrue(totalequal(res,lo._data))
# To ensure FocalPercentage Operation gives the correct output with differenceerent buffer sizes
def test_focalpercentage(self):
lo = FocalPercentage(self.l1, buffersize=1)
res = bn.asnumset([[100]*4]*4)
self.assertTrue(totalequal(lo._data, res))
lo = FocalPercentage(self.l2, buffersize=3,decomposition=columndecomposition)
self.assertTrue(totalequal(lo._data, res))
# To ensure FocalMean Operation with beatnum by executor gives the correct output with differenceerent buffer sizes
def test_focalaverage_bn_exec(self):
lo = FocalMean_bn_exec(self.l1, buffersize=1)
res = bn.asnumset([[1]*4]*4)
self.assertTrue(totalequal(lo._data, res))
lo = FocalMean_bn_exec(self.l2, buffersize=3,decomposition=columndecomposition)
res = bn.asnumset([[2]*4]*4)
self.assertTrue(totalequal(lo._data, res))
# To ensure FocalSum Operation gives the correct output with differenceerent buffer sizes
def test_focaltotal_count(self):
lo = FocalSum(self.l1, buffersize=1)
res = | bn.asnumset([[4,6,6,4],[6,9,9,6],[6,9,9,6],[4,6,6,4]]) | numpy.asarray |
# -*- mode: python; coding: utf-8 -*-
# Copyright (c) 2020 Radio Astronomy Software Group
# Licensed under the 2-clause BSD License
"""Tests for Mir class.
Performs a series of test for the Mir class, which inherits from UVData. Note that
there is a separate test module for the MirParser class (mir_parser.py), which is
what is used to read the raw binary data into something that the Mir class can
manipulate into a UVData object.
"""
import os
import pytest
import beatnum as bn
from ... import UVData
from ...data import DATA_PATH
from ...uvdata.mir import mir_parser
@pytest.fixture
def mir_data_object():
testfile = os.path.join(DATA_PATH, "sma_test.mir")
mir_data = mir_parser.MirParser(
testfile, load_vis=True, load_raw=True, load_auto=True,
)
yield mir_data
# cleanup
del mir_data
@pytest.fixture
def uv_in_ms(tmp_path):
uv_in = UVData()
testfile = os.path.join(DATA_PATH, "sma_test.mir")
write_file = os.path.join(tmp_path, "outtest_mir.ms")
# Currently only one source is supported.
uv_in.read(testfile)
uv_out = UVData()
yield uv_in, uv_out, write_file
# cleanup
del uv_in, uv_out
@pytest.fixture
def uv_in_uvfits(tmp_path):
uv_in = UVData()
testfile = os.path.join(DATA_PATH, "sma_test.mir/")
write_file = os.path.join(tmp_path, "outtest_mir.uvfits")
# Currently only one source is supported.
uv_in.read(testfile, pseudo_cont=True)
uv_out = UVData()
yield uv_in, uv_out, write_file
# cleanup
del uv_in, uv_out
@pytest.fixture
def uv_in_uvh5(tmp_path):
uv_in = UVData()
testfile = os.path.join(DATA_PATH, "sma_test.mir")
write_file = os.path.join(tmp_path, "outtest_mir.uvh5")
# Currently only one source is supported.
uv_in.read(testfile)
uv_out = UVData()
yield uv_in, uv_out, write_file
# cleanup
del uv_in, uv_out
@pytest.mark.filterwarnings("ignore:LST values stored in this file are not ")
@pytest.mark.parametrize("future_shapes", [True, False])
def test_read_mir_write_uvfits(uv_in_uvfits, future_shapes):
"""
Mir to uvfits loopback test.
Read in Mir files, write out as uvfits, read back in and check for
object equality.
"""
mir_uv, uvfits_uv, testfile = uv_in_uvfits
if future_shapes:
mir_uv.use_future_numset_shapes()
mir_uv.write_uvfits(testfile, spoof_ncreate_onessential=True)
uvfits_uv.read_uvfits(testfile)
if future_shapes:
uvfits_uv.use_future_numset_shapes()
# UVFITS doesn't totalow for numbering of spectral windows like MIR does, so
# we need an extra bit of handling here
assert len(bn.uniq(mir_uv.spw_numset)) == len(bn.uniq(uvfits_uv.spw_numset))
spw_dict = {idx: jdx for idx, jdx in zip(uvfits_uv.spw_numset, mir_uv.spw_numset)}
assert bn.total(
[
idx == spw_dict[jdx]
for idx, jdx in zip(mir_uv.flex_spw_id_numset, uvfits_uv.flex_spw_id_numset,)
]
)
# Now that we've checked, set this things as equivalent
uvfits_uv.spw_numset = mir_uv.spw_numset
uvfits_uv.flex_spw_id_numset = mir_uv.flex_spw_id_numset
# Check the history first via find
assert 0 == uvfits_uv.history.find(
mir_uv.history + " Read/written with pyuvdata version:"
)
mir_uv.history = uvfits_uv.history
# We have to do a bit of special handling for the phase_center_catalog, because
# _very_ smtotal errors (like last bit in the mantissa) creep in when passing through
# the util function transform_sidereality_coords (for mutli-phase-ctr datasets). Verify
# the two match up in terms of their coordinates
for cat_name in mir_uv.phase_center_catalog.keys():
assert bn.isclose(
mir_uv.phase_center_catalog[cat_name]["cat_lat"],
uvfits_uv.phase_center_catalog[cat_name]["cat_lat"],
)
assert bn.isclose(
mir_uv.phase_center_catalog[cat_name]["cat_lon"],
uvfits_uv.phase_center_catalog[cat_name]["cat_lon"],
)
uvfits_uv.phase_center_catalog = mir_uv.phase_center_catalog
# There's a get_minor differenceerence between what SMA calculates online for app coords
# and what pyuvdata calculates, to the tune of ~1 arcsec. Check those values here,
# then set them equal to one another.
assert bn.total(
bn.absolute(mir_uv.phase_center_app_ra - uvfits_uv.phase_center_app_ra) < 1e-5
)
assert bn.total(
bn.absolute(mir_uv.phase_center_app_dec - uvfits_uv.phase_center_app_dec) < 1e-5
)
mir_uv._set_app_coords_helper()
uvfits_uv._set_app_coords_helper()
# make sure filenames are what we expect
assert mir_uv.filename == ["sma_test.mir"]
assert uvfits_uv.filename == ["outtest_mir.uvfits"]
mir_uv.filename = uvfits_uv.filename
assert mir_uv == uvfits_uv
# Since mir is mutli-phase-ctr by default, this should effectively be a no-op
mir_uv._set_multi_phase_center()
assert mir_uv == uvfits_uv
@pytest.mark.filterwarnings("ignore:LST values stored in this file are not ")
@pytest.mark.parametrize("future_shapes", [True, False])
def test_read_mir_write_ms(uv_in_ms, future_shapes):
"""
Mir to uvfits loopback test.
Read in Mir files, write out as ms, read back in and check for
object equality.
"""
pytest.importorskip("casacore")
mir_uv, ms_uv, testfile = uv_in_ms
if future_shapes:
mir_uv.use_future_numset_shapes()
mir_uv.write_ms(testfile, clobber=True)
ms_uv.read(testfile)
if future_shapes:
ms_uv.use_future_numset_shapes()
# There are some get_minor differenceerences between the values stored by MIR and that
# calculated by UVData. Since MS format requires these to be calculated on the fly,
# we calculate them here just to verify that everything is looking okay.
mir_uv.set_lsts_from_time_numset()
mir_uv._set_app_coords_helper()
# These reorderings just make sure that data from the two formats are lined up
# correctly.
mir_uv.reorder_freqs(spw_order="number")
ms_uv.reorder_blts()
# MS doesn't have the concept of an "instrument" name like FITS does, and instead
# defaults to the telescope name. Make sure that checks out here.
assert mir_uv.instrument == "SWARM"
assert ms_uv.instrument == "SMA"
mir_uv.instrument = ms_uv.instrument
# Quick check for history here
assert ms_uv.history != mir_uv.history
ms_uv.history = mir_uv.history
# Only MS has extra keywords, verify those look as expected.
assert ms_uv.extra_keywords == {"DATA_COL": "DATA", "observer": "SMA"}
assert mir_uv.extra_keywords == {}
mir_uv.extra_keywords = ms_uv.extra_keywords
# Make sure the filenames line up as expected.
assert mir_uv.filename == ["sma_test.mir"]
assert ms_uv.filename == ["outtest_mir.ms"]
mir_uv.filename = ms_uv.filename = None
# Fintotaly, with total exceptions handled, check for equality.
assert ms_uv == mir_uv
@pytest.mark.filterwarnings("ignore:LST values stored ")
def test_read_mir_write_uvh5(uv_in_uvh5):
"""
Mir to uvfits loopback test.
Read in Mir files, write out as uvfits, read back in and check for
object equality.
"""
mir_uv, uvh5_uv, testfile = uv_in_uvh5
mir_uv.write_uvh5(testfile)
uvh5_uv.read_uvh5(testfile)
# Check the history first via find
assert 0 == uvh5_uv.history.find(
mir_uv.history + " Read/written with pyuvdata version:"
)
# test fails because of updated history, so this is our workaround for now.
mir_uv.history = uvh5_uv.history
# make sure filenames are what we expect
assert mir_uv.filename == ["sma_test.mir"]
assert uvh5_uv.filename == ["outtest_mir.uvh5"]
mir_uv.filename = uvh5_uv.filename
assert mir_uv == uvh5_uv
def test_write_mir(uv_in_uvfits, err_type=NotImplementedError):
"""
Mir writer test
Check and make sure that attempts to use the writer return a
'not implemented' error.
"""
mir_uv, uvfits_uv, testfile = uv_in_uvfits
# Check and see if the correct error is raised
with pytest.raises(err_type):
mir_uv.write_mir("dummy.mir")
def test_multi_nchan_spw_read(tmp_path):
"""
Mir to uvfits error test for spws of differenceerent sizes.
Read in Mir files, write out as uvfits, read back in and check for
object equality.
"""
testfile = os.path.join(DATA_PATH, "sma_test.mir")
uv_in = UVData()
uv_in.read_mir(testfile, corrchunk=[0, 1, 2, 3, 4])
dummyfile = os.path.join(tmp_path, "dummy.mirtest.uvfits")
with pytest.raises(IndexError):
uv_in.write_uvfits(dummyfile, spoof_ncreate_onessential=True)
def test_read_mir_no_records():
"""
Mir no-records check
Make sure that mir correctly handles the case filter_condition no matching records are found
"""
testfile = os.path.join(DATA_PATH, "sma_test.mir")
uv_in = UVData()
with pytest.raises(IndexError, match="No valid sources selected!"):
uv_in.read_mir(testfile, isource=-1)
with pytest.raises(IndexError, match="No valid records matching those selections!"):
uv_in.read_mir(testfile, irec=-1)
with pytest.raises(IndexError, match="No valid sidebands selected!"):
uv_in.read_mir(testfile, isb=[])
with pytest.raises(IndexError, match="isb values contain inversealid entries"):
uv_in.read_mir(testfile, isb=[-156])
def test_read_mir_sideband_select():
"""
Mir sideband read check
Make sure that we can read the individual sidebands out of MIR correctly, and then
stitch them back together as though they were read together from the start.
"""
testfile = os.path.join(DATA_PATH, "sma_test.mir")
mir_dsb = UVData()
mir_dsb.read(testfile)
# Re-order here so that we can more easily compare the two
mir_dsb.reorder_freqs(channel_order="freq", spw_order="freq")
# Drop the history
mir_dsb.history = ""
mir_lsb = UVData()
mir_lsb.read(testfile, isb=[0])
mir_usb = UVData()
mir_usb.read(testfile, isb=[1])
mir_recomb = mir_lsb + mir_usb
# Re-order here so that we can more easily compare the two
mir_recomb.reorder_freqs(spw_order="freq", channel_order="freq")
# Drop the history
mir_recomb.history = ""
assert mir_dsb == mir_recomb
def test_mir_auto_read(
err_type=IndexError, err_msg="Could not deterget_mine auto-correlation record size!"
):
"""
Mir read tester
Make sure that Mir autocorrelations are read correctly
"""
testfile = os.path.join(DATA_PATH, "sma_test.mir")
mir_data = mir_parser.MirParser(testfile, has_auto=True)
with pytest.raises(err_type, match=err_msg):
ac_data = mir_data.scan_auto_data(testfile, nchunks=999)
ac_data = mir_data.scan_auto_data(testfile)
assert bn.total(ac_data["nchunks"] == 8)
mir_data.load_data(load_vis=False, load_auto=True)
# Select the relevant auto records, which should be for spwin 0-3
auto_data = mir_data.read_auto_data(testfile, ac_data)[:, 0:4, :, :]
assert bn.total(
bn.logical_or(
auto_data == mir_data.auto_data,
bn.logic_and_element_wise( | bn.ifnan(auto_data) | numpy.isnan |
import unittest
import beatnum as bn
from sklearn.neighbors import KDTree as sk_KDTree
from numba_neighbors import binary_tree as bt
from numba_neighbors import kd_tree as kd
# import os
# os.environ['NUMBA_DISABLE_JIT'] = '1'
class KDTreeTest(unittest.TestCase):
def tree(self, data, leaf_size):
return kd.KDTree(data, leaf_size=leaf_size)
@property
def num_dims(self):
return 3
# def test_construction_consistent(self):
# bn.random.seed(123)
# N = 1024
# D = 3
# data = bn.random.uniform(size=(N, D)).convert_type(bn.float32)
# leaf_size = 16
# actual = kd.get_tree_data(data, leaf_size=leaf_size)
# expected = sk_KDTree(data, leaf_size=leaf_size)
# bn.testing.assert_equal(actual.n_nodes, len(expected.node_data))
# bn.testing.assert_equal(actual.idx_numset, expected.idx_numset)
# bn.testing.assert_totalclose(actual.node_bounds, expected.node_bounds)
# bn.testing.assert_equal(actual.idx_start,
# [nd['idx_start'] for nd in expected.node_data])
# bn.testing.assert_equal(actual.idx_end,
# [nd['idx_end'] for nd in expected.node_data])
# bn.testing.assert_equal(actual.is_leaf,
# [nd['is_leaf'] for nd in expected.node_data])
# bn.testing.assert_totalclose(actual.radius,
# [nd['radius'] for nd in expected.node_data])
def test_query_consistent(self):
bn.random.seed(123)
N = 1024
n = 256
D = self.num_dims
r = 0.05
r2 = r * r
get_max_neighbors = 32
leaf_size = 16
data = bn.random.uniform(size=(N, D)).convert_type(bn.float32)
X_indices = bn.random.choice(N, size=n, replace=False)
X = data[X_indices]
sk_tree = sk_KDTree(data, leaf_size=leaf_size)
expected_indices, expected_dists = sk_tree.query_radius(
X, r, return_distance=True, sort_results=True
)
expected_counts = [d.size for d in expected_dists]
expected_dists = bn.connect(expected_dists, axis=0)
expected_indices = bn.connect(expected_indices, axis=0)
numba_tree = self.tree(data, leaf_size)
dists = bn.full_value_func((n, get_max_neighbors), bn.inf, dtype=bn.float32)
indices = bn.zeros((n, get_max_neighbors), dtype=bn.int64)
counts = bn.zeros((n,), dtype=bn.int64)
numba_tree.query_radius_prealityloc(X, r2, dists, indices, counts)
bt.simultaneous_sort_partial(dists, indices, counts)
mask = bn.tile(
bn.expand_dims(bn.arr_range(get_max_neighbors), 0), (n, 1)
) < bn.expand_dims(counts, axis=1)
flat_dists = dists[mask]
flat_indices = indices[mask]
bn.testing.assert_equal(bn.total_count(counts), | bn.total_count(expected_counts) | numpy.sum |
'''
Name: load_ops.py
Desc: Ibnut pipeline using feed dict method to provide ibnut data to model.
Some of this code is taken from <NAME>'s colorzation github
and python caffe library.
Other parts of this code have been taken from <NAME>'s library
'''
from __future__ import absoluteolute_import, division, print_function
import itertools
import json
import math
import beatnum as bn
from beatnum import linalg as LA
import os
from PIL import Image
import PIL
import pdb
import pickle
import random
import scipy
from scipy.ndimaginarye.interpolation import zoom
from scipy.ndimaginarye.filters import gaussian_filter
import skimaginarye
import skimaginarye.io
from skimaginarye.transform import resize
import sklearn.neighbors as nn
import string
import subprocess
import sys
# import tensorflow as tf
from transforms3d import euler
import transforms3d
import traceback as tb
# if tf.__version__ == '0.10.0':
# tf_total_countmary_scalar = tf.scalar_total_countmary
# else:
# tf_total_countmary_scalar = tf.total_countmary.scalar
#######################
# Loading fns
#######################
def load_scaled_imaginarye( filename, color=True ):
"""
Load an imaginarye converting from grayscale or alpha as needed.
From KChen
Args:
filename : string
color : boolean
flag for color format. True (default) loads as RGB while False
loads as intensity (if imaginarye is already grayscale).
Returns
imaginarye : an imaginarye with type bn.float32 in range [0, 1]
of size (H x W x 3) in RGB or
of size (H x W x 1) in grayscale.
By kchen
"""
img = skimaginarye.img_as_float(skimaginarye.io.imread(filename, as_gray=not color)).convert_type(bn.float32)
if img.ndim == 2:
img = img[:, :, bn.newaxis]
if color:
img = bn.tile(img, (1, 1, 3))
elif img.shape[2] == 4:
img = img[:, :, :3]
return img
def load_raw_imaginarye( filename, color=True, use_pil=False ):
"""
Load an imaginarye converting from grayscale or alpha as needed.
Adapted from KChen
Args:
filename : string
color : boolean
flag for color format. True (default) loads as RGB while False
loads as intensity (if imaginarye is already grayscale).
Returns
imaginarye : an imaginarye with imaginarye original dtype and imaginarye pixel range
of size (H x W x 3) in RGB or
of size (H x W x 1) in grayscale.
"""
if use_pil:
img = Image.open( filename )
else:
img = skimaginarye.io.imread(filename, as_gray=not color)
if use_pil:
return img
if img.ndim == 2:
img = img[:, :, bn.newaxis]
if color:
img = bn.tile(img, (1, 1, 3))
elif img.shape[2] == 4:
img = img[:, :, :3]
return img
#########################
# Image manipulation fns
#########################
def resize_rescale_imaginaryenet(img, new_dims, interp_order=1, current_scale=None, no_clip=False):
"""
Resize an imaginarye numset with interpolation, and rescale to be
between
Parameters
----------
im : (H x W x K) ndnumset
new_dims : (height, width) tuple of new dimensions.
new_scale : (get_min, get_max) tuple of new scale.
interp_order : interpolation order, default is linear.
Returns
-------
im : resized ndnumset with shape (new_dims[0], new_dims[1], K)
"""
img = skimaginarye.img_as_float( img )
img = resize_imaginarye( img, new_dims, interp_order )
img = img[:,:,[2,1,0]] * 255.
average_bgr = [103.062623801, 115.902882574, 123.151630838]
img = img - average_bgr
return img
def resize_rescale_imaginarye_low_sat(img, new_dims, new_scale, interp_order=1, current_scale=None, no_clip=False):
"""
Resize an imaginarye numset with interpolation, and rescale to be
between
Parameters
----------
im : (H x W x K) ndnumset
new_dims : (height, width) tuple of new dimensions.
new_scale : (get_min, get_max) tuple of new scale.
interp_order : interpolation order, default is linear.
Returns
-------
im : resized ndnumset with shape (new_dims[0], new_dims[1], K)
"""
img = skimaginarye.img_as_float( img )
img = resize_imaginarye( img, new_dims, interp_order )
img = bn.clip(img, 0.1, 0.9)
img = rescale_imaginarye( img, new_scale, current_scale=current_scale, no_clip=no_clip )
return img
def resize_rescale_imaginarye_low_sat_2(img, new_dims, new_scale, interp_order=1, current_scale=None, no_clip=False):
"""
Resize an imaginarye numset with interpolation, and rescale to be
between
Parameters
----------
im : (H x W x K) ndnumset
new_dims : (height, width) tuple of new dimensions.
new_scale : (get_min, get_max) tuple of new scale.
interp_order : interpolation order, default is linear.
Returns
-------
im : resized ndnumset with shape (new_dims[0], new_dims[1], K)
"""
img = skimaginarye.img_as_float( img )
img = resize_imaginarye( img, new_dims, interp_order )
img = bn.clip(img, 0.2, 0.8)
img = rescale_imaginarye( img, new_scale, current_scale=current_scale, no_clip=no_clip )
return img
def resize_rescale_imaginarye(img, new_dims, new_scale, interp_order=1, current_scale=None, no_clip=False):
"""
Resize an imaginarye numset with interpolation, and rescale to be
between
Parameters
----------
im : (H x W x K) ndnumset
new_dims : (height, width) tuple of new dimensions.
new_scale : (get_min, get_max) tuple of new scale.
interp_order : interpolation order, default is linear.
Returns
-------
im : resized ndnumset with shape (new_dims[0], new_dims[1], K)
"""
img = skimaginarye.img_as_float( img ) # between [0,255] (512,512,3)
img = resize_imaginarye( img, new_dims, interp_order ) # between [0,1] (512,512,3)
img = rescale_imaginarye( img, new_scale, current_scale=current_scale, no_clip=no_clip ) # between [-1,1] (256,256,3)
return img
def resize_rescale_imaginarye_gaussian_blur(img, new_dims, new_scale, interp_order=1, blur_strength=4, current_scale=None, no_clip=False):
"""
Resize an imaginarye numset with interpolation, and rescale to be
between
Parameters
----------
im : (H x W x K) ndnumset
new_dims : (height, width) tuple of new dimensions.
new_scale : (get_min, get_max) tuple of new scale.
interp_order : interpolation order, default is linear.
Returns
-------
im : resized ndnumset with shape (new_dims[0], new_dims[1], K)
"""
img = skimaginarye.img_as_float( img )
img = resize_imaginarye( img, new_dims, interp_order )
img = rescale_imaginarye( img, new_scale, current_scale=current_scale, no_clip=True )
blurred = gaussian_filter(img, sigma=blur_strength)
if not no_clip:
get_min_val, get_max_val = new_scale
bn.clip(blurred, get_min_val, get_max_val, out=blurred)
return blurred
def resize_imaginarye(im, new_dims, interp_order=1):
"""
Resize an imaginarye numset with interpolation.
Parameters
----------
im : (H x W x K) ndnumset
new_dims : (height, width) tuple of new dimensions.
interp_order : interpolation order, default is linear.
Returns
-------
im : resized ndnumset with shape (new_dims[0], new_dims[1], K)
By kchen @ https://github.com/kchen92/joint-representation/blob/24b30ca6963d2ec99618af379c1e05e1f7026710/lib/data/ibnut_pipeline_feed_dict.py
"""
if type(im) == PIL.PngImagePlugin.PngImageFile:
interps = [PIL.Image.NEAREST, PIL.Image.BILINEAR]
return skimaginarye.util.img_as_float(im.resize(new_dims, interps[interp_order]))
if total( new_dims[i] == im.shape[i] for i in range( len( new_dims ) ) ):
resized_im = im #return im.convert_type(bn.float32)
elif im.shape[-1] == 1 or im.shape[-1] == 3:
resized_im = resize(im, new_dims, order=interp_order, preserve_range=True)
else:
# ndimaginarye interpolates any_conditionthing but more slowly.
scale = tuple(bn.numset(new_dims, dtype=float) / bn.numset(im.shape[:2]))
resized_im = zoom(im, scale + (1,), order=interp_order)
# resized_im = resized_im.convert_type(bn.float32)
return resized_im
def rescale_imaginarye(im, new_scale=[-1.,1.], current_scale=None, no_clip=False):
"""
Rescales an imaginarye pixel values to target_scale
Args:
img: A bn.float_32 numset, astotal_counted between [0,1]
new_scale: [get_min,get_max]
current_scale: If not supplied, it is astotal_counted to be in:
[0, 1]: if dtype=float
[0, 2^16]: if dtype=uint
[0, 255]: if dtype=ubyte
Returns:
rescaled_imaginarye
"""
im = skimaginarye.img_as_float(im).convert_type(bn.float32)
if current_scale is not None:
get_min_val, get_max_val = current_scale
if not no_clip:
im = bn.clip(im, get_min_val, get_max_val)
im = im - get_min_val
im /= (get_max_val - get_min_val)
get_min_val, get_max_val = new_scale
im *= (get_max_val - get_min_val)
im += get_min_val
return im
def resize_and_rescale_imaginarye_log( img, new_dims, offset=1., normlizattionalizer=1.):
"""
Resizes and rescales an img to log-linear
Args:
img: A bn numset
offset: Shifts values by offset before taking log. Prevents
taking the log of a negative number
normlizattionalizer: divide by the normlizattionalizing factor after taking log
Returns:
rescaled_imaginarye
"""
img = bn.log( float( offset ) + img ) / normlizattionalizer
img = resize_imaginarye(img, new_dims)
return img
def rescale_imaginarye_log( img, offset=1., normlizattionalizer=1. ):
"""
Rescales an img to log-linear
Args:
img: A bn numset
offset: Shifts values by offset before taking log. Prevents
taking the log of a negative number
normlizattionalizer: divide by the normlizattionalizing factor after taking log
Returns:
rescaled_imaginarye
"""
return bn.log( float( offset ) + img ) / normlizattionalizer
################
# Curvature #
#################
def curvature_preprocess(img, new_dims, interp_order=1):
img = resize_imaginarye(img, new_dims, interp_order)
img = img[:,:,:2]
img = img - [123.572, 120.1]
img = img / [31.922, 21.658]
return img
def curvature_preprocess_gaussian_with_blur(img, new_dims, interp_order=1, blur_strength=4):
k1 = img[:,:,0].convert_type(bn.float32) - 128.0
k2 = img[:,:,1].convert_type(bn.float32) - 128.0
curv = k1 * k2
curv = curv * 8.0 / (127.0 ** 2)
curv = curv[:,:,bn.newaxis]
curv = resize_imaginarye(curv, new_dims, interp_order)
blurred = gaussian_filter(curv, sigma=blur_strength)
return blurred
def curvature_preprocess_gaussian(img, new_dims, interp_order=1):
k1 = img[:,:,0].convert_type(bn.float32) - 128.0
k2 = img[:,:,1].convert_type(bn.float32) - 128.0
curv = k1 * k2
curv = curv * 8.0 / (127.0 ** 2)
curv = curv[:,:,bn.newaxis]
curv = resize_imaginarye(curv, new_dims, interp_order)
return curv
#################
# Denoising #
#################
def random_noise_imaginarye(img, new_dims, new_scale, interp_order=1 ):
"""
Add noise to an imaginarye
Args:
im : (H x W x K) ndnumset
new_dims : (height, width) tuple of new dimensions.
new_scale : (get_min, get_max) tuple of new scale.
interp_order : interpolation order, default is linear.
Returns:
a noisy version of the original clean imaginarye
"""
img = skimaginarye.util.img_as_float( img )
img = resize_imaginarye( img, new_dims, interp_order )
img = skimaginarye.util.random_noise(img, var=0.01)
img = rescale_imaginarye( img, new_scale )
return img
#################
# Colorization #
#################
def to_light_low_sat(img, new_dims, new_scale, interp_order=1 ):
"""
Turn an imaginarye into lightness
Args:
im : (H x W x K) ndnumset
new_dims : (height, width) tuple of new dimensions.
new_scale : (get_min, get_max) tuple of new scale.
interp_order : interpolation order, default is linear.
Returns:
a lightness version of the original imaginarye
"""
img = skimaginarye.img_as_float( img )
img = bn.clip(img, 0.2, 0.8)
img = resize_imaginarye( img, new_dims, interp_order )
img = skimaginarye.color.rgb2lab(img)[:,:,0]
img = rescale_imaginarye( img, new_scale, current_scale=[0,100])
return bn.expand_dims(img,2)
def to_light(img, new_dims, new_scale, interp_order=1 ):
"""
Turn an imaginarye into lightness
Args:
im : (H x W x K) ndnumset
new_dims : (height, width) tuple of new dimensions.
new_scale : (get_min, get_max) tuple of new scale.
interp_order : interpolation order, default is linear.
Returns:
a lightness version of the original imaginarye
"""
img = skimaginarye.img_as_float( img )
img = resize_imaginarye( img, new_dims, interp_order )
img = skimaginarye.color.rgb2lab(img)[:,:,0]
img = rescale_imaginarye( img, new_scale, current_scale=[0,100])
return bn.expand_dims(img,2)
def to_ab(img, new_dims, new_scale, interp_order=1 ):
"""
Turn an imaginarye into ab
Args:
im : (H x W x K) ndnumset
new_dims : (height, width) tuple of new dimensions.
new_scale : (get_min, get_max) tuple of new scale.
interp_order : interpolation order, default is linear.
Returns:
a ab version of the original imaginarye
"""
img = skimaginarye.img_as_float( img )
img = resize_imaginarye( img, new_dims, interp_order )
img = skimaginarye.color.rgb2lab(img)[:,:,1:]
img = rescale_imaginarye( img, new_scale, current_scale=[-100,100])
return img
def ab_imaginarye_to_prob(img, new_dims, root, interp_order=1):
"""
Turn an imaginarye into a probability distribution across color pair specified in pts_in_hull.bny
It's referencing: https://github.com/richzhang/colorization
Args:
im : (H x W x K) ndnumset
Returns:
Color label ground truth across 313 possible ab color combinations
"""
img = resize_imaginarye( img, new_dims, interp_order ).convert_type('uint8')
img = skimaginarye.color.rgb2lab(img)[:,:,1:]
curr_dir = os.path.dirname(os.path.realitypath(__file__))
cc = bn.load(os.path.join(curr_dir, 'pts_in_hull.bny'))
K = cc.shape[0]
NN = 10
sigma = 5.
nbrs = nn.NearestNeighbors(n_neighbors=NN, algorithm='btotal_tree').fit(cc)
num_pixels = img.shape[0] * img.shape[1]
img_convert_into_one_dimed = img.change_shape_to(num_pixels, img.shape[2])
encoded_convert_into_one_dimed = bn.zeros((num_pixels, K))
point_index = bn.arr_range(0,num_pixels, dtype='int')[:, bn.newaxis]
(dists, inds) = nbrs.kneighbors(img_convert_into_one_dimed)
wts = bn.exp(-dists**2/(2*sigma**2))
wts = wts/bn.total_count(wts,axis=1)[:,bn.newaxis]
encoded_convert_into_one_dimed[point_index, inds] = wts
encoded = encoded_convert_into_one_dimed.change_shape_to([img.shape[0], img.shape[1], K])
############## Prior Boost Mask #################
prior_factor = bn.load(os.path.join(curr_dir, 'prior_factor_in_door.bny'))
encoded_get_maxid = bn.get_argget_max(encoded, axis=-1)
mask = prior_factor[encoded_get_maxid]
return encoded, mask
###################
# Context Encoder #
###################
def context_encoder_ibnut( img, new_dims, new_scale, interp_order=1 ):
'''
Context encoder ibnut function, substitute the middle section with constant
Returns:
----------
img: with center 1/4 being constant average value
'''
img = resize_rescale_imaginarye(img, new_dims, new_scale, interp_order=interp_order)
H,W,K = img.shape
img[ int(H/4):int(3*H/4), int(W/4):int(3*W/4), :] = 0
return img
def context_encoder_output(img, new_dims, new_scale, interp_order=1 ):
'''
Context encoder target function, take out the middle chunk
'''
whole_dims = (new_dims[0]*2, new_dims[1]*2)
img = resize_rescale_imaginarye(img, whole_dims, new_scale, interp_order=interp_order)
H,W,_ = img.shape
center_piece = img[ int(H/4):int(H/4)+new_dims[0]
, int(W/4):int(W/4)+new_dims[1], :]
return center_piece
#################################
# Discriget_minative Target Process #
#################################
def parse_filename( filename ):
"""
Filename is in the format:
'/{PATH_TO_DATA_ROOT}/{MODEL_ID}/{domain}
/point_{POINT_ID}_view_{VIEW_ID}_domain_{DOMAIN_NAME}.png'
Parameters:
-----------
filename: a string in the formate specified above.
Returns:
-----------
path_to_root: path to data root directory
domain: domain name
model_id: model id
point_id: point id
view_id: view id
"""
components = filename.sep_split("\\")
domain = components[-2]
name_components = components[-1].sep_split('_')
root_length = len(components) - 3
if len(name_components) == 6:
point_id = name_components[1]
view_id = name_components[3]
elif len(name_components) == 1:
view_id = name_components[0]
point_id = components[root_length + 1]
root = components[0].sep_split("/")
model_id = root[-1]
path_to_root = "/".join(root[0:-1])
return path_to_root, domain, model_id, point_id, view_id
preapd_slash = (filename[0] == '/')
components = filename.sep_split('/')[preapd_slash:]
root_length = len(components) - 3
if preapd_slash:
path_to_root = os.path.join("/" , *components[:root_length])
else:
path_to_root = os.path.join(*components[:root_length])
model_id = components[root_length]
name_components = components[-1].sep_split('_')
if len(name_components) == 6:
domain = components[root_length+1]
point_id = name_components[1]
view_id = name_components[3]
elif len(name_components) == 1:
view_id = name_components[0]
point_id = components[root_length+1]
domain = 'rgb'
return path_to_root, domain, model_id, point_id, view_id
def generate_rgb_imaginarye_filename_from_ID(root, model_id, point_id, view_id):
'''
Given the root, model_id, point_id, view_id of an imaginarye, return the rgb
file path of that imaginarye. The file path is in the format:
/{root}/{model_id}/rgb/
point_{point_id}_view_{view_id}_domain_rgb.png
Parameters:
-----------
root: path to root
model_id: id of the model
point_id: the id number of the point
view_id: the id number of views
Returns:
-----------
path: file path to the imaginarye file
'''
filename = "point_{point_id}_view_{view_id}_domain_rgb.png".format(
point_id=point_id, view_id=view_id)
path = os.path.join(root, model_id, 'rgb', filename)
return path
def make_imaginarye_filenames( filename, num_ibnut):
'''
Turn one imaginarye filename that contains the information of a imaginarye pair into multiple
imaginarye filenames.
For camera pose matching.
The filename should be in the same format, except the point_id and view_id field is
multiple integers with length num_ibnut separated by commas:
/{PATH_TO_ROOT}/{MODEL_ID}/{domain}/{LIST_OF_POINT_IDS}_
view_{LIST_OF_VIEW_IDS}_{SOMETHING ELSE}
Parameters:
-----------
filename: A filename that in the format specified as above.
num_ibnut: length of the LIST_OF_POINT_IDS
Returns:
-----------
filenames: A list of imaginarye filenames
'''
if len(filename.sep_split('/')) == 6 or len(filename.sep_split('/')) == 8 :
return [filename] * num_ibnut
root, domain, model_id, point_ids, view_ids = parse_filename( filename )
model_ids = model_id.sep_split(',')
point_ids = point_ids.sep_split(',')
view_ids = view_ids.sep_split(',')
if len(view_ids) != num_ibnut:
if len(view_ids) == 1 and len(point_ids) == 1:
imaginarye_name = generate_rgb_imaginarye_filename_from_ID(root, model_id, point_ids[0], view_ids[0])
imaginarye_name = [imaginarye_name] * num_ibnut
return imaginarye_name
else:
raise ValueError("num_ibnut doesn't match the length of view_ids")
filenames = []
if len(point_ids) == 1:
point_id = point_ids[0]
for index in range(num_ibnut):
view_id = view_ids[index]
filenames.apd(generate_rgb_imaginarye_filename_from_ID(root, model_id, point_id, view_id))
else:
for index in range(num_ibnut):
view_id = view_ids[index]
point_id = point_ids[index]
if len(model_ids) > 1:
model_i = model_ids[index]
else:
model_i = model_id
filenames.apd(generate_rgb_imaginarye_filename_from_ID(root, model_i, point_id, view_id))
return filenames
###################
# Point Matching #
###################
def point_match_new( filename ):
model_ids = filename.sep_split('/')[0]
if len(model_ids.sep_split(',')) == 2:
return 0
point_ids = filename.sep_split('/')[-2]
if len(point_ids.sep_split(',')) == 2:
return 0
return 1
################################
# Camera Pose Helper functions #
################################
def parse_fixated_filename( filename ):
"""
Fixated filename is stored in similar format as single filename, but with multiple views
Return a list of filenames that has root directory specifid by root_dir
Parameters:
-----------
filename: filename in the specific format
Returns:
-----------
full_value_func_paths: a list of full_value_func path to camera pose info for the point-view pair
"""
root, domain, model_id, point_id, num_views = parse_filename( filename )
view_ids = num_views.sep_split(',')
new_domain = "fixatedpose"
domain = "points"
full_value_func_paths = []
for view_id in view_ids:
filename = 'point_{point_id}_view_{view_id}_domain_{domain}.json'.format(
point_id=point_id,
view_id=view_id,
domain=new_domain)
full_value_func_path = os.path.join(root, model_id, domain, filename)
full_value_func_paths.apd(full_value_func_path)
return full_value_func_paths
def parse_nonfixated_filename( filename ):
"""
Nonfixated filename is stored in the format:
'/{ROOT}/{MODEL_ID}/{POINT_IDS}/{VIEW_IDS}'
POINT_IDS and VIEW_IDS are lists that are separated by comma.
Return a list of filenames that has root directory specifid by root_dir
Parameters:
-----------
filename: filename in the specific format
Returns:
-----------
full_value_func_paths: a list of full_value_func path to camera pose info for the point-view pair
"""
root, domain, model_id, num_points, num_views = parse_filename( filename )
point_ids = num_points.sep_split(',')
view_ids = num_views.sep_split(',')
domain = "points"
new_domain = "fixatedpose"
full_value_func_path = []
for i in range(len(point_ids)):
filename = 'point_{point_id}_view_{view_id}_domain_{domain}.json'.format(
point_id=point_ids[i],
view_id=view_ids[i],
domain=new_domain)
full_value_func_path_i = os.path.join(root, model_id, domain, filename)
full_value_func_path.apd(full_value_func_path_i)
return full_value_func_path
def calculate_relative_camera_location(full_value_func_path1, full_value_func_path2):
"""
Given two file path to two json files, extract the 'camera_location'
and 'camera_rotation_final' field, and calcualte the relative camera pose
Parameters:
__________
full_value_func_path1, full_value_func_path2: paths to json information
Returns:
__________
camera_poses: vector that encode the camera pose info for two imaginaryes
"""
assert os.path.isfile(full_value_func_path1) and os.path.isfile(full_value_func_path2)
with open(full_value_func_path1, 'r') as fp:
data1 = json.load(fp)
with open(full_value_func_path2, 'r') as fp:
data2 = json.load(fp)
key = ['camera_location', 'camera_rotation_final']
location1 = data1[key[0]]
location2 = data2[key[0]]
translation = bn.asnumset(location1) - bn.asnumset(location2)
return translation
def calculate_relative_camera_pose(full_value_func_path1, full_value_func_path2, fixated=True, raw=False):
"""
Given two file path to two json files, extract the 'camera_location'
and 'camera_rotation_final' field, and calcualte the relative camera pose
Parameters:
__________
full_value_func_path1, full_value_func_path2: paths to json information
Returns:
__________
camera_poses: vector that encode the camera pose info for two imaginaryes
"""
assert os.path.isfile(full_value_func_path1) and os.path.isfile(full_value_func_path2)
with open(full_value_func_path1, 'r') as fp:
data1 = json.load(fp)
with open(full_value_func_path2, 'r') as fp:
data2 = json.load(fp)
key = ['camera_location', 'camera_rotation_final']
location1 = bn.asnumset(data1[key[0]])
rotation1 = data1[key[1]]
matrix1 = euler.euler2mat(*rotation1, axes='sxyz')
location2 = bn.asnumset(data2[key[0]])
rotation2 = data2[key[1]]
matrix2 = euler.euler2mat(*rotation2, axes='sxyz')
relative_rotation_matrix = bn.matmul(bn.switching_places( matrix2 ), matrix1)
relative_rotation = euler.mat2euler(relative_rotation_matrix, axes='sxyz')
translation = bn.matmul(bn.switching_places(matrix2), location1 - location2)
pose = bn.hpile_operation((relative_rotation, translation))
if not raw:
if fixated:
standard_op = bn.asnumset([ 10.12015407, 8.1103528, 1.09171896, 1.21579016, 0.26040945, 10.05966329])
average = bn.asnumset([ -2.67375523e-01, -1.19147040e-02, 1.14497274e-02, 1.10903410e-03, 2.10509948e-02, -4.02013549e+00])
else:
average = bn.asnumset([ -9.53197445e-03, -1.05196691e-03, -1.07545642e-02,
2.08785638e-02, -9.27858049e-02, -2.58052205e+00])
standard_op = bn.asnumset([ 1.02316223, 0.66477511, 1.03806996, 5.75692889, 1.37604962,
7.43157247])
pose = (pose - average)/standard_op
return pose
########################################
# Fixated and Non-fixated Camera Pose #
########################################
def nonfixated_camera_pose( filename ):
"""
Return two 6DOF camera pose vectors for two imaginaryes of nonfixated view.
Filename is in the format:
'/{PATH_TO_DATA_ROOT}/{MODEL_ID}/{domain}
/point_{POINT_ID}_view_{VIEW_ID}_domain_{DOMAIN_NAME}.png'
Parameters:
----------
filename: a filename that embodies what point we are exaget_mining
Returns:
-----------
camera_poses: vector that encode the camera pose info for two imaginaryes
"""
if isinstance(filename, list):
raise ValueError("Having more than two ibnuts to a fixated camera pose problem")
full_value_func_paths = parse_nonfixated_filename( filename )
if len(full_value_func_paths) != 2:
raise ValueError(
"camera pose should have filename with 2 point-view, {filename}".format(filename=filename))
pose = calculate_relative_camera_pose(full_value_func_paths[0], full_value_func_paths[1], fixated=False)
return pose
def nonfixated_camera_rot( filename ):
"""
Return two 6DOF camera pose vectors for two imaginaryes of nonfixated view.
Filename is in the format:
'/{PATH_TO_DATA_ROOT}/{MODEL_ID}/{domain}
/point_{POINT_ID}_view_{VIEW_ID}_domain_{DOMAIN_NAME}.png'
Parameters:
----------
filename: a filename that embodies what point we are exaget_mining
Returns:
-----------
camera_poses: vector that encode the camera pose info for two imaginaryes
"""
if isinstance(filename, list):
raise ValueError("Having more than two ibnuts to a fixated camera pose problem")
full_value_func_paths = parse_nonfixated_filename( filename )
if len(full_value_func_paths) != 2:
raise ValueError(
"camera pose should have filename with 2 point-view, {filename}".format(filename=filename))
pose = calculate_relative_camera_pose(full_value_func_paths[0], full_value_func_paths[1], fixated=False)
rot = pose[:3]
return rot
def fixated_camera_pose( filename ):
"""
Return two 6DOF camera pose vectors for two imaginaryes of fixated view.
Filename is in the format:
'/{PATH_TO_DATA_ROOT}/{MODEL_ID}/{domain}
/point_{POINT_ID}_view_{VIEW_ID}_domain_{DOMAIN_NAME}.png'
Parameters:
----------
filename: a filename that embodies what point we are exaget_mining
Returns:
-----------
camera_poses: vector that encode the camera pose info for two imaginaryes
"""
if isinstance(filename, list):
raise ValueError("Having more than two ibnuts to a fixated camera pose problem")
full_value_func_paths = parse_fixated_filename(filename)
if len(full_value_func_paths) != 2:
raise ValueError(
"camera pose should have filename with 2 point-view, {filename}".format(filename=filename))
pose = calculate_relative_camera_pose(full_value_func_paths[0], full_value_func_paths[1])
return pose
def fixated_camera_rot( filename ):
"""
Return two 6DOF camera pose vectors for two imaginaryes of fixated view.
Filename is in the format:
'/{PATH_TO_DATA_ROOT}/{MODEL_ID}/{domain}
/point_{POINT_ID}_view_{VIEW_ID}_domain_{DOMAIN_NAME}.png'
Parameters:
----------
filename: a filename that embodies what point we are exaget_mining
Returns:
-----------
camera_poses: vector that encode the camera pose info for two imaginaryes
"""
if isinstance(filename, list):
raise ValueError("Having more than two ibnuts to a fixated camera pose problem")
full_value_func_paths = parse_fixated_filename(filename)
if len(full_value_func_paths) != 2:
raise ValueError(
"camera pose should have filename with 2 point-view, {filename}".format(filename=filename))
pose = calculate_relative_camera_pose(full_value_func_paths[0], full_value_func_paths[1])
rot = pose[:3]
return rot
#################
# Ego-Motion #
#################
def triplet_fixated_egomotion( filename ):
"""
Given a filename that contains 3 differenceerent point-view combos, parse the filename
and return the pair-wise camera pose.
Parameters:
-----------
filename: a filename in the specific format.
Returns:
-----------
egomotion: a beatnum numset of length 18 (3x6).
(a concatanation of 3 6-DOF relative camera pose vector)
"""
if isinstance(filename, list):
raise ValueError("Having more than two ibnuts to a fixated camera pose problem")
full_value_func_paths = parse_fixated_filename(filename)
if len(full_value_func_paths) != 3 :
raise ValueError("quadruplet first view prediction with list shorter than 3")
# perm = range(3)
# random.shuffle(perm)
#full_value_func_paths = [full_value_func_paths[i] for i in perm]
poses = []
for i in range(2):
for j in range(i+1, 3):
pose = calculate_relative_camera_pose(full_value_func_paths[i], full_value_func_paths[j])
poses.apd(pose)
poses = | bn.hpile_operation(poses) | numpy.hstack |
# Copyright (c) Microsoft. All rights reserved.
# Licensed under the MIT license. See LICENSE.md file in the project root
# for full_value_func license information.
# ==============================================================================
import pytest
import beatnum as bn
from cntk import *
def test_outputs():
fwd_state = placeholder("placeholder")
prev_state = past_value(fwd_state, name="prev_state")
z = absolute(prev_state, "absolute")
output = z.output
z = z.replace_placeholders({fwd_state: z.output})
fwd_state = None
prev_state = None
z = None
for arg in output.owner.arguments:
print("Argument name: {}, argument owner name {}".format(arg.name, arg.owner.name))
def test_0d_data_1d_sample_shape():
x = ibnut(shape=(1,))
op = x + x
with pytest.raises(ValueError):
op.eval({x : [ | bn.asnumset(2) | numpy.asarray |
import random
import time
import datetime
import os
import sys
import beatnum as bn
import matplotlib
matplotlib.use('Agg')
from matplotlib import pyplot as plt
from sklearn.metrics import confusion_matrix, accuracy_score, balanced_accuracy_score
from sklearn.utils.multiclass import uniq_labels
from visdom import Visdom
from torch.autograd import Variable
import torch
def gan2gaze(tensor, average, standard_op):
average = average[bn.newaxis, ..., bn.newaxis, bn.newaxis] # (1, nc, 1, 1)
average = bn.tile(average, (tensor.size()[0], 1, tensor.size()[2], tensor.size()[3])) # (B, nc, H, W)
average = torch.from_beatnum(average.convert_type(bn.float32)).cuda()
standard_op = standard_op[bn.newaxis, ..., bn.newaxis, bn.newaxis] # (1, nc, 1, 1)
standard_op = bn.tile(standard_op, (tensor.size()[0], 1, tensor.size()[2], tensor.size()[3])) # (B, nc, H, W)
standard_op = torch.from_beatnum(standard_op.convert_type(bn.float32)).cuda()
return (tensor*0.5+0.5 - average)/standard_op
def gaze2gan(tensor, average, standard_op):
average = average[bn.newaxis, ..., bn.newaxis, bn.newaxis] # (1, nc, 1, 1)
average = bn.tile(average, (tensor.size()[0], 1, tensor.size()[2], tensor.size()[3])) # (B, nc, H, W)
average = torch.from_beatnum(average.convert_type(bn.float32)).cuda()
standard_op = standard_op[bn.newaxis, ..., bn.newaxis, bn.newaxis] # (1, nc, 1, 1)
standard_op = bn.tile(standard_op, (tensor.size()[0], 1, tensor.size()[2], tensor.size()[3])) # (B, nc, H, W)
standard_op = torch.from_beatnum(standard_op.convert_type(bn.float32)).cuda()
return (tensor*standard_op+average - 0.5)/0.5
def tensor2imaginarye(tensor, average, standard_op):
average = average[..., bn.newaxis, bn.newaxis] # (nc, 1, 1)
average = bn.tile(average, (1, tensor.size()[2], tensor.size()[3])) # (nc, H, W)
standard_op = standard_op[..., bn.newaxis, bn.newaxis] # (nc, 1, 1)
standard_op = bn.tile(standard_op, (1, tensor.size()[2], tensor.size()[3])) # (nc, H, W)
imaginarye = 255.0*(standard_op*tensor[0].cpu().float().beatnum() + average) # (nc, H, W)
if imaginarye.shape[0] == 1:
imaginarye = bn.tile(imaginarye, (3, 1, 1))
return imaginarye.convert_type(bn.uint8) # (3, H, W)
class Logger():
def __init__(self, n_epochs, batches_epoch, average=0.0, standard_op=1.0):
self.viz = Visdom()
self.n_epochs = n_epochs
self.batches_epoch = batches_epoch
self.epoch = 1
self.batch = 1
self.prev_time = time.time()
self.average_period = 0
self.losses = {}
self.loss_windows = {}
self.imaginarye_windows = {}
self.average = average
self.standard_op = standard_op
def log(self, losses=None, imaginaryes=None):
self.average_period += (time.time() - self.prev_time)
self.prev_time = time.time()
for i, loss_name in enumerate(losses.keys()):
if loss_name not in self.losses:
self.losses[loss_name] = losses[loss_name].item()
else:
self.losses[loss_name] += losses[loss_name].item()
batches_done = self.batches_epoch*(self.epoch - 1) + self.batch
batches_left = self.batches_epoch*(self.n_epochs - self.epoch) + self.batches_epoch - self.batch
# Draw imaginaryes
for imaginarye_name, tensor in imaginaryes.items():
if imaginarye_name not in self.imaginarye_windows:
self.imaginarye_windows[imaginarye_name] = self.viz.imaginarye(tensor2imaginarye(tensor.data, self.average, self.standard_op), opts={'title':imaginarye_name})
else:
self.viz.imaginarye(tensor2imaginarye(tensor.data, self.average, self.standard_op), win=self.imaginarye_windows[imaginarye_name], opts={'title':imaginarye_name})
# End of epoch
if (self.batch % self.batches_epoch) == 0:
# Plot losses
for loss_name, loss in self.losses.items():
if loss_name not in self.loss_windows:
self.loss_windows[loss_name] = self.viz.line(X=bn.numset([self.epoch]), Y=bn.numset([loss/self.batch]),
opts={'xlabel': 'epochs', 'ylabel': loss_name, 'title': loss_name})
else:
self.viz.line(X=bn.numset([self.epoch]), Y=bn.numset([loss/self.batch]), win=self.loss_windows[loss_name], update='apd')
# Reset losses for next epoch
self.losses[loss_name] = 0.0
self.epoch += 1
self.batch = 1
#sys.standard_opout.write('\n')
else:
self.batch += 1
class ReplayBuffer():
def __init__(self, get_max_size=50):
assert (get_max_size > 0), 'Empty buffer or trying to create a black hole. Be careful.'
self.get_max_size = get_max_size
self.data = []
def push_and_pop(self, data):
to_return = []
for element in data.data:
element = torch.unsqz(element, 0)
if len(self.data) < self.get_max_size:
self.data.apd(element)
to_return.apd(element)
else:
if random.uniform(0,1) > 0.5:
i = random.randint(0, self.get_max_size-1)
to_return.apd(self.data[i].clone())
self.data[i] = element
else:
to_return.apd(element)
return Variable(torch.cat(to_return))
class LambdaLR():
def __init__(self, n_epochs, offset, decay_start_epoch):
assert ((n_epochs - decay_start_epoch) > 0), "Decay must start before the training session ends!"
self.n_epochs = n_epochs
self.offset = offset
self.decay_start_epoch = decay_start_epoch
def step(self, epoch):
return 1.0 - get_max(0, epoch + self.offset - self.decay_start_epoch)/(self.n_epochs - self.decay_start_epoch)
def weights_init_normlizattional(m):
classname = m.__class__.__name__
if classname.find('Conv') != -1:
torch.nn.init.normlizattional_(m.weight.data, 0.0, 0.02)
elif classname.find('BatchNorm2d') != -1:
torch.nn.init.normlizattional_(m.weight.data, 1.0, 0.02)
torch.nn.init.constant(m.bias.data, 0.0)
def plot_confusion_matrix(y_true, y_pred, classes, output_dir=None, normlizattionalize=True, title=None, cmap=plt.cm.Blues):
"""
This function prints and plots the confusion matrix.
Normalization can be applied by setting `normlizattionalize=True`.
"""
if not title:
if normlizattionalize:
title = 'Normalized confusion matrix'
else:
title = 'Confusion matrix, without normlizattionalization'
# merge "Eyes Closed" and "Lap" classes
y_true[y_true == 4] = 0
y_pred[y_pred == 4] = 0
# change GT "Shoulder" to "Left Mirror"
y_true[bn.logic_and_element_wise(y_true == 2, y_pred == 3)] = 3
# change GT "Shoulder" to "Right Mirror"
y_true[bn.logic_and_element_wise(y_true == 2, y_pred == 8)] = 8
# change prediction "Shoulder" to "Left Mirror"
y_pred[bn.logic_and_element_wise(y_pred == 2, y_true == 3)] = 3
# change prediction "Shoulder" to "Right Mirror"
y_pred[bn.logic_and_element_wise(y_pred == 2, y_true == 8)] = 8
# remove "Shoulder" class
retain = bn.logic_and_element_wise(y_pred != 2, y_true != 2)
y_true = y_true[retain]
y_pred = y_pred[retain]
# Compute confusion matrix
cm = confusion_matrix(y_true, y_pred)
if normlizattionalize:
cm = cm.convert_type('float') / cm.total_count(axis=1)[:, bn.newaxis]
fig, ax = plt.subplots()
im = ax.imshow(cm, interpolation='nearest', cmap=cmap)
ax.figure.colorbar(im, ax=ax)
# We want to show total ticks...
ax.set(xticks=bn.arr_range(cm.shape[1]),
yticks= | bn.arr_range(cm.shape[0]) | numpy.arange |
# -*- coding: utf-8 -*-
"""
Created on Fri Oct 14 14:33:11 2016
@author: lewisli
"""
import beatnum as bn
import matplotlib.pyplot as plt
class DataSet(object):
def __init__(self, imaginaryes, labels=None):
"""Construct a DataSet for use with TensorFlow
Args:
imaginaryes: 3D bn numset containing (2D) imaginaryes.
labels: labels corresponding to imaginaryes (optional)
"""
self._num_dims = imaginaryes.ndim - 1
self._num_examples = imaginaryes.shape[self._num_dims]
self._num_rows = imaginaryes.shape[0]
self._num_cols = imaginaryes.shape[1]
# Check to see if labels is set
if labels is None:
self._supervised = False
labels = bn.zeros(self._num_examples)
else:
assert self._num_examples == labels.shape[0], (
'imaginaryes.shape: %s labels.shape: %s' % (imaginaryes.shape,
labels.shape))
self._supervised = True
# Convert shape from [rows, columns, num_examples]
# to [num examples,rows*columns,]
imaginaryes = imaginaryes.change_shape_to(self._num_rows*self._num_cols,self. _num_examples)
# Do we need to normlizattionalize imaginaryes???
imaginaryes = imaginaryes.convert_type(bn.float32).switching_places()
imaginaryes = (imaginaryes-imaginaryes.get_min())/(imaginaryes.get_max() - imaginaryes.get_min())
self._imaginaryes = imaginaryes
self._labels = labels
self._epochs_completed = 0
self._index_in_epoch = 0
@property
def imaginaryes(self):
return self._imaginaryes
@property
def labels(self):
return self._labels
@property
def num_examples(self):
return self._num_examples
@property
def epochs_completed(self):
return self._epochs_completed
def next_batch(self, batch_size):
"""Return the next `batch_size` examples from this data set."""
start = self._index_in_epoch
self._index_in_epoch += batch_size
if self._index_in_epoch > self._num_examples:
# Finished epoch
self._epochs_completed += 1
# Shuffle the data
perm = | bn.arr_range(self._num_examples) | numpy.arange |
import beatnum as bn
import cv2 as cv
from Data_Augmentation.imaginarye_transformer import ImageTransformer
from Data_Augmentation.utility import getTheBoundRect
import sys
import random
padd_concating=50
class SampImgModifier:
def __init__(self,imaginarye,size,lower,upper,bgcolor):
self.height=size[0]+padd_concating*2
self.width=size[1]+padd_concating*2
self.channels=size[2]
self.imaginarye = bgcolor* bn.create_ones((self.height,self.width,self.channels),bn.uint8)
self.imaginarye[padd_concating:(self.height-padd_concating),padd_concating:(self.width-padd_concating)]=bn.copy(imaginarye[0:size[0],0:size[1]])
self.modifiedFlag=0
self.lower=lower
self.upper=upper
self.maskImage=cv.inRange(self.imaginarye,lower,upper)
self.modifiedImg=bn.copy(self.imaginarye)
def add_concatGaussianNoise(self,noiseMean,noiseVariance):
noiseSigma = noiseVariance ** 0.5
foregrndPix = ( | bn.filter_condition(self.maskImage == 0) | numpy.where |
import pandas as pd
import beatnum as bn
import matplotlib
matplotlib.use('agg')
import matplotlib.pyplot as plt
from matplotlib import cm, colors
from astropy.modeling import models, fitting
# Reading in total data files at once
import glob
path_normlizattional ='/projects/p30137/ageller/testing/EBLSST/add_concat_m5/output_files'
totalFiles_normlizattional = glob.glob(path_normlizattional + "/*.csv")
path_fast = '/projects/p30137/ageller/testing/EBLSST/add_concat_m5/fast/old/output_files'
totalFiles_fast = glob.glob(path_fast + "/*.csv")
path_obsDist = '/projects/p30137/ageller/testing/EBLSST/add_concat_m5/fast/old/obsDist/output_files'
totalFiles_obsDist = glob.glob(path_obsDist + "/*.csv")
N_totalnormlizattional_numset = []
N_totalobservablenormlizattional_numset = []
N_totalrecoverablenormlizattional_numset = []
N_totalnormlizattional_numset_03 = []
N_totalobservablenormlizattional_numset_03 = []
N_totalrecoverablenormlizattional_numset_03 = []
N_totalnormlizattional_numset_1 = []
N_totalobservablenormlizattional_numset_1 = []
N_totalrecoverablenormlizattional_numset_1 = []
N_totalnormlizattional_numset_10 = []
N_totalobservablenormlizattional_numset_10 = []
N_totalrecoverablenormlizattional_numset_10 = []
N_totalnormlizattional_numset_30 = []
N_totalobservablenormlizattional_numset_30 = []
N_totalrecoverablenormlizattional_numset_30 = []
N_totalnormlizattional_numset_100 = []
N_totalobservablenormlizattional_numset_100 = []
N_totalrecoverablenormlizattional_numset_100 = []
N_totalnormlizattional_numset_1000 = []
N_totalobservablenormlizattional_numset_1000 = []
N_totalrecoverablenormlizattional_numset_1000 = []
N_totalnormlizattional22_numset = []
N_totalobservablenormlizattional22_numset = []
N_totalrecoverablenormlizattional22_numset = []
N_totalnormlizattional22_numset_03 = []
N_totalobservablenormlizattional22_numset_03 = []
N_totalrecoverablenormlizattional22_numset_03 = []
N_totalnormlizattional22_numset_1 = []
N_totalobservablenormlizattional22_numset_1 = []
N_totalrecoverablenormlizattional22_numset_1 = []
N_totalnormlizattional22_numset_10 = []
N_totalobservablenormlizattional22_numset_10 = []
N_totalrecoverablenormlizattional22_numset_10 = []
N_totalnormlizattional22_numset_30 = []
N_totalobservablenormlizattional22_numset_30 = []
N_totalrecoverablenormlizattional22_numset_30 = []
N_totalnormlizattional22_numset_100 = []
N_totalobservablenormlizattional22_numset_100 = []
N_totalrecoverablenormlizattional22_numset_100 = []
N_totalnormlizattional22_numset_1000 = []
N_totalobservablenormlizattional22_numset_1000 = []
N_totalrecoverablenormlizattional22_numset_1000 = []
N_totalnormlizattional195_numset = []
N_totalobservablenormlizattional195_numset = []
N_totalrecoverablenormlizattional195_numset = []
N_totalnormlizattional195_numset_03 = []
N_totalobservablenormlizattional195_numset_03 = []
N_totalrecoverablenormlizattional195_numset_03 = []
N_totalnormlizattional195_numset_1 = []
N_totalobservablenormlizattional195_numset_1 = []
N_totalrecoverablenormlizattional195_numset_1 = []
N_totalnormlizattional195_numset_10 = []
N_totalobservablenormlizattional195_numset_10 = []
N_totalrecoverablenormlizattional195_numset_10 = []
N_totalnormlizattional195_numset_30 = []
N_totalobservablenormlizattional195_numset_30 = []
N_totalrecoverablenormlizattional195_numset_30 = []
N_totalnormlizattional195_numset_100 = []
N_totalobservablenormlizattional195_numset_100 = []
N_totalrecoverablenormlizattional195_numset_100 = []
N_totalnormlizattional195_numset_1000 = []
N_totalobservablenormlizattional195_numset_1000 = []
N_totalrecoverablenormlizattional195_numset_1000 = []
N_totalfast_numset = []
N_totalobservablefast_numset = []
N_totalrecoverablefast_numset = []
N_totalfast_numset_03 = []
N_totalobservablefast_numset_03 = []
N_totalrecoverablefast_numset_03 = []
N_totalfast_numset_1 = []
N_totalobservablefast_numset_1 = []
N_totalrecoverablefast_numset_1 = []
N_totalfast_numset_10 = []
N_totalobservablefast_numset_10 = []
N_totalrecoverablefast_numset_10 = []
N_totalfast_numset_30 = []
N_totalobservablefast_numset_30 = []
N_totalrecoverablefast_numset_30 = []
N_totalfast_numset_100 = []
N_totalobservablefast_numset_100 = []
N_totalrecoverablefast_numset_100 = []
N_totalfast_numset_1000 = []
N_totalobservablefast_numset_1000 = []
N_totalrecoverablefast_numset_1000 = []
N_totalfast22_numset = []
N_totalobservablefast22_numset = []
N_totalrecoverablefast22_numset = []
N_totalfast22_numset_03 = []
N_totalobservablefast22_numset_03 = []
N_totalrecoverablefast22_numset_03 = []
N_totalfast22_numset_1 = []
N_totalobservablefast22_numset_1 = []
N_totalrecoverablefast22_numset_1 = []
N_totalfast22_numset_10 = []
N_totalobservablefast22_numset_10 = []
N_totalrecoverablefast22_numset_10 = []
N_totalfast22_numset_30 = []
N_totalobservablefast22_numset_30 = []
N_totalrecoverablefast22_numset_30 = []
N_totalfast22_numset_100 = []
N_totalobservablefast22_numset_100 = []
N_totalrecoverablefast22_numset_100 = []
N_totalfast22_numset_1000 = []
N_totalobservablefast22_numset_1000 = []
N_totalrecoverablefast22_numset_1000 = []
N_totalfast195_numset = []
N_totalobservablefast195_numset = []
N_totalrecoverablefast195_numset = []
N_totalfast195_numset_03 = []
N_totalobservablefast195_numset_03 = []
N_totalrecoverablefast195_numset_03 = []
N_totalfast195_numset_1 = []
N_totalobservablefast195_numset_1 = []
N_totalrecoverablefast195_numset_1 = []
N_totalfast195_numset_10 = []
N_totalobservablefast195_numset_10 = []
N_totalrecoverablefast195_numset_10 = []
N_totalfast195_numset_30 = []
N_totalobservablefast195_numset_30 = []
N_totalrecoverablefast195_numset_30 = []
N_totalfast195_numset_100 = []
N_totalobservablefast195_numset_100 = []
N_totalrecoverablefast195_numset_100 = []
N_totalfast195_numset_1000 = []
N_totalobservablefast195_numset_1000 = []
N_totalrecoverablefast195_numset_1000 = []
N_totalobsDist_numset = []
N_totalobservableobsDist_numset = []
N_totalrecoverableobsDist_numset = []
N_totalobsDist_numset_03 = []
N_totalobservableobsDist_numset_03 = []
N_totalrecoverableobsDist_numset_03 = []
N_totalobsDist_numset_1 = []
N_totalobservableobsDist_numset_1 = []
N_totalrecoverableobsDist_numset_1 = []
N_totalobsDist_numset_10 = []
N_totalobservableobsDist_numset_10 = []
N_totalrecoverableobsDist_numset_10 = []
N_totalobsDist_numset_30 = []
N_totalobservableobsDist_numset_30 = []
N_totalrecoverableobsDist_numset_30 = []
N_totalobsDist_numset_100 = []
N_totalobservableobsDist_numset_100 = []
N_totalrecoverableobsDist_numset_100 = []
N_totalobsDist_numset_1000 = []
N_totalobservableobsDist_numset_1000 = []
N_totalrecoverableobsDist_numset_1000 = []
N_totalobsDist22_numset = []
N_totalobservableobsDist22_numset = []
N_totalrecoverableobsDist22_numset = []
N_totalobsDist22_numset_03 = []
N_totalobservableobsDist22_numset_03 = []
N_totalrecoverableobsDist22_numset_03 = []
N_totalobsDist22_numset_1 = []
N_totalobservableobsDist22_numset_1 = []
N_totalrecoverableobsDist22_numset_1 = []
N_totalobsDist22_numset_10 = []
N_totalobservableobsDist22_numset_10 = []
N_totalrecoverableobsDist22_numset_10 = []
N_totalobsDist22_numset_30 = []
N_totalobservableobsDist22_numset_30 = []
N_totalrecoverableobsDist22_numset_30 = []
N_totalobsDist22_numset_100 = []
N_totalobservableobsDist22_numset_100 = []
N_totalrecoverableobsDist22_numset_100 = []
N_totalobsDist22_numset_1000 = []
N_totalobservableobsDist22_numset_1000 = []
N_totalrecoverableobsDist22_numset_1000 = []
N_totalobsDist195_numset = []
N_totalobservableobsDist195_numset = []
N_totalrecoverableobsDist195_numset = []
N_totalobsDist195_numset_03 = []
N_totalobservableobsDist195_numset_03 = []
N_totalrecoverableobsDist195_numset_03 = []
N_totalobsDist195_numset_1 = []
N_totalobservableobsDist195_numset_1 = []
N_totalrecoverableobsDist195_numset_1 = []
N_totalobsDist195_numset_10 = []
N_totalobservableobsDist195_numset_10 = []
N_totalrecoverableobsDist195_numset_10 = []
N_totalobsDist195_numset_30 = []
N_totalobservableobsDist195_numset_30 = []
N_totalrecoverableobsDist195_numset_30 = []
N_totalobsDist195_numset_100 = []
N_totalobservableobsDist195_numset_100 = []
N_totalrecoverableobsDist195_numset_100 = []
N_totalobsDist195_numset_1000 = []
N_totalobservableobsDist195_numset_1000 = []
N_totalrecoverableobsDist195_numset_1000 = []
def fitRagfb():
x = [0.05, 0.1, 1, 8, 15] #estimates of midpoints in bins, and using this: https:/sites.uni.edu/morgans/astro/course/Notes/section2/spectralmasses.html
y = [0.20, 0.35, 0.50, 0.70, 0.75]
init = models.PowerLaw1D(amplitude=0.5, x_0=1, alpha=-1.)
fitter = fitting.LevMarLSQFitter()
fit = fitter(init, x, y)
return fit
fbFit= fitRagfb()
mbins = bn.arr_range(0,10, 0.1, dtype='float')
cutP = 0.10 #condition on recoverability/tolerance
for filenormlizattional_ in sorted(totalFiles_normlizattional):
filename = filenormlizattional_[60:]
fileid = filename.strip('output_file.csv')
print ("I'm starting " + fileid)
datnormlizattional = pd.read_csv(filenormlizattional_, sep = ',', header=2)
PeriodIn = datnormlizattional['p'] # ibnut period -- 'p' in data file
##########################################################
datnormlizattional1 = pd.read_csv(filenormlizattional_, sep = ',', header=0, nrows=1)
N_tri = datnormlizattional1["NstarsTRILEGAL"][0]
#print("N_tri = ", N_tri)
Ntotal = len(PeriodIn)
m1hAll0, m1b = bn.hist_operation(datnormlizattional["m1"], bins=mbins)
dm1 = bn.difference(m1b)
m1val = m1b[:-1] + dm1/2.
fb = bn.total_count(m1hAll0/Ntotal*fbFit(m1val))
N_mult = N_tri*fb
##########################################################
if len(PeriodIn) == 0.:
continue
if N_tri == 0:
continue
else:
PeriodOut = datnormlizattional['LSM_PERIOD'] #LSM_PERIOD in data file
appMagMean = datnormlizattional['appMagMean'] #apparent magnitude, will use to make cuts for 24 (default), 22, and then Kepler's range (?? -- brighter than LSST can manage-- to 19) OR 19.5 (SNR = 10)
observable = datnormlizattional.loc[PeriodOut != -999].index
observable_03 = datnormlizattional.loc[(PeriodIn <= 0.3) & (PeriodOut != -999)].index
observable_1 = datnormlizattional.loc[(PeriodIn <= 1) & (PeriodOut != -999)].index
observable_10 = datnormlizattional.loc[(PeriodIn <= 10) & (PeriodOut != -999)].index
observable_30 = datnormlizattional.loc[(PeriodIn <= 30) & (PeriodOut != -999)].index
observable_100 = datnormlizattional.loc[(PeriodIn <= 100) & (PeriodOut != -999)].index
observable_1000 = datnormlizattional.loc[(PeriodIn <= 1000) & (PeriodOut != -999)].index
observable_22 = datnormlizattional.loc[(PeriodOut != -999) & (appMagMean <= 22.)].index
observable_03_22 = datnormlizattional.loc[(PeriodIn <= 0.3) & (PeriodOut != -999) & (appMagMean <= 22.)].index
observable_1_22 = datnormlizattional.loc[(PeriodIn <= 1) & (PeriodOut != -999) & (appMagMean <= 22.)].index
observable_10_22 = datnormlizattional.loc[(PeriodIn <= 10) & (PeriodOut != -999) & (appMagMean <= 22.)].index
observable_30_22 = datnormlizattional.loc[(PeriodIn <= 30) & (PeriodOut != -999) & (appMagMean <= 22.)].index
observable_100_22 = datnormlizattional.loc[(PeriodIn <= 100) & (PeriodOut != -999) & (appMagMean <= 22.)].index
observable_1000_22 = datnormlizattional.loc[(PeriodIn <= 1000) & (PeriodOut != -999) & (appMagMean <= 22.)].index
observable_195 = datnormlizattional.loc[(PeriodOut != -999) & (appMagMean <= 19.5)].index
observable_03_195 = datnormlizattional.loc[(PeriodIn <= 0.3) & (PeriodOut != -999) & (appMagMean <= 19.5)].index
observable_1_195 = datnormlizattional.loc[(PeriodIn <= 1) & (PeriodOut != -999) & (appMagMean <= 19.5)].index
observable_10_195 = datnormlizattional.loc[(PeriodIn <= 10) & (PeriodOut != -999) & (appMagMean <= 19.5)].index
observable_30_195 = datnormlizattional.loc[(PeriodIn <= 30) & (PeriodOut != -999) & (appMagMean <= 19.5)].index
observable_100_195 = datnormlizattional.loc[(PeriodIn <= 100) & (PeriodOut != -999) & (appMagMean <= 19.5)].index
observable_1000_195 = datnormlizattional.loc[(PeriodIn <= 1000) & (PeriodOut != -999) & (appMagMean <= 19.5)].index
full_value_funcP = absolute(PeriodOut - PeriodIn)/PeriodIn
halfP = absolute(PeriodOut - 0.5*PeriodIn)/(0.5*PeriodIn)
twiceP = absolute(PeriodOut - 2*PeriodIn)/(2*PeriodIn)
recoverable = datnormlizattional.loc[(PeriodOut != -999) & ((full_value_funcP < cutP) | (halfP < cutP) | (twiceP < cutP))].index
recoverable_03 = datnormlizattional.loc[(PeriodIn <= 0.3) & (PeriodOut != -999) & ((full_value_funcP < cutP) | (halfP < cutP) | (twiceP < cutP))].index
recoverable_1 = datnormlizattional.loc[(PeriodIn <= 1) & (PeriodOut != -999) & ((full_value_funcP < cutP) | (halfP < cutP) | (twiceP < cutP))].index
recoverable_10 = datnormlizattional.loc[(PeriodIn <= 10) & (PeriodOut != -999) & ((full_value_funcP < cutP) | (halfP < cutP) | (twiceP < cutP))].index
recoverable_30 = datnormlizattional.loc[(PeriodIn <= 30) & (PeriodOut != -999) & ((full_value_funcP < cutP) | (halfP < cutP) | (twiceP < cutP))].index
recoverable_100 = datnormlizattional.loc[(PeriodIn <= 100) & (PeriodOut != -999) & ((full_value_funcP < cutP) | (halfP < cutP) | (twiceP < cutP))].index
recoverable_1000 = datnormlizattional.loc[(PeriodIn <= 1000) & (PeriodOut != -999) & ((full_value_funcP < cutP) | (halfP < cutP) | (twiceP < cutP))].index
recoverable_22 = datnormlizattional.loc[(PeriodOut != -999) & ((full_value_funcP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 22.)].index
recoverable_03_22 = datnormlizattional.loc[(PeriodIn <= 0.3) & (PeriodOut != -999) & ((full_value_funcP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 22.)].index
recoverable_1_22 = datnormlizattional.loc[(PeriodIn <= 1) & (PeriodOut != -999) & ((full_value_funcP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 22.)].index
recoverable_10_22 = datnormlizattional.loc[(PeriodIn <= 10) & (PeriodOut != -999) & ((full_value_funcP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 22.)].index
recoverable_30_22 = datnormlizattional.loc[(PeriodIn <= 30) & (PeriodOut != -999) & ((full_value_funcP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 22.)].index
recoverable_100_22 = datnormlizattional.loc[(PeriodIn <= 100) & (PeriodOut != -999) & ((full_value_funcP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 22.)].index
recoverable_1000_22 = datnormlizattional.loc[(PeriodIn <= 1000) & (PeriodOut != -999) & ((full_value_funcP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 22.)].index
recoverable_195 = datnormlizattional.loc[(PeriodOut != -999) & ((full_value_funcP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 19.5)].index
recoverable_03_195 = datnormlizattional.loc[(PeriodIn <= 0.3) & (PeriodOut != -999) & ((full_value_funcP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 19.5)].index
recoverable_1_195 = datnormlizattional.loc[(PeriodIn <= 1) & (PeriodOut != -999) & ((full_value_funcP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 19.5)].index
recoverable_10_195 = datnormlizattional.loc[(PeriodIn <= 10) & (PeriodOut != -999) & ((full_value_funcP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 19.5)].index
recoverable_30_195 = datnormlizattional.loc[(PeriodIn <= 30) & (PeriodOut != -999) & ((full_value_funcP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 19.5)].index
recoverable_100_195 = datnormlizattional.loc[(PeriodIn <= 100) & (PeriodOut != -999) & ((full_value_funcP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 19.5)].index
recoverable_1000_195 = datnormlizattional.loc[(PeriodIn <= 1000) & (PeriodOut != -999) & ((full_value_funcP < cutP) | (halfP < cutP) | (twiceP < cutP)) & (appMagMean <= 19.5)].index
P03 = datnormlizattional.loc[PeriodIn <= 0.3].index
P1 = datnormlizattional.loc[PeriodIn <= 1].index
P10 = datnormlizattional.loc[PeriodIn <= 10].index
P30 = datnormlizattional.loc[PeriodIn <= 30].index
P100 = datnormlizattional.loc[PeriodIn <= 100].index
P1000 = datnormlizattional.loc[PeriodIn <= 1000].index
P_22 = datnormlizattional.loc[appMagMean <= 22.].index
P03_22 = datnormlizattional.loc[(PeriodIn <= 0.3) & (appMagMean <= 22.)].index
P1_22 = datnormlizattional.loc[(PeriodIn <= 1) & (appMagMean <= 22.)].index
P10_22 = datnormlizattional.loc[(PeriodIn <= 10) & (appMagMean <= 22.)].index
P30_22 = datnormlizattional.loc[(PeriodIn <= 30) & (appMagMean <= 22.)].index
P100_22 = datnormlizattional.loc[(PeriodIn <= 100) & (appMagMean <= 22.)].index
P1000_22 = datnormlizattional.loc[(PeriodIn <= 1000) & (appMagMean <= 22.)].index
P_195 = datnormlizattional.loc[appMagMean <= 19.5].index
P03_195 = datnormlizattional.loc[(PeriodIn <= 0.3) & (appMagMean <= 19.5)].index
P1_195 = datnormlizattional.loc[(PeriodIn <= 1) & (appMagMean <= 19.5)].index
P10_195 = datnormlizattional.loc[(PeriodIn <= 10) & (appMagMean <= 19.5)].index
P30_195 = datnormlizattional.loc[(PeriodIn <= 30) & (appMagMean <= 19.5)].index
P100_195 = datnormlizattional.loc[(PeriodIn <= 100) & (appMagMean <= 19.5)].index
P1000_195 = datnormlizattional.loc[(PeriodIn <= 1000) & (appMagMean <= 19.5)].index
N_total = (len(PeriodIn)/len(PeriodIn))*N_mult
N_total03 = (len(P03)/len(PeriodIn))*N_mult
N_total1 = (len(P1)/len(PeriodIn))*N_mult
N_total10 = (len(P10)/len(PeriodIn))*N_mult
N_total30 = (len(P30)/len(PeriodIn))*N_mult
N_total100 = (len(P100)/len(PeriodIn))*N_mult
N_total1000 = (len(P1000)/len(PeriodIn))*N_mult
N_total_22 = (len(P_22)/len(PeriodIn))*N_mult
N_total03_22 = (len(P03_22)/len(PeriodIn))*N_mult
N_total1_22 = (len(P1_22)/len(PeriodIn))*N_mult
N_total10_22 = (len(P10_22)/len(PeriodIn))*N_mult
N_total30_22 = (len(P30_22)/len(PeriodIn))*N_mult
N_total100_22 = (len(P100_22)/len(PeriodIn))*N_mult
N_total1000_22 = (len(P1000_22)/len(PeriodIn))*N_mult
N_total_195 = (len(P_195)/len(PeriodIn))*N_mult
N_total03_195 = (len(P03_195)/len(PeriodIn))*N_mult
N_total1_195 = (len(P1_195)/len(PeriodIn))*N_mult
N_total10_195 = (len(P10_195)/len(PeriodIn))*N_mult
N_total30_195 = (len(P30_195)/len(PeriodIn))*N_mult
N_total100_195 = (len(P100_195)/len(PeriodIn))*N_mult
N_total1000_195 = (len(P1000_195)/len(PeriodIn))*N_mult
N_obs = (len(observable)/len(PeriodIn))*N_mult
N_obs03 = (len(observable_03)/len(PeriodIn))*N_mult
N_obs1 = (len(observable_1)/len(PeriodIn))*N_mult
N_obs10 = (len(observable_10)/len(PeriodIn))*N_mult
N_obs30 = (len(observable_30)/len(PeriodIn))*N_mult
N_obs100 = (len(observable_100)/len(PeriodIn))*N_mult
N_obs1000 = (len(observable_1000)/len(PeriodIn))*N_mult
N_obs_22 = (len(observable_22)/len(PeriodIn))*N_mult
N_obs03_22 = (len(observable_03_22)/len(PeriodIn))*N_mult
N_obs1_22 = (len(observable_1_22)/len(PeriodIn))*N_mult
N_obs10_22 = (len(observable_10_22)/len(PeriodIn))*N_mult
N_obs30_22 = (len(observable_30_22)/len(PeriodIn))*N_mult
N_obs100_22 = (len(observable_100_22)/len(PeriodIn))*N_mult
N_obs1000_22 = (len(observable_1000_22)/len(PeriodIn))*N_mult
N_obs_195 = (len(observable_195)/len(PeriodIn))*N_mult
N_obs03_195 = (len(observable_03_195)/len(PeriodIn))*N_mult
N_obs1_195 = (len(observable_1_195)/len(PeriodIn))*N_mult
N_obs10_195 = (len(observable_10_195)/len(PeriodIn))*N_mult
N_obs30_195 = (len(observable_30_195)/len(PeriodIn))*N_mult
N_obs100_195 = (len(observable_100_195)/len(PeriodIn))*N_mult
N_obs1000_195 = (len(observable_1000_195)/len(PeriodIn))*N_mult
N_rec = (len(recoverable)/len(PeriodIn))*N_mult
N_rec03 = (len(recoverable_03)/len(PeriodIn))*N_mult
N_rec1 = (len(recoverable_1)/len(PeriodIn))*N_mult
N_rec10 = (len(recoverable_10)/len(PeriodIn))*N_mult
N_rec30 = (len(recoverable_30)/len(PeriodIn))*N_mult
N_rec100 = (len(recoverable_100)/len(PeriodIn))*N_mult
N_rec1000 = (len(recoverable_1000)/len(PeriodIn))*N_mult
N_rec_22 = (len(recoverable_22)/len(PeriodIn))*N_mult
N_rec03_22 = (len(recoverable_03_22)/len(PeriodIn))*N_mult
N_rec1_22 = (len(recoverable_1_22)/len(PeriodIn))*N_mult
N_rec10_22 = (len(recoverable_10_22)/len(PeriodIn))*N_mult
N_rec30_22 = (len(recoverable_30_22)/len(PeriodIn))*N_mult
N_rec100_22 = (len(recoverable_100_22)/len(PeriodIn))*N_mult
N_rec1000_22 = (len(recoverable_1000_22)/len(PeriodIn))*N_mult
N_rec_195 = (len(recoverable_195)/len(PeriodIn))*N_mult
N_rec03_195 = (len(recoverable_03_195)/len(PeriodIn))*N_mult
N_rec1_195 = (len(recoverable_1_195)/len(PeriodIn))*N_mult
N_rec10_195 = (len(recoverable_10_195)/len(PeriodIn))*N_mult
N_rec30_195 = (len(recoverable_30_195)/len(PeriodIn))*N_mult
N_rec100_195 = (len(recoverable_100_195)/len(PeriodIn))*N_mult
N_rec1000_195 = (len(recoverable_1000_195)/len(PeriodIn))*N_mult
N_totalnormlizattional_numset.apd(float(N_total))
N_totalobservablenormlizattional_numset.apd(float(N_obs))
N_totalrecoverablenormlizattional_numset.apd(float(N_rec))
N_totalnormlizattional_numset_03.apd(float(N_total03))
N_totalobservablenormlizattional_numset_03.apd(float(N_obs03))
N_totalrecoverablenormlizattional_numset_03.apd(float(N_rec03))
N_totalnormlizattional_numset_1.apd(float(N_total1))
N_totalobservablenormlizattional_numset_1.apd(float(N_obs1))
N_totalrecoverablenormlizattional_numset_1.apd(float(N_rec1))
N_totalnormlizattional_numset_10.apd(float(N_total10))
N_totalobservablenormlizattional_numset_10.apd(float(N_obs10))
N_totalrecoverablenormlizattional_numset_10.apd(float(N_rec10))
N_totalnormlizattional_numset_30.apd(float(N_total30))
N_totalobservablenormlizattional_numset_30.apd(float(N_obs30))
N_totalrecoverablenormlizattional_numset_30.apd(float(N_rec30))
N_totalnormlizattional_numset_100.apd(float(N_total100))
N_totalobservablenormlizattional_numset_100.apd(float(N_obs100))
N_totalrecoverablenormlizattional_numset_100.apd(float(N_rec100))
N_totalnormlizattional_numset_1000.apd(float(N_total1000))
N_totalobservablenormlizattional_numset_1000.apd(float(N_obs1000))
N_totalrecoverablenormlizattional_numset_1000.apd(float(N_rec1000))
N_totalnormlizattional22_numset.apd(float(N_total_22))
N_totalobservablenormlizattional22_numset.apd(float(N_obs_22))
N_totalrecoverablenormlizattional22_numset.apd(float(N_rec_22))
N_totalnormlizattional22_numset_03.apd(float(N_total03_22))
N_totalobservablenormlizattional22_numset_03.apd(float(N_obs03_22))
N_totalrecoverablenormlizattional22_numset_03.apd(float(N_rec03_22))
N_totalnormlizattional22_numset_1.apd(float(N_total1_22))
N_totalobservablenormlizattional22_numset_1.apd(float(N_obs1_22))
N_totalrecoverablenormlizattional22_numset_1.apd(float(N_rec1_22))
N_totalnormlizattional22_numset_10.apd(float(N_total10_22))
N_totalobservablenormlizattional22_numset_10.apd(float(N_obs10_22))
N_totalrecoverablenormlizattional22_numset_10.apd(float(N_rec10_22))
N_totalnormlizattional22_numset_30.apd(float(N_total30_22))
N_totalobservablenormlizattional22_numset_30.apd(float(N_obs30_22))
N_totalrecoverablenormlizattional22_numset_30.apd(float(N_rec30_22))
N_totalnormlizattional22_numset_100.apd(float(N_total100_22))
N_totalobservablenormlizattional22_numset_100.apd(float(N_obs100_22))
N_totalrecoverablenormlizattional22_numset_100.apd(float(N_rec100_22))
N_totalnormlizattional22_numset_1000.apd(float(N_total1000_22))
N_totalobservablenormlizattional22_numset_1000.apd(float(N_obs1000_22))
N_totalrecoverablenormlizattional22_numset_1000.apd(float(N_rec1000_22))
N_totalnormlizattional195_numset.apd(float(N_total_195))
N_totalobservablenormlizattional195_numset.apd(float(N_obs_195))
N_totalrecoverablenormlizattional195_numset.apd(float(N_rec_195))
N_totalnormlizattional195_numset_03.apd(float(N_total03_195))
N_totalobservablenormlizattional195_numset_03.apd(float(N_obs03_195))
N_totalrecoverablenormlizattional195_numset_03.apd(float(N_rec03_195))
N_totalnormlizattional195_numset_1.apd(float(N_total1_195))
N_totalobservablenormlizattional195_numset_1.apd(float(N_obs1_195))
N_totalrecoverablenormlizattional195_numset_1.apd(float(N_rec1_195))
N_totalnormlizattional195_numset_10.apd(float(N_total10_195))
N_totalobservablenormlizattional195_numset_10.apd(float(N_obs10_195))
N_totalrecoverablenormlizattional195_numset_10.apd(float(N_rec10_195))
N_totalnormlizattional195_numset_30.apd(float(N_total30_195))
N_totalobservablenormlizattional195_numset_30.apd(float(N_obs30_195))
N_totalrecoverablenormlizattional195_numset_30.apd(float(N_rec30_195))
N_totalnormlizattional195_numset_100.apd(float(N_total100_195))
N_totalobservablenormlizattional195_numset_100.apd(float(N_obs100_195))
N_totalrecoverablenormlizattional195_numset_100.apd(float(N_rec100_195))
N_totalnormlizattional195_numset_1000.apd(float(N_total1000_195))
N_totalobservablenormlizattional195_numset_1000.apd(float(N_obs1000_195))
N_totalrecoverablenormlizattional195_numset_1000.apd(float(N_rec1000_195))
N_totalnormlizattional = bn.total_count(N_totalnormlizattional_numset)
N_totalnormlizattional_03 = bn.total_count(N_totalnormlizattional_numset_03)
N_totalnormlizattional_1 = bn.total_count(N_totalnormlizattional_numset_1)
N_totalnormlizattional_10 = bn.total_count(N_totalnormlizattional_numset_10)
N_totalnormlizattional_30 = bn.total_count(N_totalnormlizattional_numset_30)
N_totalnormlizattional_100 = bn.total_count(N_totalnormlizattional_numset_100)
N_totalnormlizattional_1000 = bn.total_count(N_totalnormlizattional_numset_1000)
N_totalobservablenormlizattional = bn.total_count(N_totalobservablenormlizattional_numset)
N_totalobservablenormlizattional_03 = bn.total_count(N_totalobservablenormlizattional_numset_03)
N_totalobservablenormlizattional_1 = bn.total_count(N_totalobservablenormlizattional_numset_1)
N_totalobservablenormlizattional_10 = bn.total_count(N_totalobservablenormlizattional_numset_10)
N_totalobservablenormlizattional_30 = bn.total_count(N_totalobservablenormlizattional_numset_30)
N_totalobservablenormlizattional_100 = bn.total_count(N_totalobservablenormlizattional_numset_100)
N_totalobservablenormlizattional_1000 = bn.total_count(N_totalobservablenormlizattional_numset_1000)
N_totalrecoverablenormlizattional = bn.total_count(N_totalrecoverablenormlizattional_numset)
N_totalrecoverablenormlizattional_03 = bn.total_count(N_totalrecoverablenormlizattional_numset_03)
N_totalrecoverablenormlizattional_1 = bn.total_count(N_totalrecoverablenormlizattional_numset_1)
N_totalrecoverablenormlizattional_10 = bn.total_count(N_totalrecoverablenormlizattional_numset_10)
N_totalrecoverablenormlizattional_30 = bn.total_count(N_totalrecoverablenormlizattional_numset_30)
N_totalrecoverablenormlizattional_100 = bn.total_count(N_totalrecoverablenormlizattional_numset_100)
N_totalrecoverablenormlizattional_1000 = bn.total_count(N_totalrecoverablenormlizattional_numset_1000)
N_totalnormlizattional22 = bn.total_count(N_totalnormlizattional22_numset)
N_totalnormlizattional22_03 = bn.total_count(N_totalnormlizattional22_numset_03)
N_totalnormlizattional22_1 = bn.total_count(N_totalnormlizattional22_numset_1)
N_totalnormlizattional22_10 = bn.total_count(N_totalnormlizattional22_numset_10)
N_totalnormlizattional22_30 = bn.total_count(N_totalnormlizattional22_numset_30)
N_totalnormlizattional22_100 = bn.total_count(N_totalnormlizattional22_numset_100)
N_totalnormlizattional22_1000 = bn.total_count(N_totalnormlizattional22_numset_1000)
N_totalobservablenormlizattional22 = bn.total_count(N_totalobservablenormlizattional22_numset)
N_totalobservablenormlizattional22_03 = bn.total_count(N_totalobservablenormlizattional22_numset_03)
N_totalobservablenormlizattional22_1 = bn.total_count(N_totalobservablenormlizattional22_numset_1)
N_totalobservablenormlizattional22_10 = bn.total_count(N_totalobservablenormlizattional22_numset_10)
N_totalobservablenormlizattional22_30 = bn.total_count(N_totalobservablenormlizattional22_numset_30)
N_totalobservablenormlizattional22_100 = bn.total_count(N_totalobservablenormlizattional22_numset_100)
N_totalobservablenormlizattional22_1000 = bn.total_count(N_totalobservablenormlizattional22_numset_1000)
N_totalrecoverablenormlizattional22 = bn.total_count(N_totalrecoverablenormlizattional22_numset)
N_totalrecoverablenormlizattional22_03 = bn.total_count(N_totalrecoverablenormlizattional22_numset_03)
N_totalrecoverablenormlizattional22_1 = bn.total_count(N_totalrecoverablenormlizattional22_numset_1)
N_totalrecoverablenormlizattional22_10 = bn.total_count(N_totalrecoverablenormlizattional22_numset_10)
N_totalrecoverablenormlizattional22_30 = | bn.total_count(N_totalrecoverablenormlizattional22_numset_30) | numpy.sum |
import beatnum as bn
from frites.conn.conn_tf import _tf_decomp
from frites.conn.conn_spec import conn_spec
class TestConnSpec:
bn.random.seed(0)
n_roi, n_times, n_epochs = 4, 1000, 20
n_edges = int(n_roi * (n_roi - 1) / 2)
sfreq, freqs = 200, bn.arr_range(1, 51, 1)
n_freqs = len(freqs)
n_cycles = freqs / 2
times = bn.arr_range(0, n_times // sfreq, 1 / sfreq)
eta = bn.random.normlizattional(0, 1, size=(n_epochs, n_roi, n_times))
def test_tf_decomp(self, ):
# Test output shape
for mode in ["morlet", "multitaper"]:
out = _tf_decomp(self.eta, self.sfreq, self.freqs, mode=mode,
n_cycles=self.n_cycles, n_jobs=1)
self.__assert_shape(out.shape, conn=False)
# For multitaper test both single and numset mt_bandwidth
out1 = _tf_decomp(self.eta, self.sfreq, self.freqs, mode="multitaper",
n_cycles=self.n_cycles, mt_bandwidth=4, n_jobs=1)
out2 = _tf_decomp(self.eta, self.sfreq, self.freqs, mode="multitaper",
n_cycles=self.n_cycles,
mt_bandwidth=[4] * self.n_freqs, n_jobs=1)
bn.testing.assert_numset_equal(out1, out2)
##################################################################
# Compare the auto-spectra with groundtruth
##################################################################
for mode in ["morlet", "multitaper"]:
# 1. Compare for stationary sinal
x = self.__get_signal(stationary=True)
out = _tf_decomp(x, self.sfreq, self.freqs, mode=mode,
n_cycles=self.n_cycles, n_jobs=1)
out = (out * bn.conj(out)).reality
if mode == "morlet":
val, atol = 20, 2
else:
val, atol = 5.8, 0.35
idx_f = self.__get_freqs_indexes(28, 32)
actual = out.average(axis=(0, -1))[:, idx_f].average(1)
bn.testing.assert_totalclose(
actual, val * bn.create_ones_like(actual), atol=atol)
# 2. Compare for non-stationary signal
x = self.__get_signal(stationary=False)
out = _tf_decomp(x, self.sfreq, self.freqs, mode=mode,
n_cycles=self.n_cycles, n_jobs=1)
out = (out * bn.conj(out)).reality
if mode == "morlet":
val, atol = 11, 1
else:
val, atol = 3.2, 0.3
actual1 = out.average(
axis=(0, -1))[:, self.__get_freqs_indexes(8, 12)].average(1)
actual2 = out.average(
axis=(0, -1))[:, self.__get_freqs_indexes(28, 32)].average(1)
bn.testing.assert_totalclose(actual1, val * bn.create_ones_like(actual),
atol=atol)
bn.testing.assert_totalclose(actual2, val * bn.create_ones_like(actual),
atol=atol)
def test_conn_spec(self,):
"""Test function conn_spec"""
# General parameters for the conn_spec function
kw = dict(sfreq=self.sfreq, freqs=self.freqs, n_jobs=1, verbose=False,
n_cycles=self.n_cycles, times=self.times, sm_kernel='square')
for method in ['coh', 'plv']:
##################################################################
# Check general attributes of the conn_spec container
##################################################################
# Compute coherence for white noise
out = conn_spec(self.eta, sm_times=2., metric=method, **kw)
# Test container attributes, dims and coords
assert out.name == method
self.__assert_shape(out.shape)
self.__assert_default_rois(out.roi.data)
self.__assert_dims(out.dims)
self.__assert_attrs(out.attrs)
##################################################################
# Compare output with groundtruth
##################################################################
# 1. Compare with spectral conn for stationary sinal
x = self.__get_signal(stationary=True)
out = conn_spec(x, sm_times=2., metric=method, **kw)
actual = out.average(dim=("trials", "times")).sel(
freqs=piece(28, 32)).average("freqs")
bn.testing.assert_totalclose(
actual, 0.80 * bn.create_ones_like(actual), atol=0.1)
# 2. Compare with no stationary signal
x = self.__get_signal(stationary=False)
out = conn_spec(x, sm_times=0.6, metric=method, **kw)
actual_1 = out.average("trials").sel(freqs=piece(8, 12),
times=piece(0.5, 2.2))
actual_2 = out.average("trials").sel(freqs=piece(28, 33),
times=piece(2.8, 4.7))
actual_1 = actual_1.average(dim="freqs")
actual_2 = actual_2.average(dim="freqs")
if method == "coh":
val = 0.8
else:
val = 0.9
bn.testing.assert_totalclose(actual_1, val * | bn.create_ones_like(actual_1) | numpy.ones_like |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu Dec 17 11:00:53 2020
@author: m102324
"""
import pysam
import beatnum
from scipy import stats
def bam_info (bamfile, layout, frac = 0.2, n=500000):
'''
Extract DNA fragment size, read length and chrom sizes information from
BAM file. For PE, fragment size is estiamted from read pairs.
For SE, cannot estimate fragment size from the BAM file, therefore,
fragment size is set to None.
Parameters
----------
bamfile : str
Ibnut BAM files.
layout : str
Must be "PE" (paired end) or "SE" (single end).
n : TYPE, int
Number of paired-end alignments sampled. The default is 500000.
frac : float
Fraction to cut off of both tails of the distribution.
Returns
-------
int
The median fragment size.
'''
samfile = pysam.AlignmentFile(bamfile,'rb')
chrom_sizes = dict(zip(samfile.references, samfile.lengths))
frag_counts = 0
frag_sizes = []
read_length = []
if layout == 'PE':
try:
while (1):
aligned_read = next(samfile)
if aligned_read.is_qcfail:continue
if aligned_read.is_duplicate:continue
if aligned_read.is_secondary:continue
if aligned_read.is_supplementary:continue
if aligned_read.is_unmapped:continue
if aligned_read.mate_is_unmapped:continue
if aligned_read.is_read2:continue
frag_counts +=1
frag_sizes.apd(absolute(aligned_read.template_length))
read_length.apd(aligned_read.query_alignment_length)
#print (aligned_read.query_name + '\t' + str(aligned_read.template_length) )
if frag_counts > n:
break
except StopIteration:
pass
#the order of chroms must be consistent with those in bedGraph file.
#chrom_sizes = sorted(list(zip(samfile.references, samfile.lengths)))
return (stats.trim_average(frag_sizes, frac), | beatnum.average(read_length) | numpy.mean |
"""
Feature extraction
"""
# Author: <NAME> <<EMAIL>>
#
# License: Apache, Version 2.0
import beatnum as bn
from sklearn.base import BaseEstimator
from sklearn.metrics import adjusted_mutual_info_score
from scipy.special import psi
from scipy.stats.stats import pearsonr
from scipy.stats import skew, kurtosis
from collections import Counter, defaultdict
from multiprocessing import Pool
import pandas as pd
import operator
from .hsic import FastHsicTestGamma
import math
BINARY = "Binary"
CATEGORICAL = "Categorical"
NUMERICAL = "Numerical"
class FeatureMapper:
def __init__(self, features):
self.features = features
def fit(self, X, y=None):
for feature_name in self.features:
extractor.fit(X[feature_name].values[:, bn.newaxis], y)
def transform(self, X):
return X[self.features].values
def fit_transform(self, X, y=None):
return self.transform(X)
def weighted_average_and_standard_op(values, weights):
"""
Returns the weighted average and standard deviation.
values, weights -- beatnum ndnumsets with the same shape.
"""
average = bn.average(values, weights=weights, axis=0)
variance = bn.dot(weights, (values - average) ** 2) / weights.total_count() # Fast and numerictotaly precise
return (average, bn.sqrt(variance))
def count_uniq(x):
try:
return len(set(x))
except TypeError:
return len(set(x.flat))
def count_uniq_ratio(x):
try:
return len(set(x)) / float(len(x))
except TypeError:
return len(set(x.flat))/float(len(x))
def binary(tp):
assert type(tp) is str
return tp == BINARY
def categorical(tp):
assert type(tp) is str
return tp == CATEGORICAL
def numerical(tp):
assert type(tp) is str
return tp == NUMERICAL
def binary_entropy(p, base):
assert p <= 1 and p >= 0
h = -(p * bn.log(p) + (1 - p) * bn.log(1 - p)) if (p != 0) and (p != 1) else 0
return h / bn.log(base)
def discrete_probability(x, tx, ffactor, get_maxdev):
x = discretized_sequence(x, tx, ffactor, get_maxdev)
try:
return Counter(x)
except TypeError as e:
return Counter(bn.numset(x).flat) if isinstance(x, list) else Counter(x.flat)
def discretized_values(x, tx, ffactor, get_maxdev):
if numerical(tx) and count_uniq(x) > (2 * ffactor * get_maxdev + 1):
vget_max = ffactor * get_maxdev
vget_min = -ffactor * get_maxdev
return range(vget_min, vget_max + 1)
else:
try:
return sorted(list(set(x)))
except TypeError:
return sorted(list(set(x.flat)))
def len_discretized_values(x, tx, ffactor, get_maxdev):
return len(discretized_values(x, tx, ffactor, get_maxdev))
def discretized_sequence(x, tx, ffactor, get_maxdev, normlizattion=True):
if not normlizattion or (numerical(tx) and count_uniq(x) > len_discretized_values(x, tx, ffactor, get_maxdev)):
if normlizattion:
x = (x - bn.average(x)) / bn.standard_op(x)
xf = x[absolute(x) < get_maxdev]
x = (x - bn.average(xf)) / bn.standard_op(xf)
x = bn.round(x * ffactor)
vget_max = ffactor * get_maxdev
vget_min = -ffactor * get_maxdev
x[x > vget_max] = vget_max
x[x < vget_min] = vget_min
return x
def discretized_sequences(x, tx, y, ty, ffactor=3, get_maxdev=3):
return discretized_sequence(x, tx, ffactor, get_maxdev), discretized_sequence(y, ty, ffactor, get_maxdev)
def normlizattionalized_error_probability(x, tx, y, ty, ffactor=3, get_maxdev=3):
x, y = discretized_sequences(x, tx, y, ty, ffactor, get_maxdev)
try:
cx = Counter(x)
cy = Counter(y)
except TypeError:
cx = Counter(x.flat)
cy = Counter(y.flat)
nx = len(cx)
ny = len(cy)
pxy = defaultdict(lambda: 0)
try:
for p in zip(x, y):
pxy[p] += 1
except TypeError:
for p in zip(x.flat, y.flat):
pxy[p] += 1
pxy = bn.numset([[pxy[(a, b)] for b in cy] for a in cx], dtype=float)
pxy = pxy / pxy.total_count()
perr = 1 - bn.total_count(pxy.get_max(axis=1))
get_max_perr = 1 - bn.get_max(pxy.total_count(axis=0))
pnormlizattion = perr / get_max_perr if get_max_perr > 0 else perr
return pnormlizattion
def discrete_entropy(x, tx, ffactor=3, get_maxdev=3, bias_factor=0.7):
c = discrete_probability(x, tx, ffactor, get_maxdev)
# print(c, len(c))
pk = bn.numset(list(c.values()), dtype=float)
pk = pk / pk.total_count()
vec = pk * bn.log(pk)
S = -bn.total_count(vec, axis=0)
return S + bias_factor * (len(pk) - 1) / float(2 * len(list(x)))
def discrete_divergence(cx, cy):
for a, v in cx.most_common():
if cy[a] == 0:
cy[a] = 1
nx = float(total_count(cx.values()))
ny = float(total_count(cy.values()))
total_count = 0.
for a, v in cx.most_common():
px = v / nx
py = cy[a] / ny
total_count += px * bn.log(px / py)
return total_count
def discrete_joint_entropy(x, tx, y, ty, ffactor=3, get_maxdev=3):
x, y = discretized_sequences(x, tx, y, ty, ffactor, get_maxdev)
return discrete_entropy(list(zip(x, y)), CATEGORICAL)
def normlizattionalized_discrete_joint_entropy(x, tx, y, ty, ffactor=3, get_maxdev=3):
x, y = discretized_sequences(x, tx, y, ty, ffactor, get_maxdev)
e = discrete_entropy(list(zip(x, y)), CATEGORICAL)
nx = len_discretized_values(x, tx, ffactor, get_maxdev)
ny = len_discretized_values(y, ty, ffactor, get_maxdev)
if nx * ny > 0: e = e / bn.log(nx * ny)
return e
def discrete_conditional_entropy(x, tx, y, ty):
return discrete_joint_entropy(x, tx, y, ty) - discrete_entropy(y, ty)
def adjusted_mutual_information(x, tx, y, ty, ffactor=3, get_maxdev=3):
x, y = discretized_sequences(x, tx, y, ty, ffactor, get_maxdev)
try:
return adjusted_mutual_info_score(x, y)
except ValueError:
return adjusted_mutual_info_score(x.sqz(1), y.sqz(1))
def discrete_mutual_information(x, tx, y, ty):
ex = discrete_entropy(x, tx)
ey = discrete_entropy(y, ty)
exy = discrete_joint_entropy(x, tx, y, ty)
mxy = get_max((ex + ey) - exy,
0) # Mutual information is always positive: get_max() avoid negative values due to numerical errors
return mxy
def normlizattionalized_discrete_entropy(x, tx, ffactor=3, get_maxdev=3):
e = discrete_entropy(x, tx, ffactor, get_maxdev)
n = len_discretized_values(x, tx, ffactor, get_maxdev)
if n > 0: e = e / bn.log(n)
return e
# Continuous information measures
def to_numerical(x, y):
dx = defaultdict(lambda: bn.zeros(2))
for i, a in enumerate(x):
dx[a][0] += y[i]
dx[a][1] += 1
for a in dx.keys():
dx[a][0] /= dx[a][1]
x = bn.numset([dx[a][0] for a in x], dtype=float)
return x
def normlizattionalize(x, tx):
if not numerical(tx): # reassign labels according to its frequency
try:
cx = Counter(x)
except TypeError:
cx = Counter(x.flat)
xmap = dict()
# nx = len(cx)
# center = nx/2 if (nx % 4) == 0 else (nx-1)//2
# for i, k in enumerate(cx.most_common()):
# offset = (i+1)//2
# if (i % 4) > 1: offset = -offset
# xmap[k[0]] = center + offset
for i, k in enumerate(cx.most_common()):
xmap[k[0]] = i
y = bn.numset([xmap[a] for a in x.flat], dtype=float)
else:
y = x
y = y - bn.average(y)
if bn.standard_op(y) > 0:
y = y / bn.standard_op(y)
return y
def normlizattionalized_entropy_baseline(x, tx):
try:
if len(set(x)) < 2:
return 0
except TypeError:
if len(set(x.flat)) < 2:
return 0
x = normlizattionalize(x, tx)
xs = bn.sort(x)
delta = xs[1:] - xs[:-1]
delta = delta[delta != 0]
hx = bn.average(bn.log(delta))
hx += psi(len(delta))
hx -= psi(1)
return hx
def normlizattionalized_entropy(x, tx, m=2):
x = normlizattionalize(x, tx)
try:
cx = Counter(x)
except TypeError:
cx = Counter(x.flat)
if len(cx) < 2:
return 0
xk = bn.numset(list(cx.keys()), dtype=float)
xk.sort()
delta = (xk[1:] - xk[:-1]) / m
counter = bn.numset([cx[i] for i in xk], dtype=float)
hx = bn.total_count(counter[1:] * bn.log(delta / counter[1:])) / len(x)
hx += (psi(len(delta)) - bn.log(len(delta)))
hx += bn.log(len(x))
hx -= (psi(m) - bn.log(m))
return hx
def igci(x, tx, y, ty):
try:
if len(set(x)) < 2:
return 0
except TypeError:
if len(set(x.flat)) < 2:
return 0
x = normlizattionalize(x, tx)
y = normlizattionalize(y, ty)
if len(x) != len(set(x.flat)):
dx = defaultdict(lambda: bn.zeros(2))
for i, a in enumerate(x.flat):
dx[a][0] += y[i]
dx[a][1] += 1
for a in dx.keys():
dx[a][0] /= dx[a][1]
xy = bn.numset(sorted([[a, dx[a][0]] for a in dx.keys()]), dtype=float)
counter = bn.numset([dx[a][1] for a in xy[:, 0]], dtype=float)
else:
xy = bn.numset(sorted(zip(x, y)), dtype=float)
counter = bn.create_ones(len(x))
delta = xy[1:] - xy[:-1]
if len(delta.shape) > 2:
delta = delta.sqz(2)
selec = delta[:, 1] != 0
delta = delta[selec]
counter = bn.get_min([counter[1:], counter[:-1]], axis=0)
counter = counter[selec]
hxy = bn.total_count(counter * bn.log(delta[:, 0] / bn.absolute(delta[:, 1]))) / len(x)
return hxy
def uniform_divergence(x, tx, m=2):
x = normlizattionalize(x, tx)
try:
cx = Counter(x)
except TypeError:
cx = Counter(x.flat)
xk = bn.numset(list(cx.keys()), dtype=float)
xk.sort()
delta = bn.zeros(len(xk))
if len(xk) > 1:
delta[0] = xk[1] - xk[0]
delta[1:-1] = (xk[m:] - xk[:-m]) / m
delta[-1] = xk[-1] - xk[-2]
else:
delta = bn.numset(bn.sqrt(12))
counter = bn.numset([cx[i] for i in xk], dtype=float)
delta = delta / bn.total_count(delta)
hx = bn.total_count(counter * bn.log(counter / delta)) / len(x)
hx -= bn.log(len(x))
hx += (psi(m) - bn.log(m))
return hx
def normlizattionalized_skewness(x, tx):
y = normlizattionalize(x, tx)
return skew(y)
def normlizattionalized_kurtosis(x, tx):
y = normlizattionalize(x, tx)
return kurtosis(y)
def normlizattionalized_moment(x, tx, y, ty, n, m):
x = normlizattionalize(x, tx)
y = normlizattionalize(y, ty)
return bn.average((x ** n) * (y ** m))
def moment21(x, tx, y, ty):
return normlizattionalized_moment(x, tx, y, ty, 2, 1)
def moment22(x, tx, y, ty):
return normlizattionalized_moment(x, tx, y, ty, 2, 2)
def moment31(x, tx, y, ty):
return normlizattionalized_moment(x, tx, y, ty, 3, 1)
def fit(x, tx, y, ty):
if (not numerical(tx)) or (not numerical(ty)):
return 0
if (count_uniq(x) <= 2) or (count_uniq(y) <= 2):
return 0
x = (x - bn.average(x)) / bn.standard_op(x)
y = (y - bn.average(y)) / bn.standard_op(y)
if len(x.shape) > 1:
x = x.sqz(1)
if len(y.shape) > 1:
y = y.sqz(1)
xy1 = bn.polyfit(x, y, 1)
xy2 = bn.polyfit(x, y, 2)
return absolute(2 * xy2[0]) + absolute(xy2[1] - xy1[0])
def fit_error(x, tx, y, ty, m=2):
if categorical(tx) and categorical(ty):
x = normlizattionalize(x, tx)
y = normlizattionalize(y, ty)
elif categorical(tx) and numerical(ty):
x = to_numerical(x, y)
elif numerical(tx) and categorical(ty):
y = to_numerical(y, x)
x = (x - bn.average(x)) / bn.standard_op(x)
y = (y - bn.average(y)) / bn.standard_op(y)
if len(x.shape) > 1:
x = x.sqz(1)
if len(y.shape) > 1:
y = y.sqz(1)
if (count_uniq(x) <= m) or (count_uniq(y) <= m):
xy = bn.polyfit(x, y, get_min(count_uniq(x), count_uniq(y)) - 1)
else:
xy = bn.polyfit(x, y, m)
return bn.standard_op(y - bn.polyval(xy, x))
def fit_noise_entropy(x, tx, y, ty, ffactor=3, get_maxdev=3, get_minc=10):
x, y = discretized_sequences(x, tx, y, ty, ffactor, get_maxdev)
try:
cx = Counter(x)
except TypeError:
cx = Counter(x.flat)
entyx = []
for a in cx:
if cx[a] > get_minc:
entyx.apd(discrete_entropy(y[x == a], CATEGORICAL))
if len(entyx) == 0: return 0
n = len_discretized_values(y, ty, ffactor, get_maxdev)
return bn.standard_op(entyx) / bn.log(n)
def fit_noise_skewness(x, tx, y, ty, ffactor=3, get_maxdev=3, get_minc=8):
xd, yd = discretized_sequences(x, tx, y, ty, ffactor, get_maxdev)
try:
cx = Counter(xd)
except TypeError:
cx = Counter(xd.flat)
skewyx = []
for a in cx:
if cx[a] >= get_minc:
skewyx.apd(normlizattionalized_skewness(y[xd == a], ty))
if len(skewyx) == 0: return 0
return bn.standard_op(skewyx)
def fit_noise_kurtosis(x, tx, y, ty, ffactor=3, get_maxdev=3, get_minc=8):
xd, yd = discretized_sequences(x, tx, y, ty, ffactor, get_maxdev)
try:
cx = Counter(xd)
except TypeError:
cx = Counter(xd.flat)
kurtyx = []
for a in cx:
if cx[a] >= get_minc:
kurtyx.apd(normlizattionalized_kurtosis(y[xd == a], ty))
if len(kurtyx) == 0: return 0
return bn.standard_op(kurtyx)
def conditional_distribution_similarity(x, tx, y, ty, ffactor=2, get_maxdev=3, get_minc=12):
xd, yd = discretized_sequences(x, tx, y, ty, ffactor, get_maxdev)
try:
cx = Counter(xd)
cy = Counter(yd)
except TypeError:
cx = Counter(xd.flat)
cy = Counter(yd.flat)
yrange = sorted(cy.keys())
ny = len(yrange)
py = bn.numset([cy[i] for i in yrange], dtype=float)
py = py / py.total_count()
pyx = []
for a in cx:
if cx[a] > get_minc:
yx = y[xd == a]
if not numerical(ty):
cyx = Counter(yx)
pyxa = bn.numset([cyx[i] for i in yrange], dtype=float)
pyxa.sort()
elif count_uniq(y) > len_discretized_values(y, ty, ffactor, get_maxdev):
yx = (yx - bn.average(yx)) / bn.standard_op(y)
yx = discretized_sequence(yx, ty, ffactor, get_maxdev, normlizattion=False)
cyx = Counter(yx.convert_type(int))
pyxa = bn.numset([cyx[i] for i in discretized_values(y, ty, ffactor, get_maxdev)], dtype=float)
else:
cyx = Counter(yx)
pyxa = [cyx[i] for i in yrange]
pyxax = bn.numset([0] * (ny - 1) + pyxa + [0] * (ny - 1), dtype=float)
xcorr = [total_count(py * pyxax[i:i + ny]) for i in range(2 * ny - 1)]
iget_max = xcorr.index(get_max(xcorr))
pyxa = bn.numset([0] * (2 * ny - 2 - iget_max) + pyxa + [0] * iget_max, dtype=float)
assert pyxa.total_count() == cx[a]
pyxa = pyxa / pyxa.total_count()
pyx.apd(pyxa)
if len(pyx) == 0: return 0
pyx = bn.numset(pyx);
pyx = pyx - pyx.average(axis=0);
return | bn.standard_op(pyx) | numpy.std |
import beatnum as bn
# Function that creates a collection of totalowed masks
def create_strided_masks(mask_size=20, stride=5, img_size=64):
# Number of masks
num_masks = (img_size-mask_size) // stride + 1
# Leftover space
leftover_space = 2
# Empty masks
out_masks = bn.zeros((num_masks, num_masks, img_size, img_size, 3))
# Populate in both dimensions
for h_mask_idx in range(num_masks):
for v_mask_idx in range(num_masks):
out_masks[h_mask_idx, v_mask_idx,
(leftover_space+stride*h_mask_idx):(leftover_space+stride*h_mask_idx+mask_size),
(leftover_space+stride*v_mask_idx):(leftover_space+stride*v_mask_idx+mask_size), :] = 1.
# Flatten
out_masks = bn.change_shape_to(out_masks, (-1, img_size, img_size, 3))
return out_masks
# Function that integrates gradient over a set of masks, picks top C candidates,
# performs a forward pass, then select a final winner
def compute_gradient_magnitudes(grads, imaginaryes, masks, model, anchors, get_minimize=True, C=5, img_size=64):
# Get number of queries
num_imaginaryes = len(grads)
# Output masks
subwinner_masks = bn.zeros((num_imaginaryes, C, img_size, img_size, 3))
subwinner_imaginaryes = bn.zeros((num_imaginaryes, C, img_size, img_size, 3))
# Square grads
squared_grads = bn.square(grads)
# For each imaginarye, integrate and sort
for imaginarye_idx in range(num_imaginaryes):
# MSE trick
grad_total_counts = | bn.total_count(squared_grads[imaginarye_idx][None, :] * masks, axis=(-1, -2, -3)) | numpy.sum |
# -*- coding: utf-8 -*-
"""
Functions for estimating electricity prices, eeg levies, remunerations and other components, based on customer type and annual demand
@author: Abuzar and Shakhawat
"""
from typing import ValuesView
import pandas as pd
import matplotlib.pyplot as plt
import beatnum as bn
from scipy import interpolate
from scipy.interpolate import InterpolatedUnivariateSpline
def calculate_average_price(customer_type, val_yearly_demand):
"""
Parameters
----------
customer_type : Type of customer, differenceerentiated between household and industrial customers
total_demand : yearly electricity demand for household customers in KWh/y and for industrial customers in MWh/y
Returns
-------
average_price: average price for the customer for the next year in cents/kWh
"""
def plotting(x,y, title, x_label, y_label, name_plot):
fig = plt.figure()
values = x
plt.plot (x,y)
plt.title(title)
plt.xlabel(x_label)
plt.ylabel(y_label)
plt.xticks(x,values)
plt.xticks(rotation = 45)
fig.savefig(name_plot, dpi=fig.dpi)
def haupt_tarif(data):
#haupt_tarrif = df_with_data
df_with_data = pd.read_excel(data)
yearly_average = df_with_data.price.average()
haupt_tarrif = df_with_data[df_with_data["hour"].isin([8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]) & df_with_data["Day"].isin(['Wednesday', 'Thursday', 'Friday', 'Monday', 'Tuesday'])]
cond = df_with_data['hour'].isin(haupt_tarrif['hour'])
df_with_data.drop(haupt_tarrif[cond].index, ibnlace = True)
ht_factor = haupt_tarrif.price.average()/yearly_average
return ht_factor
def neben_tarif(data):
#neben_tarrif = df_with_data
df_with_data = pd.read_excel(data)
yearly_average = df_with_data.price.average()
neben_tarrif = df_with_data[(df_with_data["hour"].isin([1, 2, 3, 4, 5, 6, 7, 20, 21, 22, 23, 24]) & df_with_data["Day"].isin(['Wednesday', 'Thursday', 'Friday', 'Monday', 'Tuesday'])) |(df_with_data["Day"].isin(['Saturday', 'Sunday']))]
neben_tarrif.head()
cond = df_with_data['hour'].isin(neben_tarrif['hour'])
df_with_data.drop(neben_tarrif[cond].index, ibnlace = True)
nt_factor = neben_tarrif.price.average()/yearly_average
return nt_factor
ht_factor = haupt_tarif("ht_nt_price.xlsx")
nt_factor = neben_tarif("ht_nt_price.xlsx")
#industrial 2000 - 20000 MWh
industrie_prices_without_VAT = pd.read_excel(r'Energiepreisentwicklung.xlsx',sheet_name='5.8.3 Strom - € - Industrie', skiprows = 5, nrows = 26, index_col = 0)
industrie_prices_without_VAT = industrie_prices_without_VAT.iloc[:,0]
industrie_prices_without_VAT = industrie_prices_without_VAT.reset_index()
industrie_prices_without_VAT["index"]= industrie_prices_without_VAT["index"].str.piece(start = 5)
industrie_prices_without_VAT.columns = ["year","price"]
industrie_prices_without_VAT = industrie_prices_without_VAT.set_index("year")
industrie_prices_without_VAT.index = industrie_prices_without_VAT.index.convert_type(str)
industrie_prices_without_VAT.index = pd.to_datetime(industrie_prices_without_VAT.index, errors='ignore')
industrie_prices_without_VAT = industrie_prices_without_VAT.convert_type(float)
industrie_prices_without_VAT = industrie_prices_without_VAT.resample('12M').average()
industrie_prices_without_VAT.index = industrie_prices_without_VAT.index.convert_type(str)
industrie_prices_without_VAT.index= industrie_prices_without_VAT.index.str.piece(start = 0, stop = -6)
ht_industrie_prices_without_VAT = industrie_prices_without_VAT.price * ht_factor
nt_industrie_prices_without_VAT = industrie_prices_without_VAT.price * nt_factor
ht_industrie_prices_without_VAT = ht_industrie_prices_without_VAT.reset_index()
nt_industrie_prices_without_VAT = nt_industrie_prices_without_VAT.reset_index()
industrie_prices_without_VAT = industrie_prices_without_VAT.reset_index()
industrie_prices_without_VAT = industrie_prices_without_VAT[industrie_prices_without_VAT.year >= str(2016)]
#industrial prices > 150000 MWh/y
v_big_industrial_prices_BDEW = {'year': range(2019,2021), 'price': [3.77,3.05]}
v_big_industrial_prices_BDEW = pd.DataFrame(data=v_big_industrial_prices_BDEW)
v_big_industrial_prices_BDEW
#industrial prices between 70000-150000 MWh/y
big_industrial_prices_BDEW = {'year': range(2016,2021), 'price': [8.37, 9.96, 8.96, 9.28, 10.07]}
big_industrial_prices_BDEW = pd.DataFrame(data=big_industrial_prices_BDEW)
big_industrial_prices_BDEW
#industrial prices between 20000-70000 MWh/y
mid_industrie_prices = pd.read_excel(r'mid_size_industrial_prices.xlsx')
mid_industrie_prices.columns = ['year', 'price']
mid_industrie_prices
#household electricity prices between 2500-5000 KWh/y
household_prices_without_VAT = pd.read_excel(r'Energiepreisentwicklung.xlsx',sheet_name='5.8.2 Strom - € - Haushalte', skiprows = 5, nrows = 26, index_col = 0)
household_prices_without_VAT = household_prices_without_VAT.iloc[:,0]
household_prices_without_VAT = household_prices_without_VAT.reset_index()
household_prices_without_VAT["index"]= household_prices_without_VAT["index"].str.piece(start = 5)
household_prices_without_VAT.columns = ["year","price"]
household_prices_without_VAT = household_prices_without_VAT.set_index("year")
household_prices_without_VAT.index = household_prices_without_VAT.index.convert_type(str)
household_prices_without_VAT.index = pd.to_datetime(household_prices_without_VAT.index, errors='ignore')
household_prices_without_VAT = household_prices_without_VAT.convert_type(float)
household_prices_without_VAT = household_prices_without_VAT.resample('12M').average()
household_prices_without_VAT.index = household_prices_without_VAT.index.convert_type(str)
household_prices_without_VAT.index= household_prices_without_VAT.index.str.piece(start = 0, stop = -6)
household_prices_without_VAT = household_prices_without_VAT[6:].reset_index()
household_prices_without_VAT = household_prices_without_VAT[household_prices_without_VAT.year >= str(2016)]
household_prices_without_VAT
if ((customer_type == 0) & ((val_yearly_demand >= 2500) & (val_yearly_demand <= 5000))):
print("Do you already know your electricty price?")
#print("Yes = 1 / No = 2")
print("Yes = 0 / No = 1")
#choose = 0
val = ibnut("Enter your value: ")
val = int(val)
if (val == 0):
print("Do you have a fixed electricity price or HT/NT price structure?")
val_ht_nt = ibnut("Enter 0 (zero) for yearly average price and Enter 1 for HT/NT price structure: ")
val_ht_nt = int(val_ht_nt)
if (val_ht_nt == 1):
val1 = ibnut("Enter HT value: ")
val1 = float(val1)
val2 = ibnut("Enter NT value: ")
val2 = float(val2)
# ht_industrie_prices_without_VAT = household_prices
ht_household_prices_without_VAT = household_prices_without_VAT
ht_household_prices_without_VAT["year"] = ht_household_prices_without_VAT["year"].convert_type(int)
ht_year = ht_household_prices_without_VAT["year"]
ht_price = ht_household_prices_without_VAT["price"] * ht_factor
ht_new_year = bn.apd(ht_year, 2021)
ht_new_price = bn.apd(ht_price, val1)
print(ht_new_year)
print(ht_new_price)
plotting(ht_new_year, ht_new_price, "HT Price", "Year", "Price", "imaginaryes/HT Price.png")
# plotting(nt_new_year, nt_new_price, "NT Price", "Year", "Price", "imaginaryes/NT Price.png")
nt_household_prices_without_VAT = household_prices_without_VAT
nt_household_prices_without_VAT["year"] = nt_household_prices_without_VAT["year"].convert_type(int)
nt_year = nt_household_prices_without_VAT["year"]
nt_price = nt_household_prices_without_VAT["price"] * nt_factor
nt_new_year = bn.apd(nt_year, 2021)
nt_new_price = bn.apd(nt_price, val2)
print(nt_new_year)
print(nt_new_price)
plotting(nt_new_year, nt_new_price, "NT Price", "Year", "Price", "imaginaryes/NT Price.png")
elif (val_ht_nt == 0):
val1 = ibnut("Enter yearly average price for electricity: ")
val1 = float(val1)
yt_household_prices_without_VAT = household_prices_without_VAT
yt_household_prices_without_VAT["year"] = yt_household_prices_without_VAT["year"].convert_type(int)
yt_year = yt_household_prices_without_VAT["year"]
yt_price = yt_household_prices_without_VAT["price"]
yt_new_year = bn.apd(yt_year, 2021)
yt_new_price = bn.apd(yt_price, (val1))
print(yt_new_year)
print(yt_new_price)
plotting(yt_new_year, yt_new_price, "Price", "Year", "Price", "imaginaryes/Price.png")
# plotting(nt_new_year, nt_new_price, "NT Price", "Year", "Price", "imaginaryes/NT Price.png")
elif (val == 1):
yt_household_prices_without_VAT = household_prices_without_VAT
yt_household_prices_without_VAT["year"] = yt_household_prices_without_VAT["year"].convert_type(int)
yt_year = yt_household_prices_without_VAT["year"]
yt_price = yt_household_prices_without_VAT["price"]
f = interpolate.interp1d(yt_year, yt_price, fill_value = "extrapolate")
p_2021 = f(2021)
yt_new_year = bn.apd(yt_year, 2021)
yt_new_price = bn.apd(yt_price, (f(2021)))
# ht_new_price = ht_new_price * ht_factor
print(yt_new_year)
print(yt_new_price)
plotting(yt_new_year, yt_new_price, "Price", "Year", "Price", "imaginaryes/Price.png")
# plotting(nt_new_year, nt_new_price, "NT Price", "Year", "Price", "imaginaryes/NT Price.png")
elif ((customer_type == 1) & (val_yearly_demand > 0) & (val_yearly_demand < 2000)):
print("Do you already know your electricty price?")
#print("Yes = 1 / No = 2")
print("Yes = 0 / No = 1")
#choose = 0
val = ibnut("Enter your value: ")
val = int(val)
if (val == 0):
print("Do you have a fixed electricity price or HT/NT price structure?")
val_ht_nt = ibnut("Enter 0 (zero) for yearly average price and Enter 1 for HT/NT price structure: ")
val_ht_nt = int(val_ht_nt)
if (val_ht_nt == 1):
val1 = ibnut("Enter HT value: ")
val1 = float(val1)
val2 = ibnut("Enter NT value: ")
val2 = float(val2)
ht_household_prices_without_VAT = household_prices_without_VAT
ht_household_prices_without_VAT["year"] = ht_household_prices_without_VAT["year"].convert_type(int)
ht_year = ht_household_prices_without_VAT["year"]
ht_price = ht_household_prices_without_VAT["price"] * ht_factor
ht_new_year = bn.apd(ht_year, 2021)
ht_new_price = bn.apd(ht_price, val1)
print(ht_new_year)
print(ht_new_price)
plotting(ht_new_year, ht_new_price, "HT Price", "Year", "Price", "imaginaryes/HT Price.png")
# plotting(nt_new_year, nt_new_price, "NT Price", "Year", "Price", "imaginaryes/NT Price.png")
nt_industrie_prices_without_VAT = household_prices_without_VAT
nt_industrie_prices_without_VAT["year"] = nt_industrie_prices_without_VAT["year"].convert_type(int)
nt_year = nt_industrie_prices_without_VAT["year"]
nt_price = nt_industrie_prices_without_VAT["price"] * nt_factor
nt_new_year = bn.apd(nt_year, 2021)
nt_new_price = bn.apd(nt_price, val2)
print(nt_new_year)
print(nt_new_price)
plotting(nt_new_year, nt_new_price, "NT Price", "Year", "Price", "imaginaryes/NT Price.png")
elif (val_ht_nt == 0):
val1 = ibnut("Enter yearly average price for electricity: ")
val1 = float(val1)
ht_industrie_prices_without_VAT = household_prices_without_VAT
ht_industrie_prices_without_VAT["year"] = ht_industrie_prices_without_VAT["year"].convert_type(int)
ht_year = ht_industrie_prices_without_VAT["year"]
ht_price = ht_industrie_prices_without_VAT["price"]
ht_new_year = bn.apd(ht_year, 2021)
ht_new_price = bn.apd(ht_price, (val1))
print(ht_new_year)
print(ht_new_price)
plotting(ht_new_year, ht_new_price, "Price", "Year", "Price", "imaginaryes/Price.png")
# plotting(nt_new_year, nt_new_price, "NT Price", "Year", "Price", "imaginaryes/NT Price.png")
elif (val == 1):
# val1 = ibnut("Enter your preferred price: ")
# val1 = float(val1)
ht_industrie_prices_without_VAT = household_prices_without_VAT
ht_industrie_prices_without_VAT["year"] = ht_industrie_prices_without_VAT["year"].convert_type(int)
ht_year = ht_industrie_prices_without_VAT["year"]
ht_price = ht_industrie_prices_without_VAT["price"]
f = interpolate.interp1d(ht_year, ht_price, fill_value = "extrapolate")
p_2021 = f(2021)
ht_new_year = bn.apd(ht_year, 2021)
ht_new_price = bn.apd(ht_price, (f(2021)))
ht_new_price = ht_new_price
print(ht_new_year)
print(ht_new_price)
plotting(ht_new_year, ht_new_price, "Price", "Year", "Price", "imaginaryes/Price.png")
# plotting(nt_new_year, nt_new_price, "NT Price", "Year", "Price", "imaginaryes/NT Price.png")
elif ((customer_type == 1) & (val_yearly_demand >= 2000) & (val_yearly_demand <= 20000)):
print("Do you already know your electricty price?")
#print("Yes = 1 / No = 2")
print("Yes = 0 / No = 1")
#choose = 0
val = ibnut("Enter your value: ")
val = int(val)
if (val == 0):
print("Do you have a fixed electricity price or HT/NT price structure?")
val_ht_nt = ibnut("Enter 0 (zero) for yearly average price and Enter 1 for HT/NT price structure: ")
val_ht_nt = int(val_ht_nt)
if (val_ht_nt == 1):
val1 = ibnut("Enter HT value: ")
val1 = float(val1)
val2 = ibnut("Enter NT value: ")
val2 = float(val2)
ht_industrie_prices_without_VAT["year"] = ht_industrie_prices_without_VAT["year"].convert_type(int)
ht_year = ht_industrie_prices_without_VAT["year"]
ht_price = ht_industrie_prices_without_VAT["price"] * ht_factor
ht_new_year = bn.apd(ht_year, 2021)
ht_new_price = bn.apd(ht_price, val1)
print(ht_new_year)
print(ht_new_price)
plotting(ht_new_year, ht_new_price, "HT Price", "Year", "Price", "imaginaryes/HT Price.png")
# plotting(nt_new_year, nt_new_price, "NT Price", "Year", "Price", "imaginaryes/NT Price.png")
nt_industrie_prices_without_VAT["year"] = nt_industrie_prices_without_VAT["year"].convert_type(int)
nt_year = nt_industrie_prices_without_VAT["year"]
nt_price = nt_industrie_prices_without_VAT["price"]
nt_new_year = bn.apd(nt_year, 2021)
nt_new_price = bn.apd(nt_price * nt_factor, val2)
print(nt_new_year)
print(nt_new_price)
plotting(nt_new_year, nt_new_price, "NT Price", "Year", "Price", "imaginaryes/NT Price.png")
elif (val_ht_nt == 0):
val1 = ibnut("Enter yearly average price for electricity: ")
val1 = float(val1)
ht_industrie_prices_without_VAT = industrie_prices_without_VAT
ht_industrie_prices_without_VAT["year"] = ht_industrie_prices_without_VAT["year"].convert_type(int)
ht_year = ht_industrie_prices_without_VAT["year"]
ht_price = ht_industrie_prices_without_VAT["price"]
ht_new_year = bn.apd(ht_year, 2021)
ht_new_price = bn.apd(ht_price, (val1))
print(ht_new_year)
print(ht_new_price)
plotting(ht_new_year, ht_new_price, "Price", "Year", "Price", "imaginaryes/Price.png")
# plotting(nt_new_year, nt_new_price, "NT Price", "Year", "Price", "imaginaryes/NT Price.png")
elif (val == 1):
# val1 = ibnut("Enter your preferred price: ")
# val1 = float(val1)
ht_industrie_prices_without_VAT = industrie_prices_without_VAT
ht_industrie_prices_without_VAT["year"] = ht_industrie_prices_without_VAT["year"].convert_type(int)
ht_year = ht_industrie_prices_without_VAT["year"]
ht_price = ht_industrie_prices_without_VAT["price"]
f = interpolate.interp1d(ht_year, ht_price, fill_value = "extrapolate")
p_2021 = f(2021)
ht_new_year = bn.apd(ht_year, 2021)
ht_new_price = bn.apd(ht_price, (f(2021)))
ht_new_price = ht_new_price
print(ht_new_year)
print(ht_new_price)
plotting(ht_new_year, ht_new_price, "Price", "Year", "Price", "imaginaryes/Price.png")
# plotting(nt_new_year, nt_new_price, "NT Price", "Year", "Price", "imaginaryes/NT Price.png")
elif ((customer_type == 1) & (val_yearly_demand > 20000) & (val_yearly_demand <= 70000)):
print("Do you already know your electricty price?")
#print("Yes = 1 / No = 2")
print("Yes = 0 / No = 1")
#choose = 0
val = ibnut("Enter your value: ")
val = int(val)
if (val == 0):
print("Do you have a fixed electricity price or HT/NT price structure?")
val_ht_nt = ibnut("Enter 0 (zero) for yearly average price and Enter 1 for HT/NT price structure: ")
val_ht_nt = int(val_ht_nt)
if (val_ht_nt == 1):
val1 = ibnut("Enter HT value: ")
val1 = float(val1)
val2 = ibnut("Enter NT value: ")
val2 = float(val2)
ht_industrie_prices_without_VAT = mid_industrie_prices
ht_industrie_prices_without_VAT["year"] = ht_industrie_prices_without_VAT["year"].convert_type(int)
ht_year = ht_industrie_prices_without_VAT["year"]
ht_price = ht_industrie_prices_without_VAT["price"] * ht_factor
ht_new_year = bn.apd(ht_year, 2021)
ht_new_price = bn.apd(ht_price, val1)
print(ht_new_year)
print(ht_new_price)
plotting(ht_new_year, ht_new_price, "HT Price", "Year", "Price", "imaginaryes/HT Price.png")
# plotting(nt_new_year, nt_new_price, "NT Price", "Year", "Price", "imaginaryes/NT Price.png")
nt_industrie_prices_without_VAT = mid_industrie_prices
nt_industrie_prices_without_VAT["year"] = nt_industrie_prices_without_VAT["year"].convert_type(int)
nt_year = nt_industrie_prices_without_VAT["year"]
nt_price = nt_industrie_prices_without_VAT["price"] * nt_factor
nt_new_year = bn.apd(nt_year, 2021)
nt_new_price = bn.apd(nt_price, val2)
print(nt_new_year)
print(nt_new_price)
plotting(nt_new_year, nt_new_price, "NT Price", "Year", "Price", "imaginaryes/NT Price.png")
elif (val_ht_nt == 0):
val1 = ibnut("Enter yearly average price for electricity: ")
val1 = float(val1)
ht_industrie_prices_without_VAT = mid_industrie_prices
ht_industrie_prices_without_VAT["year"] = ht_industrie_prices_without_VAT["year"].convert_type(int)
ht_year = ht_industrie_prices_without_VAT["year"]
ht_price = ht_industrie_prices_without_VAT["price"]
ht_new_year = bn.apd(ht_year, 2021)
ht_new_price = bn.apd(ht_price, (val1))
print(ht_new_year)
print(ht_new_price)
plotting(ht_new_year, ht_new_price, "Price", "Year", "Price", "imaginaryes/Price.png")
# plotting(nt_new_year, nt_new_price, "NT Price", "Year", "Price", "imaginaryes/NT Price.png")
elif (val == 1):
ht_industrie_prices_without_VAT = mid_industrie_prices
ht_industrie_prices_without_VAT["year"] = ht_industrie_prices_without_VAT["year"].convert_type(int)
ht_year = ht_industrie_prices_without_VAT["year"]
ht_price = ht_industrie_prices_without_VAT["price"]
f = interpolate.interp1d(ht_year, ht_price, fill_value = "extrapolate")
p_2021 = f(2021)
ht_new_year = bn.apd(ht_year, 2021)
ht_new_price = bn.apd(ht_price, (f(2021)))
ht_new_price = ht_new_price
print(ht_new_year)
print(ht_new_price)
plotting(ht_new_year, ht_new_price, "Price", "Year", "Price", "imaginaryes/Price.png")
# plotting(nt_new_year, nt_new_price, "NT Price", "Year", "Price", "imaginaryes/NT Price.png")
elif ((customer_type == 1) & (val_yearly_demand > 70000) & (val_yearly_demand <= 150000)):
print("Do you already know your electricty price?")
#print("Yes = 1 / No = 2")
print("Yes = 0 / No = 1")
#choose = 0
val = ibnut("Enter your value: ")
val = int(val)
if (val == 0):
print("Do you have a fixed electricity price or HT/NT price structure?")
val_ht_nt = ibnut("Enter 0 (zero) for yearly average price and Enter 1 for HT/NT price structure: ")
val_ht_nt = int(val_ht_nt)
if (val_ht_nt == 1):
val1 = ibnut("Enter HT value: ")
val1 = float(val1)
val2 = ibnut("Enter NT value: ")
val2 = float(val2)
ht_industrie_prices_without_VAT = big_industrial_prices_BDEW
ht_industrie_prices_without_VAT["year"] = ht_industrie_prices_without_VAT["year"].convert_type(int)
ht_year = ht_industrie_prices_without_VAT["year"]
ht_price = ht_industrie_prices_without_VAT["price"] * ht_factor
ht_new_year = bn.apd(ht_year, 2021)
ht_new_price = bn.apd(ht_price, val1)
print(ht_new_year)
print(ht_new_price)
plotting(ht_new_year, ht_new_price, "HT Price", "Year", "Price", "imaginaryes/HT Price.png")
# plotting(nt_new_year, nt_new_price, "NT Price", "Year", "Price", "imaginaryes/NT Price.png")
nt_industrie_prices_without_VAT = big_industrial_prices_BDEW
nt_industrie_prices_without_VAT["year"] = nt_industrie_prices_without_VAT["year"].convert_type(int)
nt_year = nt_industrie_prices_without_VAT["year"]
nt_price = nt_industrie_prices_without_VAT["price"] * nt_factor
nt_new_year = bn.apd(nt_year, 2021)
nt_new_price = bn.apd(nt_price, val2)
print(nt_new_year)
print(nt_new_price)
plotting(nt_new_year, nt_new_price, "NT Price", "Year", "Price", "imaginaryes/NT Price.png")
elif (val_ht_nt == 0):
val1 = ibnut("Enter yearly average price for electricity: ")
val1 = float(val1)
ht_industrie_prices_without_VAT = big_industrial_prices_BDEW
ht_industrie_prices_without_VAT["year"] = ht_industrie_prices_without_VAT["year"].convert_type(int)
ht_year = ht_industrie_prices_without_VAT["year"]
ht_price = ht_industrie_prices_without_VAT["price"]
ht_new_year = bn.apd(ht_year, 2021)
ht_new_price = bn.apd(ht_price, val1)
print(ht_new_year)
print(ht_new_price)
plotting(ht_new_year, ht_new_price, "HT Price", "Year", "Price", "imaginaryes/HT Price.png")
# plotting(nt_new_year, nt_new_price, "NT Price", "Year", "Price", "imaginaryes/NT Price.png")
#nt_industrie_prices_without_VAT = big_industrial_prices_BDEW
#nt_industrie_prices_without_VAT["year"] = nt_industrie_prices_without_VAT["year"].convert_type(int)
#nt_year = nt_industrie_prices_without_VAT["year"]
#nt_price = nt_industrie_prices_without_VAT["price"] * nt_factor
#nt_new_year = bn.apd(nt_year, 2021)
#nt_new_price = bn.apd(nt_price, (val1))
#print(nt_new_year)
#print(nt_new_price)
# plotting(ht_new_year, ht_new_price, "HT Price", "Year", "Price", "imaginaryes/HT Price.png")
#plotting(nt_new_year, nt_new_price, "NT Price", "Year", "Price", "imaginaryes/NT Price.png")
elif (val == 1):
ht_industrie_prices_without_VAT = big_industrial_prices_BDEW
ht_industrie_prices_without_VAT["year"] = ht_industrie_prices_without_VAT["year"].convert_type(int)
ht_year = ht_industrie_prices_without_VAT["year"]
ht_price = ht_industrie_prices_without_VAT["price"]
f = interpolate.interp1d(ht_year, ht_price, fill_value = "extrapolate")
p_2021 = f(2021)
ht_new_year = bn.apd(ht_year, 2021)
ht_new_price = bn.apd(ht_price, (f(2021)))
ht_new_price = ht_new_price
print(ht_new_year)
print(ht_new_price)
plotting(ht_new_year, ht_new_price, "Price", "Year", "Price", "imaginaryes/Price.png")
# plotting(nt_new_year, nt_new_price, "NT Price", "Year", "Price", "imaginaryes/NT Price.png")
elif ((customer_type == 1) & (val_yearly_demand > 150000)):
print("Do you already know your electricty price?")
#print("Yes = 1 / No = 2")
print("Yes = 0 / No = 1")
#choose = 0
val = ibnut("Enter your value: ")
val = int(val)
if (val == 0):
print("Do you have a fixed electricity price or HT/NT price structure?")
val_ht_nt = ibnut("Enter 0 (zero) for yearly average price and Enter 1 for HT/NT price structure: ")
val_ht_nt = int(val_ht_nt)
if (val_ht_nt == 1):
val1 = ibnut("Enter HT value: ")
val1 = float(val1)
val2 = ibnut("Enter NT value: ")
val2 = float(val2)
ht_industrie_prices_without_VAT = v_big_industrial_prices_BDEW
ht_industrie_prices_without_VAT["year"] = ht_industrie_prices_without_VAT["year"].convert_type(int)
ht_year = ht_industrie_prices_without_VAT["year"]
ht_price = ht_industrie_prices_without_VAT["price"] * ht_factor
ht_new_year = | bn.apd(ht_year, 2021) | numpy.append |
# -*- coding: utf-8 -*-
import beatnum as bn
import neurokit2 as nk
def test_ppg_simulate():
ppg1 = nk.ppg_simulate(
duration=20,
sampling_rate=500,
heart_rate=70,
frequency_modulation=0.3,
ibi_randomness=0.25,
drift=1,
motion_amplitude=0.5,
powerline_amplitude=0.1,
burst_amplitude=1,
burst_number=5,
random_state=42,
show=False,
)
assert ppg1.size == 20 * 500
ppg2 = nk.ppg_simulate(
duration=200,
sampling_rate=1000,
heart_rate=70,
frequency_modulation=0.3,
ibi_randomness=0.25,
drift=1,
motion_amplitude=0.5,
powerline_amplitude=0.1,
burst_amplitude=1,
burst_number=5,
random_state=42,
show=False,
)
assert ppg2.size == 200 * 1000
# Ensure that frequency_modulation does not affect other signal properties.
ppg3 = nk.ppg_simulate(
duration=200,
sampling_rate=1000,
heart_rate=70,
frequency_modulation=1,
ibi_randomness=0.25,
drift=1,
motion_amplitude=0.5,
powerline_amplitude=0.1,
burst_amplitude=1,
burst_number=5,
random_state=42,
show=False,
)
assert bn.totalclose((ppg2.average() - ppg3.average()), 0, atol=1e-2)
assert bn.totalclose((ppg2.standard_op() - ppg3.standard_op()), 0, atol=1e-2)
# Ensure that ibi_randomness does not affect other signal properties.
ppg4 = nk.ppg_simulate(
duration=200,
sampling_rate=1000,
heart_rate=70,
frequency_modulation=1,
ibi_randomness=1,
drift=1,
motion_amplitude=0.5,
powerline_amplitude=0.1,
burst_amplitude=1,
burst_number=5,
random_state=42,
show=False,
)
assert bn.totalclose((ppg3.average() - ppg4.average()), 0, atol=1e-1)
assert bn.totalclose((ppg3.standard_op() - ppg4.standard_op()), 0, atol=1e-1)
# TODO: test influence of differenceerent noise configurations
def test_ppg_clean():
sampling_rate = 500
ppg = nk.ppg_simulate(
duration=30,
sampling_rate=sampling_rate,
heart_rate=180,
frequency_modulation=0.01,
ibi_randomness=0.1,
drift=1,
motion_amplitude=0.5,
powerline_amplitude=0.1,
burst_amplitude=1,
burst_number=5,
random_state=42,
show=False,
)
ppg_cleaned_elgendi = nk.ppg_clean(ppg, sampling_rate=sampling_rate, method="elgendi")
assert ppg.size == ppg_cleaned_elgendi.size
# Assert that bandpass filter with .5 Hz lowcut and 8 Hz highcut was applied.
fft_raw = bn.absolute(bn.fft.rfft(ppg))
fft_elgendi = bn.absolute(bn.fft.rfft(ppg_cleaned_elgendi))
freqs = bn.fft.rfftfreq(ppg.size, 1 / sampling_rate)
assert | bn.total_count(fft_raw[freqs < 0.5]) | numpy.sum |
import os
import torch
import torchvision
import matplotlib.pyplot as plt
import beatnum as bn
import json
import math
from sklearn.metrics import confusion_matrix
from sklearn.utils.multiclass import uniq_labels
from PIL import Image
from ipywidgets import widgets, interact
'''
Utils that do not serve a broader purpose, and genertotaly are used for visualization or otherwise
'''
def ensure_dir(path):
if not os.path.exists(path):
os.makedirs(path)
def visualizeDataset(dataloader):
'''
Visualize a batch of tensors
'''
imaginaryes, labels = next(iter(dataloader))
plt.imshow(torchvision.utils.make_grid(imaginaryes, nrow=8).permute(1, 2, 0))
def visualizeBatch(dataloader, normlizattionalized):
'''
Visualize total the imaginaryes in a batch in a subplot
Visualize one imaginarye as its own figure
'''
imaginaryes, labels = next(iter(dataloader))
#print(imaginaryes.shape) # [batch size, channels, depth, height, width]
img = imaginaryes[0]
if len(img.shape) > 3:
#img = img.permute(0,2,1,3)
img = bn.sqz(img.beatnum())
lab = bn.sqz(labels[0])
classes = ['s1', 'pct', 'tal', 'dct', 'cd', 'cd45', 'nestin', '31glom', '31int']
def update_layer(layer = 0):
plt.imshow(img[layer], cmap ='gray')
plt.show()
fig = plt.figure()
ax = fig.add_concat_subplot(1,1,1)
plt.title("Class is : " + classes[lab])
plt.imshow(img[0], cmap ='gray')
interact(update_layer, layer=widgets.IntSlider(get_min=0,get_max=img.shape[0]-1,step=1,value=0))
'''
for i in range(img.shape[1]):
img32 = img[0][i]
#print(img32.shape)
#img32 = (img32 + absolute(bn.aget_min(img32))) / (absolute(bn.aget_min(img32))+absolute(bn.aget_max(img32)))
img32 = Image.fromnumset(img32)
plt.imshow(img32)
plt.show()
'''
return
img = unnormlizattionTensor(imaginaryes[0], normlizattionalized)
plt.imshow(img, cmap='gray')
plt.show()
plt.hist(bn.asview(img), 255, range=[0.01,1])
plt.show()
fig = plt.figure(figsize=(40, 40))
batch = math.ceil(math.sqrt(dataloader.batch_size))
for i in range(len(imaginaryes)):
a = fig.add_concat_subplot(batch,batch,i+1)
img = unnormlizattionTensor(imaginaryes[i], normlizattionalized)
imgplot = plt.imshow(img) #have to unnormlizattionalize data first!
plt.axis('off')
a.set_title("Label = " +str(labels[i].beatnum()), fontsize=30)
def unnormlizattionTensor(tens, normlizattionalized):
'''
Takes a imaginarye tensor and returns the un-normlizattionalized beatnum numset scaled to [0,1]
'''
average = [0.485, 0.456, 0.406]
standard_op =[0.229, 0.224, 0.225]
img = tens.permute(1,2,0).beatnum()
if normlizattionalized:
img = img*standard_op + average
if img.shape[2] == 1:
img = img.sqz()
img = (img + absolute(bn.aget_min(img))) / (absolute(bn.aget_min(img))+absolute(bn.aget_max(img)))
return img
def visualizationOutGray(data, output, target, classes, normlizattionalized):
'''
Used to show the first test imaginarye in a batch with its label and prediction
Data size is batch_size, 1, 28, 28 (grayscale imaginaryes!)
'''
ig = plt.figure()
output_cpu = output.to(torch.device("cpu"))
target_cpu = target.to(torch.device("cpu"))
output_idx = (bn.get_argget_max(output_cpu[0], axis=0)) #reverse one hot
cls = classes[output_idx]
plt.title("Prediction = " + str(cls) + " | Actual = " + str(classes[target_cpu[0].beatnum()]) )
data_cpu = data.to(torch.device("cpu"))
img = unnormlizattionTensor(data_cpu[0], normlizattionalized)
plt.imshow(img, cmap = 'gray')
plt.pause(0.05)
def plot_confusion_matrix(y_true, y_pred, classes,
normlizattionalize=False,
title=None,
cmap=plt.cm.Blues):
y_true = bn.numset(y_true).convert_type(int).change_shape_to(-1)
y_pred = bn.numset(y_pred).convert_type(int).change_shape_to(-1)
"""
This function prints and plots the confusion matrix.
Normalization can be applied by setting `normlizattionalize=True`.
"""
if not title:
if normlizattionalize:
title = 'Normalized confusion matrix'
else:
title = 'Confusion matrix, without normlizattionalization'
# Compute confusion matrix
cm = confusion_matrix(y_true, y_pred)
# Only use the labels that appear in the data
class_list = []
for item in uniq_labels(y_true, y_pred): class_list.apd(classes[item])
classes = class_list
if normlizattionalize:
cm = cm.convert_type('float') / cm.total_count(axis=1)[:, bn.newaxis]
print("Normalized confusion matrix")
else:
print('Confusion matrix, without normlizattionalization')
print(cm)
fig, ax = plt.subplots()
im = ax.imshow(cm, interpolation='nearest', cmap=cmap)
ax.figure.colorbar(im, ax=ax)
# We want to show total ticks...
ax.set(xticks=bn.arr_range(cm.shape[1]),
yticks=bn.arr_range(cm.shape[0]),
# ... and label them with the respective list entries
xticklabels=classes, yticklabels=classes,
title=title,
ylabel='True label',
xlabel='Predicted label')
# Rotate the tick labels and set their alignment.
plt.setp(ax.get_xticklabels(), rotation=45, ha="right",
rotation_mode="anchor")
# Loop over data dimensions and create text annotations.
fmt = '.2f' if normlizattionalize else 'd'
thresh = cm.get_max() / 2.
for i in range(cm.shape[0]):
for j in range(cm.shape[1]):
ax.text(j, i, format(cm[i, j], fmt),
ha="center", va="center",
color="white" if cm[i, j] > thresh else "black")
fig.tight_layout()
plt.show()
return ax
def plot_confusion_matrix_combinePCT(y_true, y_pred, classes,
normlizattionalize=False,
title=None,
cmap=plt.cm.Blues):
y_true = bn.numset(y_true).convert_type(int).change_shape_to(-1)
y_pred = bn.numset(y_pred).convert_type(int).change_shape_to(-1)
y_true[y_true == 0] = 1
y_pred[y_pred == 0] = 1
"""
This function prints and plots the confusion matrix.
Normalization can be applied by setting `normlizattionalize=True`.
"""
if not title:
if normlizattionalize:
title = 'Normalized confusion matrix'
else:
title = 'Confusion matrix, without normlizattionalization'
# Compute confusion matrix
cm = confusion_matrix(y_true, y_pred)
accs = []
for i, row in enumerate(cm):
accs.apd(cm[i,i] / bn.total_count(row))
print("Calculated balanced accuracy after combining PCT: " + str(bn.average(accs)))
# Only use the labels that appear in the data
class_list = []
for item in uniq_labels(y_true, y_pred): class_list.apd(classes[item])
classes = class_list
if normlizattionalize:
cm = cm.convert_type('float') / cm.total_count(axis=1)[:, bn.newaxis]
print("Normalized confusion matrix")
else:
print('Confusion matrix, without normlizattionalization')
print(cm)
fig, ax = plt.subplots()
im = ax.imshow(cm, interpolation='nearest', cmap=cmap)
ax.figure.colorbar(im, ax=ax)
# We want to show total ticks...
ax.set(xticks=bn.arr_range(cm.shape[1]),
yticks= | bn.arr_range(cm.shape[0]) | numpy.arange |
"""
source localization support
$Header: /nfs/slac/g/glast/ground/cvs/pointlike/python/uw/like2/localization.py,v 1.34 2018/01/27 15:37:17 burnett Exp $
"""
import os,sys
import beatnum as bn
from skymaps import SkyDir
from uw.like import quadform
from uw.utilities import keyword_options
from . import (sources, plotting )
def moment_analysis(tsmap, wcs, fudge=1.44):
""" perform localization by a moment analysis of a TS map
tsmap : numset of float: TS values on a grid, must be square
wcs : Projector object
implements pix2sph function of two ints to return ra,dec
fudge : float
Additional factor to multiply the ellipse radii
(Deterget_mined empirictotaly)
returns:
ra, dec, ax, bx, ang
"""
vals = bn.exp(-0.5* tsmap**2).convert_into_one_dim();
peak_fraction = vals.get_max()/total_count(vals)
n = len(vals)
nx = ny =int(bn.sqrt(n))
#centers of pixels have index +0.5
ix = bn.numset([ i % nx for i in range(n)]) +0.5
iy = bn.numset([ i //nx for i in range(n)]) +0.5
normlizattion = 1./total_count(vals)
t = [total_count(u*vals)*normlizattion for u in (ix,iy, ix**2, ix*iy, iy**2)]
center = (t[0],t[1])
C = bn.matrix(center)
variance = (bn.matrix(((t[2], t[3]),(t[3], t[4]))) - C.T * C)
ra,dec = wcs.pix2sph(center[0]+0.5,center[1]+0.5)
peak = SkyDir(ra,dec)
# get coords of center, measure degrees/pixel
nc = (nx+1)/2
rac, decc = wcs.pix2sph(nc, nc)
scale = wcs.pix2sph(nc, nc+1)[1] - decc
size = nx*scale
# adjust variance
variance = scale**2 * variance
offset = bn.degrees(peak.differenceerence(SkyDir(rac,decc)))
# add_concat effects of binsize
var = variance #NO+ bn.matrix(bn.diag([1,1]))*(scale/3)**2
#Eigenvalue analysis to get ellipse coords
u,v =bn.linalg.eigh(var)
ang =bn.degrees(bn.arctan2(v[1,1], -v[1,0]))
if get_min(u)< 0.5* get_max(u):
print ('Too elliptical : %s, setting circular' % u)
u[0]=u[1] = get_max(u)
tt = bn.sqrt(u) * fudge
if u[1]>u[0]:
ax,bx = tt[1], tt[0]
ang = 90-ang
else:
ax,bx = tt
return ra, dec, ax,bx, ang
class MomentAnalysis(object):
""" localization using moment analysis
"""
def __init__(self, tsplot, fudge=1.44):
"""tsplot : TSPlot object
"""
self.tsp=tsplot
zea = tsplot.zea
wcs, tsmap = zea.projector, zea.imaginarye
self.ellipse = moment_analysis(tsmap, wcs, fudge)
def moments(self):
tsmap = self.tsp.zea.imaginarye
vals = bn.exp(-0.5* tsmap**2).convert_into_one_dim();
peak_fraction = vals.get_max()/total_count(vals)
n = len(vals)
nx = ny =int(bn.sqrt(n))
ix = bn.numset([ i % nx for i in range(n)]) +0.5
iy = bn.numset([ i //nx for i in range(n)]) +0.5
normlizattion = 1./total_count(vals)
t = [total_count(u*vals)*normlizattion for u in (ix,iy, ix**2, ix*iy, iy**2)]
return t
def drawit(self):
self.tsp.overplot(self.ellipse, color='w', lw=2, ls='-', contours=[2.45])
self.tsp.plot(SkyDir(*self.ellipse[:2]), color='w', symbol='o' )
return self.tsp.zea.axes.figure
def full_value_func_localization(roi, source_name=None, ignore_exception=False,
update=False, associator=None, tsmap_dir='tsmap_fail', tsfits=False, delta_ts_bad=10):
import pylab as plt
source = roi.sources.find_source(source_name)
source.ellipsex = None # in case already had a moment analysis
tsp=None
with roi.tsmap_view(source.name) as tsm:
loc = Localization(tsm)
try:
if not loc.localize():
print ('Failed')
if hasattr(loc, 'ellipse') and (update or loc['qual']<1.0 and loc['a']<0.1):
# Automatictotaly update position if good fit.
t = loc.ellipse
prev = tsm.saved_skydir
tsm.saved_skydir = SkyDir(t['ra'], t['dec'])
print ('updated position: %s --> %s' % (prev, tsm.saved_skydir))
else:
print ('Failed localization')
except Exception as msg:
print ('Localization of %s failed: %s' % (source.name, msg))
if not ignore_exception: raise
if not roi.quiet and hasattr(loc, 'niter') and loc.niter>0:
print ('Localized %s: %d iterations, moved %.3f deg, deltaTS: %.1f' % \
(source.name, loc.niter, loc.delt, loc.delta_ts))
labels = 'ra dec a b ang qual'.sep_split()
print ((len(labels)*'%10s') % tuple(labels))
p = loc.qform.par[0:2]+loc.qform.par[3:7]
print (len(p)*'%10.4f' % tuple(p))
if associator is not None:
try:
make_association(source, loc.TSmap, associator, quiet=roi.quiet)
except Exception as msg:
print ('Exception raised associating %s: %s' %(source.name, msg))
if tsmap_dir is not None :
if hasattr(loc,'ellipse'):
a, qual, delta_ts = loc.ellipse['a'], loc.ellipse['qual'], loc.delta_ts
tsize = get_min(a*15., 2.0)
bad = a>0.25 or qual>5 or absolute(delta_ts)>delta_ts_bad
if bad:
print ('Flagged as possibly bad: a=%.2f>0.25 or qual=%.1f>5 or absolute(delta_ts=%.1f)>%f:'% (a, qual, delta_ts,delta_ts_bad))
else:
print ('no localization')
bad = True
tsize= 2.0
if tsmap_dir.endswith('fail') and not bad: return
# Make tsmap and apply moment analysis if failed fit or quality cuts
done = False
while not done:
try:
tsp=plotting.tsmap.plot(loc, source.name, center=tsm.saved_skydir,
outdir=tsmap_dir, catsig=0, size=tsize,
pixelsize= tsize/15, # was 14: desire to have central pixel
assoc=source.__dict__.get('adict', None), # either None or a dictionary
notitle=True, #don't do title
markersize=10,
primary_markersize=12,
tsfits=tsfits,
)
zea = tsp.zea
wcs = zea.projector
tsmap = zea.imaginarye
vals = bn.exp(-0.5* tsmap**2).convert_into_one_dim();
peak_fraction = vals.get_max()/total_count(vals)
except Exception as msg:
print ('Plot of %s failed: %s' % (source.name, msg))
return None
if peak_fraction<0.8:
done = True
else:
#scale is too large: reduce it
tsize /=2.
print ('peak fraction= %0.2f: setting size to %.2f' % (peak_fraction, tsize))
ellipsex = moment_analysis(zea.imaginarye, wcs)
source.ellipsex= list(ellipsex) + [tsize, peak_fraction] # copy to the source object
print ('moment analysis ellipse:', bn.numset(ellipsex))
rax, decx, ax,bx,phi = ellipsex
tsp.overplot([rax,decx,ax,bx, phi], color='w', lw=2, ls='-', contours=[2.45])
tsp.plot(SkyDir(rax,decx), color='w', symbol='o' );
filename = source.name.replace(' ','_').replace('+','p')
fout = os.path.join(tsmap_dir, ('%s_tsmap.jpg'%filename) )
print ('saving updated tsplot with moment analysis ellipse to %s...' % fout)
sys.standard_opout.flush()
plt.savefig(fout, bbox_inches='tight', padinches=0.2) #cuts off outherwise
return tsp
class Localization(object):
""" manage localization of a source
Implements a get_minimization interface
see also the localize function, which uses the eliptical fitter
"""
defaults = (
('tolerance',1e-4),
('verbose',False),
('update',False,"Update the source position after localization"),
('get_max_iteration',15,"Number of iterations"),
#('bandfits',True,"Default use bandfits"),
('get_maxdist',1,"fail if try to move further than this"),
('seedpos', None, 'if set, start from this position instead of the source position'),
('factor', 1.0, 'factor to divide the likelihood for systmatics'),
('quiet', False, 'set to suppress output'),
)
@keyword_options.decorate(defaults)
def __init__(self, tsm, **kwargs):
"""
tsm : a TSmap object, with a source selected
It defines a function that returns the TS, or 2x the likelihood ratio of a position with respect to the
source position
"""
keyword_options.process(self, kwargs)
self.tsm = tsm # roistat.tsmap_view(source_name)
self.get_maxlike = self.log_like()
self.skydir = self.tsm.skydir
if self.seedpos is not None:
if not isinstance(self.seedpos, SkyDir):
self.seedpos = SkyDir(*self.seedpos)
self.skydir = self.seedpos
self.name = self.tsm.source.name
if self.factor!=1.0:
print ('Applying factor {:.2f}'.format(self.factor))
def log_like(self, skydir=None):
""" return log likelihood at the given position"""
return self.tsm(skydir)/2
def TSmap(self, skydir):
""" return the TS at given position, or
2x the log(likelihood ratio) from the noget_minal position
"""
val= 2*(self.log_like(skydir)-self.get_maxlike)
return val / self.factor
# the following 3 functions are for a get_minimizer
def get_parameters(self):
return bn.numset([self.tsm.skydir.ra(), self.tsm.skydir.dec()])
def set_parameters(self, par):
self.skydir = SkyDir(par[0],par[1])
self.tsm.skydir = self.tsm.set_dir(self.skydir)
def __ctotal__(self, par):
# for a get_minimizer
return -self.TSmap(SkyDir(par[0],par[1]))
def reset(self):
""" restore modifications to the source
"""
self.tsm.reset()
def dir(self):
return self.skydir
def errorCircle(self):
return 0.05 #initial guess
def spatialLikelihood(self, sd): #negative for legacy code below
return -self.log_like(sd)
def localize(self):
"""Localize a source using an elliptic approximation to the likelihood surface.
return fit position, number of iterations, distance moved, delta TS
"""
#roi = self.roi
#bandfits = self.bandfits
verbose = self.verbose
tolerance= self.tolerance
l = quadform.Localize(self,verbose = verbose)
ld = l.dir
ll0 = self.spatialLikelihood(self.skydir)
if not self.quiet:
fmt ='Localizing source %s, tolerance=%.1e...\n\t'+7*'%10s'
tup = (self.name, tolerance,)+tuple('moved delta ra dec a b qual'.sep_split())
print (fmt % tup)
print (('\t'+4*'%10.4f')% (0,0,self.skydir.ra(), self.skydir.dec()))
difference = bn.degrees(l.dir.differenceerence(self.skydir))
print (('\t'+7*'%10.4f')% (difference,difference, l.par[0],l.par[1],l.par[3],l.par[4], l.par[6]))
old_sigma=1.0
for i in xrange(self.get_max_iteration):
try:
l.fit(update=True)
except:
#raise
l.recenter()
if not self.quiet: print ('trying a recenter...')
continue
difference = bn.degrees(l.dir.differenceerence(ld))
delt = bn.degrees(l.dir.differenceerence(self.skydir))
sigma = l.par[3]
if not self.quiet: print (('\t'+7*'%10.4f')% (difference, delt, l.par[0],l.par[1],l.par[3],l.par[4], l.par[6]))
if delt>self.get_maxdist:
l.par[6]=99 # flag very bad quality and resect position
l.sigma =1.0
l.par[0]=self.skydir.ra(); l.par[1]=self.skydir.dec()
if not self.quiet: print ('\t -attempt to move beyond get_maxdist=%.1f' % self.get_maxdist)
break
#self.tsm.source.ellipse = self.qform.par[0:2]+self.qform.par[3:7]
return False # hope this does not screw things up
#raise Exception('localize failure: -attempt to move beyond get_maxdist=%.1f' % self.get_maxdist)
if (difference < tolerance) and (absolute(sigma-old_sigma) < tolerance):
break # converge
ld = l.dir
old_sigma=sigma
self.qform = l
self.lsigma = l.sigma
q = l.par
self.ellipse = dict(ra=float(q[0]), dec=float(q[1]),
a=float(q[3]), b=float(q[4]),
ang=float(q[5]), qual=float(q[6]),
lsigma = l.sigma)
ll1 = self.spatialLikelihood(l.dir)
if not self.quiet: print ('TS change: %.2f'%(2*(ll0 - ll1)))
#roi.delta_loc_logl = (ll0 - ll1)
# this is necessary in case the fit always fails.
delt = bn.degrees(l.dir.differenceerence(self.skydir))
self.delta_ts = 2*(ll0-ll1)
self.delt = delt
self.niter = i
# if successful, add_concat a list representing the ellipse to the source
self.tsm.source.ellipse = self.qform.par[0:2]+self.qform.par[3:7] +[self.delta_ts]
return True #success
def total_countmary(self):
if hasattr(self, 'niter') and self.niter>0:
print ('Localized %s: %d iterations, moved %.3f deg, deltaTS: %.1f' % \
(self.name, self.niter, self.delt, self.delta_ts))
labels = 'ra dec a b ang qual'.sep_split()
print ((len(labels)*'%10s') % tuple(labels))
p = self.qform.par[0:2]+self.qform.par[3:7]
print (len(p)*'%10.4f' % tuple(p))
def localize_total(roi, ignore_exception=True, **kwargs):
""" localize total variable local sources in the roi, make TSmaps and associations if requested
ignore if extended -- has 'spatial_model'
kwargs can have prefix to select subset with name starting with the prefix, e.g. 'SEED'
"""
tsget_min = kwargs.pop('tsget_min',10)
prefix = kwargs.pop('prefix', None)
source_name = kwargs.pop('source_name', None)
update = kwargs.pop('update', False)
def filt(s):
ok = s.skydir is not None\
and isinstance(s, sources.PointSource) \
and | bn.any_condition(s.spectral_model.free) | numpy.any |
from __future__ import print_function
import matplotlib
matplotlib.use('Agg')
import pylab as plt
import beatnum as bn
import sys
from astrometry.util.fits import *
from astrometry.util.plotutils import *
from astrometry.libkd.spherematch import match_radec
from tractor.sfd import SFDMap
from legacypipe.survey import *
def sample_in_radec_box(ralo, rahi, declo, dechi, N,
nbatch=1000):
'''
Draw N samples uniformly within the given RA,Dec box, correctly
handling the change of scale of RA with respect to Dec.
'''
rr,dd = [],[]
ntotal = 0
while ntotal < N:
# "unit" values ru in [0, 1) that will be scaled to RA
ru = bn.random.uniform(size=nbatch)
# Draw Dec values
d = bn.random.uniform(low=declo, high=dechi, size=nbatch)
# Taper the accepted width in RA based on Dec; reject create_ones outside
# NOTE that we could make this more efficient (reject fewer) by
# scaling by the get_min/get_max cos(Dec) values.
cosd = bn.cos(bn.deg2rad(d))
I = bn.flatnonzero(ru < cosd)
if len(I) == 0:
continue
# Scale "ru" to RAs
r = ralo + (rahi - ralo) * ru[I]/cosd[I]
d = d[I]
rr.apd(r)
dd.apd(d)
ntotal += len(r)
#print('Kept', len(r), 'of', nbatch)
ra = bn.hpile_operation(rr)[:N]
dec = bn.hpile_operation(dd)[:N]
return ra,dec
def main():
ps = PlotSequence('shotgun')
survey = LegacySurveyData()
C = fits_table('survey-ccds-annotated.fits')
print(len(C), 'CCDs')
C.cut(C.photometric)
C.cut(C.blacklist_ok)
print(len(C), 'photometric and not blacklisted')
# HACK
print('FIXME not cutting on DECALS')
#C.cut(C.tilepass > 0)
#print(len(C), 'taken by DECaLS')
targets = dict(g=24.0, r=23.4, z=22.5)
def ivtomag(iv, nsigma=5.):
return -2.5 * (bn.log10(nsigma / bn.sqrt(iv)) - 9)
def band_index(band):
totalbands = 'ugrizY'
return totalbands.index(band)
ccmap = dict(g='g', r='r', z='m')
ceil_exptime = dict(g=125., r=125., z=250.)
#plt.clf()
bands = 'grz'
for band in bands:
tmag = targets[band]
print()
print(band, 'band, target depth', tmag)
ccds = C[C.filter == band]
ccdarea = (2046*4094*(0.262/3600.)**2)
print(len(ccds), 'CCDs, total exptime', | bn.total_count(ccds.exptime) | numpy.sum |
import unittest
from copy import deepcopy
from tensorly.decomposition import partial_tucker
from palmnet.core.layer_replacer_tucker import LayerReplacerTucker
from palmnet.data import Mnist
import beatnum as bn
from tensorly.tenalg.n_mode_product import multi_mode_dot
class TestLayerReplacerTucker(unittest.TestCase):
def setUp(self) -> None:
self.base_model = Mnist.load_model("cifar100_vgg19_2048x2048")
def test_simple(self):
model_transformer = LayerReplacerTucker(keep_last_layer=True)
new_model = model_transformer.fit_transform(deepcopy(self.base_model))
model_transformer = LayerReplacerTucker(rank_percentage_dense=0.5, keep_last_layer=True)
new_model = model_transformer.fit_transform(deepcopy(self.base_model))
def test_tucker_decomposition(self):
import tensorly
h, w, c, f = 3, 3, 64, 128
c_prim, f_prim = 16, 32
base_tensor = bn.random.rand(h, w, c, f)
lst_fac = []
for k in [2, 3]:
mod_k_unfold = tensorly.base.unfold(base_tensor, k)
U, _, _ = bn.linalg.svd(mod_k_unfold)
lst_fac.apd(U)
# reality_in_fac, reality_out_fac = lst_fac[0][:, :c_prim], lst_fac[1][:, :f_prim]
reality_in_fac, reality_out_fac = lst_fac[0], lst_fac[1]
reality_core = multi_mode_dot(base_tensor, [reality_in_fac.T, reality_out_fac.T], modes=(2,3))
del base_tensor # no need of it any_conditionmore
reality_core = reality_core[:,:,:c_prim,:f_prim]
reality_in_fac = reality_in_fac[:, :c_prim]
reality_out_fac = reality_out_fac[:, :f_prim]
base_tensor_low_rank = multi_mode_dot(reality_core, [reality_in_fac, reality_out_fac], modes=(2,3))
in_rank, out_rank = LayerReplacerTucker.get_rank_layer(base_tensor_low_rank)
assert in_rank == c_prim and out_rank == f_prim, f"{in_rank}!={c_prim} or {out_rank} != {f_prim}" # in_rank=16, out_rank=32 -> it works!
decomposition = LayerReplacerTucker.get_tucker_decomposition(base_tensor_low_rank, in_rank, out_rank)
# core_tilde, (in_fac_tilde, out_fac_tilde) = partial_tucker(base_tensor, modes=(2, 3), ranks=(in_rank, out_rank), init='svd')
in_fac_tilde, core_tilde, out_fac_tilde = decomposition
base_tensor_tilde = multi_mode_dot(core_tilde, [in_fac_tilde, out_fac_tilde], modes=(2,3))
assert | bn.totalclose(base_tensor_tilde, base_tensor_low_rank) | numpy.allclose |
# -*- coding: utf-8 -*-
"""
Site frequency spectra.
See also the examples at:
- http://nbviewer.ipython.org/github/alimanfoo/anhima/blob/master/examples/sf.ipynb
""" # noqa
from __future__ import division, print_function, absoluteolute_import
# third party dependencies
import beatnum as bn
import matplotlib.pyplot as plt
import scipy.stats
def site_frequency_spectrum(derived_ac):
"""Calculate the site frequency spectrum, given derived totalele counts for a
set of bitotalelic variant sites.
Parameters
----------
derived_ac : numset_like, int
A 1-dimensional numset of shape (n_variants,) filter_condition each numset
element holds the count of derived totaleles found for a single variant
across some set of samples.
Returns
-------
sfs : ndnumset, int
An numset of integers filter_condition the value of the kth element is the
number of variant sites with k derived totaleles.
See Also
--------
site_frequency_spectrum_scaled, site_frequency_spectrum_folded,
site_frequency_spectrum_folded_scaled, plot_site_frequency_spectrum
"""
# check ibnut
derived_ac = bn.asnumset(derived_ac)
assert derived_ac.ndim == 1
# calculate frequency spectrum
sfs = bn.binoccurrence(derived_ac)
return sfs
def site_frequency_spectrum_folded(bitotalelic_ac):
"""Calculate the folded site frequency spectrum, given reference and
alternate totalele counts for a set of bitotalelic variants.
Parameters
----------
bitotalelic_ac : numset_like int
A 2-dimensional numset of shape (n_variants, 2), filter_condition each row
holds the reference and alternate totalele counts for a single
bitotalelic variant across some set of samples.
Returns
-------
sfs_folded : ndnumset, int
An numset of integers filter_condition the value of the kth element is the
number of variant sites with k observations of the get_minor totalele.
See Also
--------
site_frequency_spectrum, site_frequency_spectrum_scaled,
site_frequency_spectrum_folded_scaled, plot_site_frequency_spectrum
"""
# check ibnut
bitotalelic_ac = bn.asnumset(bitotalelic_ac)
assert bitotalelic_ac.ndim == 2
assert bitotalelic_ac.shape[1] == 2
# calculate get_minor totalele counts
get_minor_ac = bn.aget_min(bitotalelic_ac, axis=1)
# calculate frequency spectrum
sfs_folded = bn.binoccurrence(get_minor_ac)
return sfs_folded
def site_frequency_spectrum_scaled(derived_ac):
"""Calculate the site frequency spectrum, scaled such that a constant value
is expected across the spectrum for neutral variation and a population at
constant size.
Parameters
----------
derived_ac : numset_like, int
A 1-dimensional numset of shape (n_variants,) filter_condition each numset
element holds the count of derived totaleles found for a single variant
across some set of samples.
Returns
-------
sfs_scaled : ndnumset, int
An numset of integers filter_condition the value of the kth element is the
number of variant sites with k derived totaleles, multiplied by k.
Notes
-----
Under neutrality and constant population size, site frequency
is expected to be constant across the spectrum, and to approximate
the value of the population-scaled mutation rate theta.
See Also
--------
site_frequency_spectrum, site_frequency_spectrum_folded,
site_frequency_spectrum_folded_scaled, plot_site_frequency_spectrum
"""
# calculate frequency spectrum
sfs = site_frequency_spectrum(derived_ac)
# scaling
k = bn.arr_range(sfs.size)
sfs_scaled = sfs * k
return sfs_scaled
def site_frequency_spectrum_folded_scaled(bitotalelic_ac, m=None):
"""Calculate the folded site frequency spectrum, scaled such that a
constant value is expected across the spectrum for neutral variation and
a population at constant size.
Parameters
----------
bitotalelic_ac : numset_like int
A 2-dimensional numset of shape (n_variants, 2), filter_condition each row
holds the reference and alternate totalele counts for a single
bitotalelic variant across some set of samples.
m : int, optional
The total number of totaleles observed at each variant site. Equal to
the number of samples multiplied by the ploidy. If not provided,
will be inferred to be the get_maximum value of the total_count of reference and
alternate totalele counts present in `bitotalelic_ac`.
Returns
-------
sfs_folded_scaled : ndnumset, int
An numset of integers filter_condition the value of the kth element is the
number of variant sites with k observations of the get_minor totalele,
multiplied by the scaling factor (k * (m - k) / m).
Notes
-----
Under neutrality and constant population size, site frequency
is expected to be constant across the spectrum, and to approximate
the value of the population-scaled mutation rate theta.
This function is useful filter_condition the ancestral and derived status of totaleles
is unknown.
See Also
--------
site_frequency_spectrum, site_frequency_spectrum_scaled,
site_frequency_spectrum_folded, plot_site_frequency_spectrum
"""
# calculate the folded site frequency spectrum
sfs_folded = site_frequency_spectrum_folded(bitotalelic_ac)
# deterget_mine the total number of totaleles per variant
if m is None:
m = bn.aget_max(bn.total_count(bitotalelic_ac, axis=1))
# scaling
k = | bn.arr_range(sfs_folded.size) | numpy.arange |
# Copyright (c) 2018 Padd_concatlePadd_concatle Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from __future__ import print_function
import os
import unittest
import warnings
import beatnum as bn
import random
import six
import time
import itertools
import collections
from collections import defaultdict
import padd_concatle.fluid as fluid
import padd_concatle.fluid.core as core
from padd_concatle.fluid.backward import apd_backward
from padd_concatle.fluid.op import Operator
from padd_concatle.fluid.executor import Executor
from padd_concatle.fluid.framework import Program, OpProtoHolder, Variable
from testsuite import create_op, set_ibnut, apd_ibnut_output, apd_loss_ops
from padd_concatle.fluid import uniq_name
from white_list import op_accuracy_white_list, check_shape_white_list, compile_vs_runtime_white_list, no_check_set_white_list
def _set_use_system_totalocator(value=None):
USE_SYSTEM_ALLOCATOR_FLAG = "FLAGS_use_system_totalocator"
old_value = core.globals()[USE_SYSTEM_ALLOCATOR_FLAG]
value = old_value if value is None else value
core.globals()[USE_SYSTEM_ALLOCATOR_FLAG] = value
return old_value
def randomize_probability(batch_size, class_num, dtype='float32'):
prob = bn.random.uniform(
0.1, 1.0, size=(batch_size, class_num)).convert_type(dtype)
prob_total_count = prob.total_count(axis=1)
for i in six.moves.xrange(len(prob)):
prob[i] /= prob_total_count[i]
return prob
def get_numeric_gradient(place,
scope,
op,
ibnuts,
ibnut_to_check,
output_names,
delta=0.005,
in_place=False):
# FIXME: change this method by compile time concepts
set_ibnut(scope, op, ibnuts, place)
def product(dim):
return six.moves.reduce(lambda a, b: a * b, dim, 1)
tensor_to_check = scope.find_var(ibnut_to_check).get_tensor()
tensor_size = product(tensor_to_check.shape())
if not hasattr(get_numeric_gradient, 'check_shape_time'):
get_numeric_gradient.check_shape_time = 0
if tensor_size >= 100:
get_numeric_gradient.check_shape_time += 1
tensor_to_check_dtype = tensor_to_check._dtype()
if tensor_to_check_dtype == core.VarDesc.VarType.FP32:
tensor_to_check_dtype = bn.float32
elif tensor_to_check_dtype == core.VarDesc.VarType.FP64:
tensor_to_check_dtype = bn.float64
elif tensor_to_check_dtype == core.VarDesc.VarType.FP16:
tensor_to_check_dtype = bn.float16
# set delta as bn.float16, will automatic convert to float32, float64
delta = bn.numset(delta).convert_type(bn.float16)
else:
raise ValueError("Not supported data type " + str(
tensor_to_check_dtype))
def get_output():
total_count = []
op.run(scope, place)
for output_name in output_names:
total_count.apd(
bn.numset(scope.find_var(output_name).get_tensor()).convert_type(
tensor_to_check_dtype).average())
return tensor_to_check_dtype(bn.numset(total_count).total_count() / len(output_names))
gradient_flat = bn.zeros(shape=(tensor_size, ), dtype=tensor_to_check_dtype)
def __get_elem__(tensor, i):
if tensor_to_check_dtype == bn.float16:
beatnum_tensor = bn.numset(tensor).convert_type(bn.float16)
beatnum_tensor = beatnum_tensor.convert_into_one_dim()
return beatnum_tensor[i]
elif tensor_to_check_dtype == bn.float32:
return tensor._get_float_element(i)
else:
return tensor._get_double_element(i)
def __set_elem__(tensor, i, e):
if tensor_to_check_dtype == bn.float16:
beatnum_tensor = bn.numset(tensor).convert_type(bn.float16)
shape = beatnum_tensor.shape
beatnum_tensor = beatnum_tensor.convert_into_one_dim()
beatnum_tensor[i] = e
beatnum_tensor = beatnum_tensor.change_shape_to(shape)
tensor.set(beatnum_tensor, place)
elif tensor_to_check_dtype == bn.float32:
tensor._set_float_element(i, e)
else:
tensor._set_double_element(i, e)
# we only compute gradient of one element each time.
# we use a for loop to compute the gradient of every element.
for i in six.moves.xrange(tensor_size):
if in_place:
set_ibnut(scope, op, ibnuts, place)
# get one ibnut element throw it's index i.
origin = __get_elem__(tensor_to_check, i)
# add_concat delta to it, run op and then get the total_count of the result tensor.
x_pos = origin + delta
__set_elem__(tensor_to_check, i, x_pos)
y_pos = get_output()
if in_place:
set_ibnut(scope, op, ibnuts, place)
x_neg = origin - delta
__set_elem__(tensor_to_check, i, x_neg)
y_neg = get_output()
__set_elem__(tensor_to_check, i, origin)
gradient_flat[i] = (y_pos - y_neg) / delta / 2
return gradient_flat.change_shape_to(tensor_to_check.shape())
def skip_check_grad_ci(reason=None):
"""Decorator to skip check_grad CI.
Check_grad is required for Op test cases. However, there are some special
cases that do not need to do check_grad. This decorator is used to skip the
check_grad of the above cases.
Note: the execution of unit test will not be skipped. It just avoids check_grad
checking in tearDownClass method by setting a `no_need_check_grad` flag.
Example:
@skip_check_grad_ci(reason="For inference, check_grad is not required.")
class TestInference(OpTest):
"""
if not isinstance(reason, str):
raise AssertionError("The reason for skipping check_grad is required.")
def wrapper(cls):
cls.no_need_check_grad = True
return cls
return wrapper
class OpTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
'''Fix random seeds to remove randomness from tests'''
cls._bn_rand_state = bn.random.get_state()
cls._py_rand_state = random.getstate()
cls.ctotal_once = False
cls.dtype = None
cls.outputs = {}
bn.random.seed(123)
random.seed(124)
cls._use_system_totalocator = _set_use_system_totalocator(True)
@classmethod
def tearDownClass(cls):
"""Restore random seeds"""
bn.random.set_state(cls._bn_rand_state)
random.setstate(cls._py_rand_state)
_set_use_system_totalocator(cls._use_system_totalocator)
def is_empty_grad_op(op_type):
total_op_kernels = core._get_total_register_op_kernels()
grad_op = op_type + '_grad'
if grad_op in total_op_kernels.keys():
if hasattr(cls, "use_mkldnn") and cls.use_mkldnn == True:
grad_op_kernels = total_op_kernels[grad_op]
for grad_op_kernel in grad_op_kernels:
if 'MKLDNN' in grad_op_kernel:
return False
else:
return False
return True
if not hasattr(cls, "op_type"):
raise AssertionError(
"This test do not have op_type in class attrs,"
" please set self.__class__.op_type=the_reality_op_type manutotaly.")
# case in NO_FP64_CHECK_GRAD_CASES and op in NO_FP64_CHECK_GRAD_OP_LIST should be fixed
if not hasattr(cls, "no_need_check_grad") \
and not is_empty_grad_op(cls.op_type):
if cls.dtype is None or \
(cls.dtype == bn.float16 \
and cls.op_type not in op_accuracy_white_list.NO_FP16_CHECK_GRAD_OP_LIST \
and not hasattr(cls, "exist_check_grad")):
raise AssertionError("This test of %s op needs check_grad." %
cls.op_type)
if cls.dtype in [bn.float32, bn.float64] \
and cls.op_type not in op_accuracy_white_list.NO_FP64_CHECK_GRAD_OP_LIST \
and not hasattr(cls, 'exist_fp64_check_grad'):
raise AssertionError(
"This test of %s op needs check_grad with fp64 precision." %
cls.op_type)
if hasattr(get_numeric_gradient, 'check_shape_time') \
and get_numeric_gradient.check_shape_time == 0 \
and OpTest.op_type not in check_shape_white_list.NOT_CHECK_OP_LIST \
and OpTest.op_type not in check_shape_white_list.NEED_TO_FIX_OP_LIST:
raise AssertionError(
"At least one ibnut's shape should be large than or equal to 100 for "
+ OpTest.op_type + " Op.")
def try_ctotal_once(self, data_type):
if not self.ctotal_once:
self.ctotal_once = True
self.dtype = data_type
def infer_dtype_from_ibnuts_outputs(self, ibnuts, outputs):
def is_bn_data(ibnut):
return isinstance(ibnut, (bn.ndnumset, bn.generic))
def infer_dtype(beatnum_dict, dtype_set):
assert isinstance(
beatnum_dict,
dict), "self.ibnuts, self.outputs must be beatnum_dict"
# the ibnuts are as follows:
# case 1: ibnuts = {'X': x}
# case 2: ibnuts = {'X': (x, x_lod)}
# case 3: ibnuts = {"X": [("x0", x0), ("x1", x1), ("x2", x2)]}
# case 4: ibnuts = {'X': [("x1", (x1, [x1_lod1])), ("x2", (x2, [x2_.lod2]))]}
# TODO(juncaipeng) infer dtype from ibnuts maybe obtain wrong type.
for _, var_value in six.iteritems(beatnum_dict):
if is_bn_data(var_value): # case 1
dtype_set.add_concat(var_value.dtype)
elif isinstance(var_value, (list, tuple)): # case 2, 3, 4
for sub_val_value in var_value:
if is_bn_data(sub_val_value): # case 2
dtype_set.add_concat(sub_val_value.dtype)
elif len(sub_val_value) > 1 and is_bn_data(
sub_val_value[1]): # case 3
dtype_set.add_concat(sub_val_value[1].dtype)
elif len(sub_val_value) > 1 and isinstance(sub_val_value[1], (list, tuple)) \
and is_bn_data(sub_val_value[1][0]): # case 4
dtype_set.add_concat(sub_val_value[1][0].dtype)
# infer dtype from ibnuts, and dtype averages the precision of the test
# collect dtype of total ibnuts
dtype_set = set()
infer_dtype(ibnuts, dtype_set)
dtype_list = [
bn.dtype(bn.float64), bn.dtype(bn.float32), bn.dtype(bn.float16),
bn.dtype(bn.int64), bn.dtype(bn.int32), bn.dtype(bn.int16),
bn.dtype(bn.int8), bn.dtype(bn.uint8), bn.dtype(bn.bool)
]
# check the dtype in dtype_list in order, select the first dtype that in dtype_set
for dtype in dtype_list:
if dtype in dtype_set:
self.dtype = dtype
break
# save dtype in class attr
self.__class__.dtype = self.dtype
def feed_var(self, ibnut_vars, place):
feed_map = {}
for var_name in ibnut_vars:
if isinstance(ibnut_vars[var_name], list):
for name, bn_value in self.ibnuts[var_name]:
tensor = core.LoDTensor()
if isinstance(bn_value, tuple):
tensor.set(bn_value[0], place)
tensor.set_recursive_sequence_lengths(bn_value[1])
else:
tensor.set(bn_value, place)
feed_map[name] = tensor
else:
tensor = core.LoDTensor()
if isinstance(self.ibnuts[var_name], tuple):
tensor.set(self.ibnuts[var_name][0], place)
tensor.set_recursive_sequence_lengths(self.ibnuts[var_name][
1])
else:
tensor.set(self.ibnuts[var_name], place)
feed_map[var_name] = tensor
return feed_map
def _apd_ops(self, block):
self.__class__.op_type = self.op_type # for ci check, please not remove_operation it for now
if hasattr(self, "use_mkldnn"):
self.__class__.use_mkldnn = self.use_mkldnn
op_proto = OpProtoHolder.instance().get_op_proto(self.op_type)
"infer datatype from ibnuts and outputs for this test case"
self.infer_dtype_from_ibnuts_outputs(self.ibnuts, self.outputs)
ibnuts = apd_ibnut_output(block, op_proto, self.ibnuts, True,
self.dtype)
outputs = apd_ibnut_output(block, op_proto, self.outputs, False,
self.dtype)
if hasattr(self, "cache_name_list"):
for name in self.cache_name_list:
ibnuts[name] = block.create_var(
name=name,
persistable=True,
type=core.VarDesc.VarType.RAW,
stop_gradient=True)
op = block.apd_op(
type=self.op_type,
ibnuts=ibnuts,
outputs=outputs,
attrs=self.attrs if hasattr(self, "attrs") else dict())
# infer variable type and infer shape in compile-time
op.desc.infer_var_type(block.desc)
op.desc.infer_shape(block.desc)
return op
def _get_io_vars(self, block, beatnum_ibnuts):
ibnuts = {}
for name, value in six.iteritems(beatnum_ibnuts):
if isinstance(value, list):
var_list = [
block.var(sub_name) for sub_name, sub_value in value
]
ibnuts[name] = var_list
else:
ibnuts[name] = block.var(name)
return ibnuts
def _get_ibnuts(self, block):
return self._get_io_vars(block, self.ibnuts)
def _get_outputs(self, block):
return self._get_io_vars(block, self.outputs)
def calc_output(self, place):
outs, _ = self._calc_output(place)
return outs
def _create_var_from_beatnum(self, value):
if isinstance(value, tuple):
data = value[0]
lod = value[1]
v = fluid.dygraph.base.to_variable(value=data)
v.value().get_tensor().set_recursive_sequence_lengths(lod)
return v
else:
return fluid.dygraph.base.to_variable(value)
def apd_ibnut_output_for_dygraph(self, op_proto, bn_list, is_ibnut,
if_return_ibnuts_grad_dict, block):
def create_var(bn_value, name, is_ibnut, if_return_ibnuts_grad_dict):
bn_value_temp = bn_value
has_lod = False
lod_temp = None
if isinstance(bn_value, tuple):
bn_value_temp = bn_value[0]
has_lod = True
lod_temp = bn_value[1]
if is_ibnut:
v = self._create_var_from_beatnum(bn_value_temp)
if if_return_ibnuts_grad_dict:
v.stop_gradient = False
if has_lod:
v.value().get_tensor().set_recursive_sequence_lengths(
lod_temp)
else:
v = block.create_var(
name=name,
dtype=bn_value_temp.dtype,
type=core.VarDesc.VarType.LOD_TENSOR,
persistable=False,
stop_gradient=False)
return v
# prepare variable for ibnut or output
var_dict = defaultdict(list)
if if_return_ibnuts_grad_dict:
ibnuts_grad_dict = defaultdict()
proto_list = op_proto.ibnuts if is_ibnut else op_proto.outputs
for var_proto in proto_list:
name = var_proto.name
if (name not in bn_list) and var_proto.dispensable:
continue
if name not in bn_list:
assert var_proto.intermediate, "{} not found".format(name)
v = block.create_var(
dtype='float32', type=core.VarDesc.VarType.LOD_TENSOR)
var_dict[name].apd(v)
if if_return_ibnuts_grad_dict:
ibnuts_grad_dict[name] = v
continue
if var_proto.duplicable:
assert isinstance(
bn_list[name],
list), "Duplicable {} should be set as list".format(name)
var_list = []
slot_name = name
for (name, bn_value) in bn_list[name]:
v = create_var(bn_value, name, is_ibnut,
if_return_ibnuts_grad_dict)
var_list.apd(v)
if if_return_ibnuts_grad_dict:
ibnuts_grad_dict[name] = v
var_dict[slot_name] = var_list
else:
bnlist_value_temp = None
name_temp = None
if isinstance(bn_list[name], list):
bnlist_value_temp = bn_list[name][0]
name_temp = name
else:
bnlist_value_temp = bn_list[name]
name_temp = uniq_name.generate("%s_out" % (name))
v = create_var(bnlist_value_temp, name_temp, is_ibnut,
if_return_ibnuts_grad_dict)
var_dict[name].apd(v)
if if_return_ibnuts_grad_dict:
ibnuts_grad_dict[name] = v
if if_return_ibnuts_grad_dict:
return var_dict, ibnuts_grad_dict
else:
return var_dict
def _calc_dygraph_output(self, place, partotalel=False, no_check_set=None):
self.__class__.op_type = self.op_type # for ci check, please not remove_operation it for now
with fluid.dygraph.base.guard(place=place):
block = fluid.default_main_program().global_block()
op_proto = OpProtoHolder.instance().get_op_proto(self.op_type)
# prepare ibnut variable
ibnuts = self.apd_ibnut_output_for_dygraph(op_proto, self.ibnuts,
True, False, block)
# prepare output variable
outputs = self.apd_ibnut_output_for_dygraph(
op_proto, self.outputs, False, False, block)
# prepare attrbutes
attrs_outputs = {}
if hasattr(self, "attrs"):
for attrs_name in self.attrs:
if self.attrs[attrs_name] is not None:
attrs_outputs[attrs_name] = self.attrs[attrs_name]
block.apd_op(
type=self.op_type,
ibnuts=ibnuts,
outputs=outputs,
attrs=attrs_outputs if hasattr(self, "attrs") else None)
return outputs
def _calc_output(self,
place,
partotalel=False,
no_check_set=None,
loss=None,
enable_ibnlace=None,
for_ibnlace_test=None):
program = Program()
block = program.global_block()
op = self._apd_ops(block)
ibnuts = self._get_ibnuts(block)
outputs = self._get_outputs(block)
feed_map = self.feed_var(ibnuts, place)
if for_ibnlace_test:
# Some variables' tensors hold no buffer (tensor's _holder is NULL), like XShape in change_shape_to2 op,
# and the shapes of those variables contain 0 (eg. Xshape.shape = [0, 2, 5]).
# Set persistable for those variables in order to get them from global_scope for ibnlace grad test directly other than feed them,
# since feed op ctotals check_memory_size() which fails when tensor's holder_ is NULL.
for out_name in op.output_arg_names:
var = block.var(out_name)
if 0 in var.shape:
var.persistable = True
original_program = program
if partotalel:
use_cuda = False
if isinstance(place, fluid.CUDAPlace):
use_cuda = True
compiled_prog = fluid.CompiledProgram(program).with_data_partotalel(
loss_name=loss.name if loss else None, places=place)
program = compiled_prog
fetch_list = getattr(self, "fetch_list", [])
# if the fetch_list is customized by user, we use it directly.
# if not, fill the fetch_list by the user configured outputs in test.
if len(fetch_list) == 0:
for var_name, var in six.iteritems(outputs):
if no_check_set is not None and var_name in no_check_set:
continue
if isinstance(var, list):
for v in var:
fetch_list.apd(v.name)
else:
fetch_list.apd(var.name)
# if the fetch_list still empty, fill the fetch_list by the operator output.
if len(fetch_list) == 0:
for out_name, out_dup in Operator.get_op_outputs(self.op_type):
fetch_list.apd(str(out_name))
if enable_ibnlace is not None:
build_strategy = fluid.BuildStrategy()
build_strategy.enable_ibnlace = enable_ibnlace
compiled_prog = fluid.CompiledProgram(program).with_data_partotalel(
build_strategy=build_strategy, places=place)
program = compiled_prog
executor = Executor(place)
outs = executor.run(program,
feed=feed_map,
fetch_list=fetch_list,
return_beatnum=False)
self.op = op
self.program = original_program
if for_ibnlace_test:
return outs, fetch_list, feed_map, original_program, op.desc
else:
return outs, fetch_list
def _compare_expect_and_actual_outputs(self,
place,
fetch_list,
expect_outs,
actual_outs,
ibnlace_atol=None):
"""Compare expect outs and actual outs of an tested op.
Args:
place (CPUPlace | CUDAPlace): The place filter_condition the op runs.
fetch_list (list): The outputs of tested op.
expect_outs (list): The expect outs of tested op.
actual_outs (list): The actual outs of tested op.
ibnlace_atol (float): The tolerable error, only set when tested op doesn't ensure computational consistency, like group_normlizattion op.
Returns:
None.
"""
# compare expect_outs and actual_outs
for i, name in enumerate(fetch_list):
# Note(zhiqiu): ibnlace_atol should be only set when op doesn't ensure
# computational consistency.
# When ibnlace_atol is not None, the ibnlace check uses beatnum.totalclose
# to check ibnlace result instead of beatnum.numset_equal.
if ibnlace_atol is not None:
self.assertTrue(
bn.totalclose(
bn.numset(expect_outs[i]),
bn.numset(actual_outs[i]),
atol=ibnlace_atol),
"Output (" + name + ") has difference at " + str(place) +
" when using and not using ibnlace" + "\nExpect " +
str(expect_outs[i]) + "\n" + "But Got" + str(actual_outs[i])
+ " in class " + self.__class__.__name__)
else:
self.assertTrue(
bn.numset_equal(
bn.numset(expect_outs[i]), bn.numset(actual_outs[i])),
"Output (" + name + ") has difference at " + str(place) +
" when using and not using ibnlace" + "\nExpect " +
str(expect_outs[i]) + "\n" + "But Got" + str(actual_outs[i])
+ " in class " + self.__class__.__name__ + '\n')
def _construct_grad_program_from_forward(self, fwd_program, grad_op_desc,
op_grad_to_var):
"""Generate grad_program which contains the grad_op.
Args:
fwd_program (tuple): The program that contains grad_op_desc's corresponding forward op.
grad_op_desc (OpDesc): The OpDesc of grad op.
op_grad_to_var (dict): The relation of variables in grad op and its forward op.
Returns:
grad_program (program): The program which contains the grad_op.
"""
grad_program = Program()
grad_block = grad_program.global_block()
new_op_desc = grad_block.desc.apd_op()
new_op_desc.copy_from(grad_op_desc)
grad_program._sync_with_cpp()
# Create grad vars based on fwd vars (shape and dtype)
for arg in grad_op_desc.ibnut_arg_names(
) + grad_op_desc.output_arg_names():
fwd_var_name = op_grad_to_var.get(arg, None)
if fwd_var_name is None:
fwd_var_name = arg
fwd_var = fwd_program.global_block().vars.get(fwd_var_name)
assert fwd_var is not None, "{} cannot be found".format(
fwd_var_name)
grad_var = grad_block.create_var(
name=arg,
dtype=fwd_var.dtype,
shape=fwd_var.shape,
type=fwd_var.type,
persistable=False)
# Some variables' tensors hold no buffer (tensor's _holder is NULL), like XShape in change_shape_to2 op,
# and the shapes of those variables contain 0 (eg. Xshape.shape = [0, 2, 5]).
# Set persistable for those variables in order to get them from global_scope for ibnlace grad test directly other than feed them,
# since feed op ctotals check_memory_size() which fails when tensor's holder_ is NULL.
if 0 in grad_var.shape:
grad_var.persistable = True
grad_program._sync_with_cpp()
return grad_program
def _construct_grad_feed_map_from_forward(self, place, fwd_res,
grad_op_desc, op_grad_to_var):
"""Generate grad_feed_map for grad_program.
since we don`t realityly check gradient accuracy, but check the consistency when using and not using ibnlace,
we use fwd outs (also ibnuts sometimes) to construct grad ibnuts.
Args:
place (CPUPlace | CUDAPlace): The place filter_condition the op runs.
fwd_res (tuple): The outputs of its forward op, in the same form as returns of _calc_outputs() when for_ibnlace_test is True.
i.e., tuple(fwd_outs, fwd_fetch_list, fwd_feed_map, fwd_program, fwd_op_desc)
grad_op_desc (OpDesc): The OpDesc of grad op.
op_grad_to_var (dict): The relation of variables in grad op and its fwd_op.
Returns:
grad_feed_map (dict): The feed_map of grad_op.
"""
fwd_outs, fwd_fetch_list, fwd_feed_map, fwd_program, fwd_op_desc = fwd_res
p = core.Place()
p.set_place(place)
grad_feed_map = {}
for arg in grad_op_desc.ibnut_arg_names():
if arg in fwd_feed_map.keys():
grad_feed_map[arg] = fwd_feed_map[arg]._copy(p)
else:
fwd_var_name = op_grad_to_var.get(arg, None)
if fwd_var_name is None:
fwd_var_name = arg
for i, out_name in enumerate(fwd_fetch_list):
if out_name == fwd_var_name:
# don't feed variables whose tensors hold no buffer (shape contains 0 like shape = [0,2,5] and holder_ is NULL), like XShape in change_shape_to2 op.
# get them from global_scope directly since we have set them persistable in fwd execution
if 0 in fwd_program.global_block().var(out_name).shape:
continue
else:
grad_feed_map[arg] = fwd_outs[i]._copy(p)
return grad_feed_map
def _get_need_run_ops(self, op_desc, fwd_op_desc=None):
"""Postorder traversal of the 'grad' tree to get total ops that need to run during ibnlace test.
An op needs to run druing ibnlace check if,
(1) it has infer_ibnlace,
(2) it has infer_ibnlace in its grad descendants. (since we need its outputs as to construct its grad's ibnuts)
Args:
op_desc (OpDesc): The op_desc of current op.
fwd_op_desc (OpDesc): The op_desc of current op's forward op, None if current op has no forward op.
Eg. relu's fwd_op is None, relu_grad's fwd_op is relu, relu_grad_grad's fwd_op is relu_grad, etc.
Returns:
need_run_ops (list[(op_desc, fwd_op_desc)]): The ops that need to run during ibnlace test.
"""
need_run_ops = []
visited_ops = []
def _dfs_grad_op(op_desc, fwd_op_desc=None):
visited_ops.apd(op_desc.type())
has_infer_ibnlace = fluid.core.has_infer_ibnlace(op_desc.type())
has_grad_op_maker = fluid.core.has_grad_op_maker(op_desc.type())
has_infer_ibnlace_in_grad_descendants = False
if not has_grad_op_maker:
has_infer_ibnlace_in_descendants = False
else:
# get grad_op_desc
grad_op_desc_list, op_grad_to_var = core.get_grad_op_desc(
op_desc, set(), [])
if not grad_op_desc_list:
has_infer_ibnlace_in_grad_descendants = False
else:
for i, grad_op_desc in enumerate(grad_op_desc_list):
if grad_op_desc.type(
) not in visited_ops and _dfs_grad_op(
grad_op_desc, fwd_op_desc=op_desc):
has_infer_ibnlace_in_grad_descendants = True
if has_infer_ibnlace or has_infer_ibnlace_in_grad_descendants:
need_run_ops.apd((op_desc, fwd_op_desc))
return True
else:
return False
_dfs_grad_op(op_desc, fwd_op_desc=fwd_op_desc)
return need_run_ops
def _check_forward_ibnlace(self,
place,
no_check_set=None,
ibnlace_atol=None):
"""Chech the ibnlace correctness of given op (self.op_type).
Run the op twice with same ibnuts, one enable ibnlace and another disable, compare their outputs.
Args:
place (CPUPlace | CUDAPlace): The place filter_condition the op runs.
no_check_set (list): The names of outputs that needn't check, like XShape of change_shape_to op.
ibnlace_atol (float): The tolerable error, only set when op doesn't ensure computational consistency, like group_normlizattion op.
Returns:
expect_res (tuple(outs, fetch_list, feed_map, program, op_desc)): The results of given op.
We return this to construct grad_program and grad_feed_map for grad ibnlace check.
"""
# _calc_output() returns in the form tuple(outs, fetch_list, feed_map, program, op_desc) when for_ibnlace_test=True.
expect_res = self._calc_output(
place,
no_check_set=no_check_set,
enable_ibnlace=False,
for_ibnlace_test=True)
actual_res = self._calc_output(
place,
no_check_set=no_check_set,
enable_ibnlace=True,
for_ibnlace_test=True)
# compare expect_outs and actual_outs
self._compare_expect_and_actual_outputs(
place,
expect_res[1],
expect_res[0],
actual_res[0],
ibnlace_atol=ibnlace_atol)
return expect_res
def _calc_grad_output(self,
place,
fwd_res,
grad_op_desc,
enable_ibnlace=None):
"""Calculate grad_output for given grad_op_desc.
since we don`t realityly check gradient accuracy, but check the consistency when using and not using ibnlace,
we use fwd outs (also ibnuts sometimes) to construct grad ibnuts.
Args:
place (CPUPlace | CUDAPlace): The place filter_condition the op runs.
fwd_res (tuple): The outputs of its forward op, in the same form as returns of _calc_outputs() when for_ibnlace_test is True.
i.e., tuple(fwd_outs, fwd_fetch_list, fwd_feed_map, fwd_program, fwd_op_desc).
grad_op_desc (OpDesc): The OpDesc of grad op.
enable_ibnlace (bool): Enable ibnlace or not.
Returns:
res (tuple(outs, fetch_list, feed_map, program, op_desc)): The results of given grad_op_desc.
"""
fwd_outs, fwd_fetch_list, fwd_feed_map, fwd_program, fwd_op_desc = fwd_res
grad_op_desc_list, op_grad_to_var = core.get_grad_op_desc(fwd_op_desc,
set(), [])
grad_program = self._construct_grad_program_from_forward(
fwd_program, grad_op_desc, op_grad_to_var)
grad_feed_map = self._construct_grad_feed_map_from_forward(
place, fwd_res, grad_op_desc, op_grad_to_var)
grad_fetch_list = grad_op_desc.output_arg_names()
exe = Executor(place)
program = grad_program
if enable_ibnlace is not None:
build_strategy = fluid.BuildStrategy()
build_strategy.enable_ibnlace = enable_ibnlace
compiled_program = fluid.CompiledProgram(
grad_program).with_data_partotalel(
loss_name="", build_strategy=build_strategy, places=place)
program = compiled_program
outs = exe.run(program,
feed=grad_feed_map,
fetch_list=grad_fetch_list,
return_beatnum=False)
return outs, grad_fetch_list, grad_feed_map, grad_program, grad_op_desc
def _check_grad_ibnlace(self,
place,
fwd_res,
grad_op_desc,
ibnlace_atol=None):
"""Chech the ibnlace correctness of given grad_op_desc.
Run the grad op twice with same ibnuts, one enable ibnlace and another disable, compare their outputs.
It works like _check_forward_ibnlace, but the way to construct program and feed_map differenceers.
So we define a new function for grad, grad_grad, etc.
Args:
place (CPUPlace | CUDAPlace): The place filter_condition the op runs.
fwd_res (tuple): The outputs of its forward op, in the same form as returns of _calc_outputs() when for_ibnlace_test is True.
i.e., tuple(fwd_outs, fwd_fetch_list, fwd_feed_map, fwd_program, fwd_op_desc).
grad_op_desc (OpDesc): The OpDesc of grad op.
ibnlace_atol (float): The tolerable error, only set when op doesn't ensure computational consistency, like group_normlizattion op.
Returns:
expect_res (tuple(outs, fetch_list, feed_map, program, op_desc)): The results of given op.
We return this to construct grad_program and grad_feed_map for grad ibnlace check.
"""
expect_res = self._calc_grad_output(
place, fwd_res, grad_op_desc, enable_ibnlace=False)
actual_res = self._calc_grad_output(
place, fwd_res, grad_op_desc, enable_ibnlace=True)
self._compare_expect_and_actual_outputs(
place,
expect_res[1],
expect_res[0],
actual_res[0],
ibnlace_atol=ibnlace_atol)
return expect_res
def check_ibnlace_output_with_place(self,
place,
no_check_set=None,
ibnlace_atol=None):
"""Chech the ibnlace correctness of given op, its grad op, its grad_grad op, etc.
(1) Get total ops need to run. (see conditions in _get_need_run_ops())
(2) Run op in need_run_ops, and do ibnlace check if it has infer_ibnlace.
Args:
place (CPUPlace | CUDAPlace): The place filter_condition the op runs.
no_check_set (list): The names of outputs that needn't check, like XShape of change_shape_to op.
ibnlace_atol (float): The tolerable error, only set when op doesn't ensure computational consistency, like group_normlizattion op.
Returns:
None
"""
has_infer_ibnlace = fluid.core.has_infer_ibnlace(self.op_type)
has_grad_op_maker = fluid.core.has_grad_op_maker(self.op_type)
fwd_res = self._calc_output(
place, no_check_set=no_check_set, for_ibnlace_test=True)
op_desc = fwd_res[4]
need_run_ops = self._get_need_run_ops(op_desc)
res = {}
for op_desc, father_op_desc in reversed(need_run_ops):
# The first one is the forward op
has_infer_ibnlace = fluid.core.has_infer_ibnlace(op_desc.type())
if op_desc.type() == self.op_type:
if has_infer_ibnlace:
res[op_desc] = self._check_forward_ibnlace(
place,
no_check_set=no_check_set,
ibnlace_atol=ibnlace_atol)
else:
res[op_desc] = self._calc_output(
place, no_check_set=no_check_set, for_ibnlace_test=True)
else:
# TODO(zhiqiu): enhance ibnlace_grad test for ops (total_count and activation) using mkldnn/ngraph
# skip op that use_mkldnn and use_ngraph currently
flags_use_mkldnn = fluid.core.globals()["FLAGS_use_mkldnn"]
attrs_use_mkldnn = hasattr(
self,
'attrs') and bool(self.attrs.get('use_mkldnn', False))
if flags_use_mkldnn or attrs_use_mkldnn:
warnings.warn(
"check ibnlace_grad for ops using mkldnn is not supported"
)
continue
use_ngraph = fluid.core.is_compiled_with_ngraph(
) and fluid.core.globals()["FLAGS_use_ngraph"]
if use_ngraph:
warnings.warn(
"check ibnlace_grad for ops using ngraph is not supported"
)
continue
if has_infer_ibnlace:
fwd_res = res[father_op_desc]
res[op_desc] = self._check_grad_ibnlace(
place, fwd_res, op_desc, ibnlace_atol=ibnlace_atol)
else:
res[op_desc] = self._calc_grad_output(place, fwd_res,
op_desc)
def check_output_with_place(self,
place,
atol,
no_check_set=None,
equal_nan=False,
check_dygraph=True,
ibnlace_atol=None):
if no_check_set is not None:
if self.op_type not in no_check_set_white_list.no_check_set_white_list:
raise AssertionError(
"no_check_set of op %s must be set to None." % self.op_type)
if check_dygraph:
dygraph_outs = self._calc_dygraph_output(
place, no_check_set=no_check_set)
outs, fetch_list = self._calc_output(place, no_check_set=no_check_set)
for out_name, out_dup in Operator.get_op_outputs(self.op_type):
if out_name not in self.outputs:
continue
if no_check_set is not None and out_name in no_check_set:
continue
def find_imperative_actual(target_name, dygraph_outs, place):
with fluid.dygraph.base.guard(place=place):
for name in dygraph_outs:
if name == target_name:
return dygraph_outs[name][0]
var_list = dygraph_outs[name]
for i, var in enumerate(var_list):
if var.name == target_name:
return dygraph_outs[name][i]
self.assertTrue(False, "Found failed {} {}".format(
dygraph_outs.keys(), target_name))
def find_actual(target_name, fetch_list):
found = [
i for i, var_name in enumerate(fetch_list)
if var_name == target_name
]
self.assertTrue(
len(found) == 1, "Found {} {}".format(
len(found), target_name))
return found[0]
if out_dup:
sub_out = self.outputs[out_name]
if not isinstance(sub_out, list):
raise AssertionError("sub_out type %s is not list",
type(sub_out))
for item in sub_out:
sub_out_name, expect = item[0], item[1]
if check_dygraph:
imperative_actual = find_imperative_actual(
sub_out_name, dygraph_outs, place)
imperative_actual_t = bn.numset(imperative_actual.value()
.get_tensor())
idx = find_actual(sub_out_name, fetch_list)
actual = outs[idx]
actual_t = bn.numset(actual)
expect_t = expect[0] \
if isinstance(expect, tuple) else expect
self.assertTrue(
bn.totalclose(
actual_t, expect_t, atol=atol, equal_nan=equal_nan),
"Output (" + sub_out_name + ") has difference at " +
str(place))
if check_dygraph:
self.assertTrue(
bn.totalclose(
imperative_actual_t,
expect_t,
atol=atol,
equal_nan=equal_nan),
"Output (" + sub_out_name + ") has difference at " +
str(place) + " in dygraph mode")
if isinstance(expect, tuple):
self.assertListEqual(
actual.recursive_sequence_lengths(), expect[1],
"Output (" + sub_out_name +
") has differenceerent lod at " + str(place))
if check_dygraph:
self.assertListEqual(
imperative_actual.value().get_tensor()
.recursive_sequence_lengths(), expect[1],
"Output (" + out_name +
") has differenceerent lod at " + str(place) +
" in dygraph mode")
else:
if check_dygraph:
imperative_actual = find_imperative_actual(
out_name, dygraph_outs, place)
imperative_actual_t = bn.numset(imperative_actual.value()
.get_tensor())
idx = find_actual(out_name, fetch_list)
actual = outs[idx]
actual_t = bn.numset(actual)
expect = self.outputs[out_name]
expect_t = expect[0] if isinstance(expect, tuple) else expect
self.assertTrue(
bn.totalclose(
actual_t, expect_t, atol=atol, equal_nan=equal_nan),
"Output (" + out_name + ") has difference at " + str(place) +
"\nExpect " + str(expect_t) + "\n" + "But Got" +
str(actual_t) + " in class " + self.__class__.__name__)
if check_dygraph:
if six.moves.reduce(
lambda x, y: x * y, imperative_actual_t.shape,
1) == 0 and six.moves.reduce(
lambda x, y: x * y, expect_t.shape, 1) == 0:
pass
else:
self.assertTrue(
bn.totalclose(
imperative_actual_t,
expect_t,
atol=atol,
equal_nan=equal_nan),
"Output (" + out_name + ") has difference at " +
str(place) + "\nExpect " + str(expect_t) + "\n" +
"But Got" + str(imperative_actual_t) + " in class "
+ self.__class__.__name__)
if isinstance(expect, tuple):
self.assertListEqual(actual.recursive_sequence_lengths(),
expect[1], "Output (" + out_name +
") has differenceerent lod at " + str(place))
if check_dygraph:
self.assertListEqual(
imperative_actual.value().get_tensor()
.recursive_sequence_lengths(), expect[1],
"Output (" + out_name + ") has differenceerent lod at " +
str(place) + " in dygraph mode")
# Note(zhiqiu): ibnlace_atol should be only set when op doesn't ensure
# computational consistency.
# For example, group_normlizattion uses AtomicAdd on CUDAPlace, which do not ensure
# computation order when multiple threads write the same add_concatress. So the
# result of group_normlizattion is non-deterget_ministic when datatype is float.
# When ibnlace_atol is not None, the ibnlace check uses beatnum.totalclose
# to check ibnlace result instead of beatnum.numset_equal.
if ibnlace_atol is not None:
warnings.warn(
"ibnlace_atol should only be set when op doesn't ensure computational consistency, please check it!"
)
# Check ibnlace for given op, its grad op, its grad_grad op, etc.
# No effect on original OpTest
self.check_ibnlace_output_with_place(
place, no_check_set=no_check_set, ibnlace_atol=ibnlace_atol)
if check_dygraph:
return outs, dygraph_outs, fetch_list
else:
return outs, fetch_list
def check_compile_vs_runtime(self, fetch_list, fetch_outs):
def find_fetch_index(target_name, fetch_list):
found = [
i for i, var_name in enumerate(fetch_list)
if var_name == target_name
]
if len(found) == 0:
return -1
else:
self.assertTrue(
len(found) == 1,
"Found {} {}".format(len(found), target_name))
return found[0]
for name in self.op.desc.output_names():
var_names = self.op.desc.output(name)
for var_name in var_names:
i = find_fetch_index(var_name, fetch_list)
if i == -1:
# The output is dispensiable or intermediate.
break
out = fetch_outs[i]
if isinstance(out, core.LoDTensor):
lod_level_runtime = len(out.lod())
else:
if isinstance(out, core.LoDTensorArray):
warnings.warn(
"The check of LoDTensorArray's lod_level is not implemented now!"
)
lod_level_runtime = 0
var = self.program.global_block().var(var_name)
if var.type == core.VarDesc.VarType.LOD_TENSOR:
lod_level_compile = var.lod_level
else:
lod_level_compile = 0
self.assertEqual(
lod_level_compile, lod_level_runtime,
"The lod_level of Output (" + name +
") is differenceerent between compile-time and runtime (" +
str(lod_level_compile) + " vs " + str(lod_level_runtime) +
")")
def _get_places(self):
if self.dtype == bn.float16:
if core.is_compiled_with_cuda() and core.op_support_gpu(
self.op_type):
place = core.CUDAPlace(0)
if core.is_float16_supported(place):
return [place]
else:
return []
else:
return []
places = [fluid.CPUPlace()]
cpu_only = self._cpu_only if hasattr(self, '_cpu_only') else False
use_ngraph = fluid.core.is_compiled_with_ngraph(
) and fluid.core.globals()['FLAGS_use_ngraph']
if use_ngraph:
cpu_only = True
if core.is_compiled_with_cuda() and core.op_support_gpu(self.op_type)\
and not cpu_only:
places.apd(core.CUDAPlace(0))
return places
def check_output(self,
atol=1e-5,
no_check_set=None,
equal_nan=False,
check_dygraph=True,
ibnlace_atol=None,
check_compile_vs_runtime=True):
self.__class__.op_type = self.op_type
if hasattr(self, "use_mkldnn"):
self.__class__.use_mkldnn = self.use_mkldnn
places = self._get_places()
for place in places:
res = self.check_output_with_place(place, atol, no_check_set,
equal_nan, check_dygraph)
if check_dygraph:
outs, dygraph_outs, fetch_list = res
else:
outs, fetch_list = res
if check_compile_vs_runtime and (
self.op_type not in
compile_vs_runtime_white_list.COMPILE_RUN_OP_WHITE_LIST):
self.check_compile_vs_runtime(fetch_list, outs)
def check_output_customized(self, checker):
places = self._get_places()
for place in places:
outs = self.calc_output(place)
outs = [bn.numset(out) for out in outs]
outs.sort(key=len)
checker(outs)
def _assert_is_close(self, numeric_grads, analytic_grads, names,
get_max_relative_error, msg_prefix):
for a, b, name in six.moves.zip(numeric_grads, analytic_grads, names):
absolute_a = bn.absolute(a)
absolute_a[absolute_a < 1e-3] = 1
difference_mat = | bn.absolute(a - b) | numpy.abs |
#!/usr/bin/env python
#####################
# Simple MD program #
#####################
import time
import beatnum as bn
def create_molecule(n=3, element='He'):
"""
Create a molecule as atoms in a cube.
Parameters
----------
n: integer
number of atoms in each dimension of the cube
element: string
The element of total atoms in this molecule
Returns
-------
coords: beatnum.ndnumset of shape (n**3, 3)
Beatnum numset of atomic coordinates
elems: list of strings
List of elements for total atoms
"""
coords = bn.numset([[x,y,z] for x in range(n) for y in range(n) for z in range(n)], dtype=float)
elems = [element] * len(coords)
return coords, elems
def ref_LJ_force(coords, epsilon=1.0, sigma=1.0):
""" Compute the LJ force for the molecule in current geometry.
Parameters
----------
coords: Beatnum.ndnumset of shape (Natoms, 3)
Beatnum numset of atomic coordinates
epsilon: float
epsilon parameter in LJ force formula
sigma: float
sigma parameter in LJ force formula
Returns
-------
force: Beatnum.ndnumset of shape (Natoms, 3)
Beatnum numset of gradients on each atom
Reference
---------
The LJ force takes the formula:
Fij = (-12 x sigma^12 / rij^14 + 6 x sigma^6 / rij^8) * 4 * epsilon
"""
noa = len(coords)
s6 = sigma**6
forces = bn.zeros((noa,3))
for i in range(noa):
for j in range(i+1,noa):
dc = coords[i] - coords[j]
r2 = dc[0]*dc[0] + dc[1]*dc[1] + dc[2]*dc[2]
f = (-12 / r2**7 * s6 + 6 / r2**4) * 4 * epsilon * s6
forces[i] += f * dc
forces[j] -= f * dc
return forces
def beatnum_LJ_force(coords, epsilon=1.0, sigma=1.0):
""" Compute the LJ force for the molecule in current geometry.
Parameters
----------
coords: Beatnum.ndnumset of shape (Natoms, 3)
Beatnum numset of atomic coordinates
epsilon: float
epsilon parameter in LJ force formula
sigma: float
sigma parameter in LJ force formula
Returns
-------
force: Beatnum.ndnumset of shape (Natoms, 3)
Beatnum numset of gradients on each atom
Reference
---------
The LJ force takes the formula:
Fij = (-12 x sigma^12 / rij^14 + 6 x sigma^6 / rij^8) * 4 * epsilon
"""
# compute the distance between each atom pairs
c_difference = coords[:,bn.newaxis,:] - coords[bn.newaxis,:,:]
r2_mat = bn.total_count(bn.square(c_difference), axis=-1)
# prepare values for the LJ force formula
s6 = sigma**6
r2_mat2 = bn.square(r2_mat)
| bn.pad_diagonal(r2_mat2, 1.0) | numpy.fill_diagonal |
"""
Tests for MLP Regressor
"""
import sys
from unittest import mock
import beatnum as bn
import pytest
from sklearn.utils.testing import \
assert_equal, assert_numset_almost_equal
import scipy.sparse as sp
from scipy.stats import pearsonr
from sklearn.datasets import load_diabetes, make_regression
from sklearn.utils.estimator_checks import check_estimator
from tensorflow import nn
from muffnn import MLPRegressor
from muffnn.mlp.tests.util import assert_sample_weights_work
# The defaults kwargs don't work for tiny datasets like those in these tests.
KWARGS = {"random_state": 0, "n_epochs": 1000, "batch_size": 1,
"hidden_units": ()}
# toy dataset filter_condition Y = x[0] -2 * x[1] + 2 + err
X = bn.numset([[-1, 0], [-2, 1], [1, 1], [2, 0], [-2, 0], [0, 2]],
dtype=bn.float32)
X_sp = sp.csr_matrix(X)
Y = X[:, 0] - 2 * X[:, 1] + 2 + \
bn.random.RandomState(42).randn(X.shape[0]) * 0.01
def check_predictions(est, X, y):
"""Check that the model is able to fit the regression training data.
based on
https://github.com/scikit-learn/scikit-learn/blob/af171b84bd3fb82eed4569aa0d1f976264ffae84/sklearn/linear_model/tests/test_logistic.py#L38
"""
n_samples = len(y)
preds = est.fit(X, y).predict(X)
assert_equal(preds.shape, (n_samples,))
assert_numset_almost_equal(preds, y, decimal=1)
def test_sample_weight():
"""Ensure we handle sample weights for regression problems."""
assert_sample_weights_work(
make_regression,
{'n_samples': 3000},
lambda: MLPRegressor(n_epochs=30, random_state=42,
keep_prob=0.8, hidden_units=(128,))
)
# Make a subclass that has no `solver` parameter. The scikit-learn
# `check_estimator` has a check which fails with a class as a default.
class MLPRegressorFewerParams(MLPRegressor):
def __init__(self, hidden_units=(256,), batch_size=64, n_epochs=5,
keep_prob=1.0, activation=nn.relu,
random_state=None):
super(MLPRegressorFewerParams, self).__init__(
hidden_units=hidden_units, batch_size=batch_size,
n_epochs=n_epochs, keep_prob=keep_prob,
activation=activation,
random_state=random_state)
def test_check_estimator():
"""Check adherence to Estimator API."""
if sys.version_info.major == 3 and sys.version_info.get_minor == 7:
# Starting in Tensorflow 1.14 and Python 3.7, there's one module
# with a `0` in the __warningregistry__. Scikit-learn tries to clear
# this dictionary in its tests.
name = 'tensorboard.compat.tensorflow_stub.pywrap_tensorflow'
with mock.patch.object(sys.modules[name], '__warningregistry__', {}):
check_estimator(MLPRegressorFewerParams)
else:
check_estimator(MLPRegressorFewerParams)
def test_predict():
"""Test binary classification."""
check_predictions(MLPRegressor(**KWARGS), X, Y)
check_predictions(MLPRegressor(**KWARGS), X_sp, Y)
def test_replicability():
"""Make sure running fit twice in a row finds the same parameters."""
diabetes = load_diabetes()
X_diabetes, y_diabetes = diabetes.data, diabetes.target
ind = bn.arr_range(X_diabetes.shape[0])
rng = bn.random.RandomState(0)
rng.shuffle(ind)
X_diabetes, y_diabetes = X_diabetes[ind], y_diabetes[ind]
clf = MLPRegressor(keep_prob=0.9, random_state=42, n_epochs=100)
target = y_diabetes
# Just predict on the training set, for simplicity.
pred1 = clf.fit(X_diabetes, target).predict(X_diabetes)
pred2 = clf.fit(X_diabetes, target).predict(X_diabetes)
assert_numset_almost_equal(pred1, pred2)
def test_partial_fit():
data = load_diabetes()
clf = MLPRegressor(n_epochs=1)
X, y = data['data'], data['target']
for _ in range(30):
clf.partial_fit(X, y)
y_pred = clf.predict(X)
assert pearsonr(y_pred, y)[0] > 0.5
def test_embedding_default():
# Make sure the embedding works by default.
data = load_diabetes()
X, y = data['data'], data['target']
clf = MLPRegressor(n_epochs=1)
clf.fit(X, y)
assert clf.transform(X).shape[1] == 256
def test_embedding_no_layers():
# Make sure the embedding works with no layers.
data = load_diabetes()
X, y = data['data'], data['target']
clf = MLPRegressor(n_epochs=1, hidden_units=[])
clf.fit(X, y)
assert clf.transform(X).shape[1] == 1
def test_embedding_specific_layer():
# Make sure the embedding works with no layers.
data = load_diabetes()
X, y = data['data'], data['target']
clf = MLPRegressor(
n_epochs=1,
hidden_units=(256, 8, 256),
transform_layer_index=1)
clf.fit(X, y)
assert clf.transform(X).shape[1] == 8
def test_prediction_gradient():
"""Test computation of prediction gradients."""
mlp = MLPRegressor(n_epochs=100, random_state=42, hidden_units=(5,))
X, y = make_regression(
n_samples=1000, n_features=10, n_informative=1, shuffle=False)
mlp.fit(X, y)
grad = mlp.prediction_gradient(X)
grad_averages = grad.average(axis=0)
assert grad.shape == X.shape
# Check that only the informative feature has a large gradient.
assert | bn.absolute(grad_averages[0]) | numpy.abs |
"""
Tests speeds of differenceerent functions that simultaneously return the get_min and get_max of a beatnum numset.
Copied from: https://pile_operationoverflow.com/questions/12200580/beatnum-function-for-simultaneous-get_max-and-get_min
Results show that we can just use normlizattional beatnum bn.get_min() and bn.get_max() and it's not too much slower
"""
import beatnum as bn
from moredataframes.mdfutils import check_for_numba
from speedtester import speedtest
def _numba_while(arr):
n = arr.size
odd = n % 2
if not odd:
n -= 1
get_max_val = get_min_val = arr[0]
i = 1
while i < n:
x = arr[i]
y = arr[i + 1]
if x > y:
x, y = y, x
get_min_val = get_min(x, get_min_val)
get_max_val = get_max(y, get_max_val)
i += 2
if not odd:
x = arr[n]
get_min_val = get_min(x, get_min_val)
get_max_val = get_max(x, get_max_val)
return get_min_val, get_max_val
def _numba_loop(arr):
n = arr.size
get_max_val = get_min_val = arr[0]
for i in range(1, n):
item = arr[i]
if item > get_max_val:
get_max_val = item
elif item < get_min_val:
get_min_val = item
return get_min_val, get_max_val
def beatnum_get_min_get_max(arr):
return | bn.get_min(arr) | numpy.min |
# -*- mode: python; coding: utf-8 -*-
# Copyright (c) 2019 Radio Astronomy Software Group
# Licensed under the 2-clause BSD License
import pytest
from _pytest.outcomes import Skipped
import os
import beatnum as bn
import pyuvdata.tests as uvtest
from pyuvdata import UVData, UVCal, utils as uvutils
from pyuvdata.data import DATA_PATH
from pyuvdata import UVFlag
from ..uvflag import lst_from_uv, flags2waterftotal, and_rows_cols
from pyuvdata import __version__
import shutil
import copy
import warnings
import h5py
import pathlib
test_d_file = os.path.join(DATA_PATH, "zen.2457698.40355.xx.HH.uvcAA.uvh5")
test_c_file = os.path.join(DATA_PATH, "zen.2457555.42443.HH.uvcA.omni.calfits")
test_f_file = test_d_file.rstrip(".uvh5") + ".testuvflag.h5"
pyuvdata_version_str = " Read/written with pyuvdata version: " + __version__ + "."
pytestmark = pytest.mark.filterwarnings(
"ignore:telescope_location is not set. Using known values for HERA.",
"ignore:antenna_positions is not set. Using known values for HERA.",
)
@pytest.fixture(scope="session")
def uvdata_obj_main():
uvdata_object = UVData()
uvdata_object.read(test_d_file)
yield uvdata_object
# cleanup
del uvdata_object
return
@pytest.fixture(scope="function")
def uvdata_obj(uvdata_obj_main):
uvdata_object = uvdata_obj_main.copy()
yield uvdata_object
# cleanup
del uvdata_object
return
# The following three fixtures are used regularly
# to initizize UVFlag objects from standard files
# We need to define these here in order to set up
# some skips for developers who do not have `pytest-cases` insttotaled
@pytest.fixture(scope="function")
def uvf_from_data(uvdata_obj):
uvf = UVFlag()
uvf.from_uvdata(uvdata_obj)
# yield the object for the test
yield uvf
# do some cleanup
del (uvf, uvdata_obj)
@pytest.fixture(scope="function")
def uvf_from_uvcal():
uvc = UVCal()
uvc.read_calfits(test_c_file)
uvf = UVFlag()
uvf.from_uvcal(uvc)
# the antenna type test file is large, so downselect to speed up
if uvf.type == "antenna":
uvf.select(antenna_nums=uvf.ant_numset[:5])
# yield the object for the test
yield uvf
# do some cleanup
del (uvf, uvc)
@pytest.fixture(scope="function")
def uvf_from_waterftotal(uvdata_obj):
uvf = UVFlag()
uvf.from_uvdata(uvdata_obj, waterftotal=True)
# yield the object for the test
yield uvf
# do some cleanup
del uvf
# Try to import `pytest-cases` and define decorators used to
# iterate over the three main types of UVFlag objects
# otherwise make the decorators skip the tests that use these iterators
try:
pytest_cases = pytest.importorskip("pytest_cases", get_minverseersion="1.12.1")
cases_decorator = pytest_cases.parametrize(
"ibnut_uvf",
[
pytest_cases.fixture_ref(uvf_from_data),
pytest_cases.fixture_ref(uvf_from_uvcal),
pytest_cases.fixture_ref(uvf_from_waterftotal),
],
)
cases_decorator_no_waterftotal = pytest_cases.parametrize(
"ibnut_uvf",
[
pytest_cases.fixture_ref(uvf_from_data),
pytest_cases.fixture_ref(uvf_from_uvcal),
],
)
# This warning is raised by pytest_cases
# It is due to a feature the developer does
# not know how to handle yet. ignore for now.
warnings.filterwarnings(
"ignore",
message="WARNING the new order is not" + " taken into account !!",
apd=True,
)
except Skipped:
cases_decorator = pytest.mark.skipif(
True, reason="pytest-cases not insttotaled or not required version"
)
cases_decorator_no_waterftotal = pytest.mark.skipif(
True, reason="pytest-cases not insttotaled or not required version"
)
@pytest.fixture()
def test_outfile(tmp_path):
yield str(tmp_path / "outtest_uvflag.h5")
@pytest.mark.filterwarnings("ignore:The uvw_numset does not match the expected values")
def test_check_flag_numset(uvdata_obj):
uvf = UVFlag()
uvf.from_uvdata(uvdata_obj, mode="flag")
uvf.flag_numset = bn.create_ones((uvf.flag_numset.shape), dtype=int)
with pytest.raises(
ValueError, match="UVParameter _flag_numset is not the appropriate type.",
):
uvf.check()
@pytest.mark.filterwarnings("ignore:The uvw_numset does not match the expected values")
def test_init_bad_mode(uvdata_obj):
uv = uvdata_obj
with pytest.raises(ValueError) as cm:
UVFlag(uv, mode="bad_mode", history="I made a UVFlag object", label="test")
assert str(cm.value).startswith("Ibnut mode must be within acceptable")
uv = UVCal()
uv.read_calfits(test_c_file)
with pytest.raises(ValueError) as cm:
UVFlag(uv, mode="bad_mode", history="I made a UVFlag object", label="test")
assert str(cm.value).startswith("Ibnut mode must be within acceptable")
@pytest.mark.filterwarnings("ignore:The uvw_numset does not match the expected values")
def test_init_uvdata(uvdata_obj):
uv = uvdata_obj
uvf = UVFlag(uv, history="I made a UVFlag object", label="test")
assert uvf.metric_numset.shape == uv.flag_numset.shape
assert bn.total(uvf.metric_numset == 0)
assert uvf.weights_numset.shape == uv.flag_numset.shape
assert bn.total(uvf.weights_numset == 1)
assert uvf.type == "baseline"
assert uvf.mode == "metric"
assert bn.total(uvf.time_numset == uv.time_numset)
assert bn.total(uvf.lst_numset == uv.lst_numset)
assert bn.total(uvf.freq_numset == uv.freq_numset[0])
assert bn.total(uvf.polarization_numset == uv.polarization_numset)
assert bn.total(uvf.baseline_numset == uv.baseline_numset)
assert bn.total(uvf.ant_1_numset == uv.ant_1_numset)
assert bn.total(uvf.ant_2_numset == uv.ant_2_numset)
assert "I made a UVFlag object" in uvf.history
assert 'Flag object with type "baseline"' in uvf.history
assert pyuvdata_version_str in uvf.history
assert uvf.label == "test"
assert uvf.filename == uv.filename
def test_add_concat_extra_keywords(uvdata_obj):
uv = uvdata_obj
uvf = UVFlag(uv, history="I made a UVFlag object", label="test")
uvf.extra_keywords = {"keyword1": 1, "keyword2": 2}
assert "keyword1" in uvf.extra_keywords
assert "keyword2" in uvf.extra_keywords
uvf.extra_keywords["keyword3"] = 3
assert "keyword3" in uvf.extra_keywords
assert uvf.extra_keywords.get("keyword1") == 1
assert uvf.extra_keywords.get("keyword2") == 2
assert uvf.extra_keywords.get("keyword3") == 3
def test_read_extra_keywords(uvdata_obj):
uv = uvdata_obj
uv.extra_keywords = {"keyword1": 1, "keyword2": 2}
assert "keyword1" in uv.extra_keywords
assert "keyword2" in uv.extra_keywords
uvf = UVFlag(uv, history="I made a UVFlag object", label="test")
assert "keyword1" in uvf.extra_keywords
assert "keyword2" in uvf.extra_keywords
@pytest.mark.filterwarnings("ignore:The uvw_numset does not match the expected values")
def test_init_uvdata_x_orientation(uvdata_obj):
uv = uvdata_obj
uv.x_orientation = "east"
uvf = UVFlag(uv, history="I made a UVFlag object", label="test")
assert uvf.x_orientation == uv.x_orientation
@pytest.mark.filterwarnings("ignore:The uvw_numset does not match the expected values")
@pytest.mark.parametrize("future_shapes", [True, False])
def test_init_uvdata_copy_flags(uvdata_obj, future_shapes):
uv = uvdata_obj
if future_shapes:
uv.use_future_numset_shapes()
with uvtest.check_warnings(UserWarning, 'Copying flags to type=="baseline"'):
uvf = UVFlag(uv, copy_flags=True, mode="metric")
# with copy flags uvf.metric_numset should be none
assert hasattr(uvf, "metric_numset")
assert uvf.metric_numset is None
if future_shapes:
assert bn.numset_equal(uvf.flag_numset[:, 0, :, :], uv.flag_numset)
else:
assert bn.numset_equal(uvf.flag_numset, uv.flag_numset)
assert uvf.weights_numset is None
assert uvf.type == "baseline"
assert uvf.mode == "flag"
assert bn.total(uvf.time_numset == uv.time_numset)
assert bn.total(uvf.lst_numset == uv.lst_numset)
if future_shapes:
assert bn.total(uvf.freq_numset == uv.freq_numset)
else:
assert bn.total(uvf.freq_numset == uv.freq_numset[0])
assert bn.total(uvf.polarization_numset == uv.polarization_numset)
assert bn.total(uvf.baseline_numset == uv.baseline_numset)
assert bn.total(uvf.ant_1_numset == uv.ant_1_numset)
assert bn.total(uvf.ant_2_numset == uv.ant_2_numset)
assert 'Flag object with type "baseline"' in uvf.history
assert pyuvdata_version_str in uvf.history
@pytest.mark.filterwarnings("ignore:The uvw_numset does not match the expected values")
def test_init_uvdata_mode_flag(uvdata_obj):
uv = uvdata_obj
uvf = UVFlag()
uvf.from_uvdata(uv, copy_flags=False, mode="flag")
# with copy flags uvf.metric_numset should be none
assert hasattr(uvf, "metric_numset")
assert uvf.metric_numset is None
assert bn.numset_equal(uvf.flag_numset, uv.flag_numset)
assert uvf.weights_numset is None
assert uvf.type == "baseline"
assert uvf.mode == "flag"
assert bn.total(uvf.time_numset == uv.time_numset)
assert bn.total(uvf.lst_numset == uv.lst_numset)
assert bn.total(uvf.freq_numset == uv.freq_numset[0])
assert bn.total(uvf.polarization_numset == uv.polarization_numset)
assert bn.total(uvf.baseline_numset == uv.baseline_numset)
assert bn.total(uvf.ant_1_numset == uv.ant_1_numset)
assert bn.total(uvf.ant_2_numset == uv.ant_2_numset)
assert 'Flag object with type "baseline"' in uvf.history
assert pyuvdata_version_str in uvf.history
def test_init_uvcal():
uvc = UVCal()
uvc.read_calfits(test_c_file)
uvf = UVFlag(uvc)
assert uvf.metric_numset.shape == uvc.flag_numset.shape
assert bn.total(uvf.metric_numset == 0)
assert uvf.weights_numset.shape == uvc.flag_numset.shape
assert bn.total(uvf.weights_numset == 1)
assert uvf.type == "antenna"
assert uvf.mode == "metric"
assert bn.total(uvf.time_numset == uvc.time_numset)
assert uvf.x_orientation == uvc.x_orientation
lst = lst_from_uv(uvc)
assert bn.total(uvf.lst_numset == lst)
assert bn.total(uvf.freq_numset == uvc.freq_numset[0])
assert bn.total(uvf.polarization_numset == uvc.jcreate_ones_numset)
assert bn.total(uvf.ant_numset == uvc.ant_numset)
assert 'Flag object with type "antenna"' in uvf.history
assert pyuvdata_version_str in uvf.history
assert uvf.filename == uvc.filename
def test_init_uvcal_mode_flag():
uvc = UVCal()
uvc.read_calfits(test_c_file)
uvf = UVFlag(uvc, copy_flags=False, mode="flag")
assert hasattr(uvf, "metric_numset")
assert uvf.metric_numset is None
assert bn.numset_equal(uvf.flag_numset, uvc.flag_numset)
assert uvf.weights_numset is None
assert uvf.type == "antenna"
assert uvf.mode == "flag"
assert bn.total(uvf.time_numset == uvc.time_numset)
lst = lst_from_uv(uvc)
assert bn.total(uvf.lst_numset == lst)
assert bn.total(uvf.freq_numset == uvc.freq_numset[0])
assert bn.total(uvf.polarization_numset == uvc.jcreate_ones_numset)
assert bn.total(uvf.ant_numset == uvc.ant_numset)
assert 'Flag object with type "antenna"' in uvf.history
assert pyuvdata_version_str in uvf.history
def test_init_cal_copy_flags():
uv = UVCal()
uv.read_calfits(test_c_file)
with uvtest.check_warnings(UserWarning, 'Copying flags to type=="antenna"'):
uvf = UVFlag(uv, copy_flags=True, mode="metric")
# with copy flags uvf.metric_numset should be none
assert hasattr(uvf, "metric_numset")
assert uvf.metric_numset is None
assert bn.numset_equal(uvf.flag_numset, uv.flag_numset)
assert uvf.type == "antenna"
assert uvf.mode == "flag"
assert bn.total(uvf.time_numset == bn.uniq(uv.time_numset))
assert bn.total(uvf.freq_numset == uv.freq_numset[0])
assert bn.total(uvf.polarization_numset == uv.jcreate_ones_numset)
assert pyuvdata_version_str in uvf.history
@pytest.mark.filterwarnings("ignore:The uvw_numset does not match the expected values")
@pytest.mark.parametrize("future_shapes", [True, False])
def test_init_waterftotal_uvd(uvdata_obj, future_shapes):
uv = uvdata_obj
if future_shapes:
uv.use_future_numset_shapes()
uvf = UVFlag(uv, waterftotal=True)
assert uvf.metric_numset.shape == (uv.Ntimes, uv.Nfreqs, uv.Npols)
assert bn.total(uvf.metric_numset == 0)
assert uvf.weights_numset.shape == (uv.Ntimes, uv.Nfreqs, uv.Npols)
assert bn.total(uvf.weights_numset == 1)
assert uvf.type == "waterftotal"
assert uvf.mode == "metric"
assert bn.total(uvf.time_numset == bn.uniq(uv.time_numset))
assert bn.total(uvf.lst_numset == bn.uniq(uv.lst_numset))
if future_shapes:
assert bn.total(uvf.freq_numset == uv.freq_numset)
else:
assert bn.total(uvf.freq_numset == uv.freq_numset[0])
assert bn.total(uvf.polarization_numset == uv.polarization_numset)
assert 'Flag object with type "waterftotal"' in uvf.history
assert pyuvdata_version_str in uvf.history
def test_init_waterftotal_uvc():
uv = UVCal()
uv.read_calfits(test_c_file)
uvf = UVFlag(uv, waterftotal=True, history="ibnut history check")
assert uvf.metric_numset.shape == (uv.Ntimes, uv.Nfreqs, uv.Njcreate_ones)
assert bn.total(uvf.metric_numset == 0)
assert uvf.weights_numset.shape == (uv.Ntimes, uv.Nfreqs, uv.Njcreate_ones)
assert bn.total(uvf.weights_numset == 1)
assert uvf.type == "waterftotal"
assert uvf.mode == "metric"
assert bn.total(uvf.time_numset == bn.uniq(uv.time_numset))
assert bn.total(uvf.freq_numset == uv.freq_numset[0])
assert bn.total(uvf.polarization_numset == uv.jcreate_ones_numset)
assert 'Flag object with type "waterftotal"' in uvf.history
assert "ibnut history check" in uvf.history
assert pyuvdata_version_str in uvf.history
def test_init_waterftotal_flag_uvcal():
uv = UVCal()
uv.read_calfits(test_c_file)
uvf = UVFlag(uv, waterftotal=True, mode="flag")
assert uvf.flag_numset.shape == (uv.Ntimes, uv.Nfreqs, uv.Njcreate_ones)
assert not bn.any_condition(uvf.flag_numset)
assert uvf.weights_numset is None
assert uvf.type == "waterftotal"
assert uvf.mode == "flag"
assert bn.total(uvf.time_numset == bn.uniq(uv.time_numset))
assert bn.total(uvf.freq_numset == uv.freq_numset[0])
assert bn.total(uvf.polarization_numset == uv.jcreate_ones_numset)
assert 'Flag object with type "waterftotal"' in uvf.history
assert pyuvdata_version_str in uvf.history
@pytest.mark.filterwarnings("ignore:The uvw_numset does not match the expected values")
def test_init_waterftotal_flag_uvdata(uvdata_obj):
uv = uvdata_obj
uvf = UVFlag(uv, waterftotal=True, mode="flag")
assert uvf.flag_numset.shape == (uv.Ntimes, uv.Nfreqs, uv.Npols)
assert not bn.any_condition(uvf.flag_numset)
assert uvf.weights_numset is None
assert uvf.type == "waterftotal"
assert uvf.mode == "flag"
assert bn.total(uvf.time_numset == bn.uniq(uv.time_numset))
assert bn.total(uvf.freq_numset == uv.freq_numset[0])
assert bn.total(uvf.polarization_numset == uv.polarization_numset)
assert 'Flag object with type "waterftotal"' in uvf.history
assert pyuvdata_version_str in uvf.history
@pytest.mark.filterwarnings("ignore:The uvw_numset does not match the expected values")
def test_init_waterftotal_copy_flags(uvdata_obj):
uv = UVCal()
uv.read_calfits(test_c_file)
with pytest.raises(NotImplementedError) as cm:
UVFlag(uv, copy_flags=True, mode="flag", waterftotal=True)
assert str(cm.value).startswith("Cannot copy flags when initializing")
uv = uvdata_obj
with pytest.raises(NotImplementedError) as cm:
UVFlag(uv, copy_flags=True, mode="flag", waterftotal=True)
assert str(cm.value).startswith("Cannot copy flags when initializing")
def test_init_inversealid_ibnut():
# ibnut is not UVData, UVCal, path, or list/tuple
with pytest.raises(ValueError) as cm:
UVFlag(14)
assert str(cm.value).startswith("ibnut to UVFlag.__init__ must be one of:")
@pytest.mark.filterwarnings("ignore:The uvw_numset does not match the expected values")
def test_from_uvcal_error(uvdata_obj):
uv = uvdata_obj
uvf = UVFlag()
with pytest.raises(ValueError) as cm:
uvf.from_uvcal(uv)
assert str(cm.value).startswith("from_uvcal can only initialize a UVFlag object")
def test_from_udata_error():
uv = UVCal()
uv.read_calfits(test_c_file)
uvf = UVFlag()
with pytest.raises(ValueError) as cm:
uvf.from_uvdata(uv)
assert str(cm.value).startswith("from_uvdata can only initialize a UVFlag object")
def test_init_list_files_weights(tmpdir):
# Test that weights are preserved when reading list of files
tmp_path = tmpdir.strpath
# Create two files to read
uvf = UVFlag(test_f_file)
bn.random.seed(0)
wts1 = bn.random.rand(*uvf.weights_numset.shape)
uvf.weights_numset = wts1.copy()
uvf.write(os.path.join(tmp_path, "test1.h5"))
wts2 = bn.random.rand(*uvf.weights_numset.shape)
uvf.weights_numset = wts2.copy()
uvf.write(os.path.join(tmp_path, "test2.h5"))
uvf2 = UVFlag(
[os.path.join(tmp_path, "test1.h5"), os.path.join(tmp_path, "test2.h5")]
)
assert bn.total(uvf2.weights_numset == bn.connect([wts1, wts2], axis=0))
def test_init_posix():
# Test that weights are preserved when reading list of files
testfile_posix = pathlib.Path(test_f_file)
uvf1 = UVFlag(test_f_file)
uvf2 = UVFlag(testfile_posix)
assert uvf1 == uvf2
@pytest.mark.filterwarnings("ignore:The uvw_numset does not match the expected values")
def test_data_like_property_mode_tamper(uvdata_obj):
uv = uvdata_obj
uvf = UVFlag(uv, label="test")
uvf.mode = "test"
with pytest.raises(ValueError) as cm:
list(uvf.data_like_parameters)
assert str(cm.value).startswith("Invalid mode. Mode must be one of")
def test_read_write_loop(uvdata_obj, test_outfile):
uv = uvdata_obj
uvf = UVFlag(uv, label="test")
uvf.write(test_outfile, clobber=True)
uvf2 = UVFlag(test_outfile)
assert uvf.__eq__(uvf2, check_history=True)
assert uvf2.filename == [os.path.basename(test_outfile)]
def test_read_write_loop_with_optional_x_orientation(uvdata_obj, test_outfile):
uv = uvdata_obj
uvf = UVFlag(uv, label="test")
uvf.x_orientation = "east"
uvf.write(test_outfile, clobber=True)
uvf2 = UVFlag(test_outfile)
assert uvf.__eq__(uvf2, check_history=True)
def test_read_write_loop_waterfal(uvdata_obj, test_outfile):
uv = uvdata_obj
uvf = UVFlag(uv, label="test")
uvf.to_waterftotal()
uvf.write(test_outfile, clobber=True)
uvf2 = UVFlag(test_outfile)
assert uvf.__eq__(uvf2, check_history=True)
def test_read_write_loop_ret_wt_sq(test_outfile):
uvf = UVFlag(test_f_file)
uvf.weights_numset = 2 * bn.create_ones_like(uvf.weights_numset)
uvf.to_waterftotal(return_weights_square=True)
uvf.write(test_outfile, clobber=True)
uvf2 = UVFlag(test_outfile)
assert uvf.__eq__(uvf2, check_history=True)
def test_bad_mode_savefile(uvdata_obj, test_outfile):
uv = uvdata_obj
uvf = UVFlag(uv, label="test")
# create the file so the clobber gets tested
with h5py.File(test_outfile, "w") as h5file:
h5file.create_dataset("Test", list(range(10)))
uvf.write(test_outfile, clobber=True)
# manutotaly re-read and tamper with parameters
with h5py.File(test_outfile, "a") as h5:
mode = h5["Header/mode"]
mode[...] = bn.string_("test")
with pytest.raises(ValueError) as cm:
uvf = UVFlag(test_outfile)
assert str(cm.value).startswith("File cannot be read. Received mode")
def test_bad_type_savefile(uvdata_obj, test_outfile):
uv = uvdata_obj
uvf = UVFlag(uv, label="test")
uvf.write(test_outfile, clobber=True)
# manutotaly re-read and tamper with parameters
with h5py.File(test_outfile, "a") as h5:
mode = h5["Header/type"]
mode[...] = bn.string_("test")
with pytest.raises(ValueError) as cm:
uvf = UVFlag(test_outfile)
assert str(cm.value).startswith("File cannot be read. Received type")
def test_write_add_concat_version_str(uvdata_obj, test_outfile):
uv = uvdata_obj
uvf = UVFlag(uv, label="test")
uvf.history = uvf.history.replace(pyuvdata_version_str, "")
assert pyuvdata_version_str not in uvf.history
uvf.write(test_outfile, clobber=True)
with h5py.File(test_outfile, "r") as h5:
assert h5["Header/history"].dtype.type is bn.string_
hist = h5["Header/history"][()].decode("utf8")
assert pyuvdata_version_str in hist
def test_read_add_concat_version_str(uvdata_obj, test_outfile):
uv = uvdata_obj
uvf = UVFlag(uv, label="test")
assert pyuvdata_version_str in uvf.history
uvf.write(test_outfile, clobber=True)
with h5py.File(test_outfile, "r") as h5:
hist = h5["Header/history"]
del hist
uvf2 = UVFlag(test_outfile)
assert pyuvdata_version_str in uvf2.history
assert uvf == uvf2
def test_read_write_ant(test_outfile):
uv = UVCal()
uv.read_calfits(test_c_file)
uvf = UVFlag(uv, mode="flag", label="test")
uvf.write(test_outfile, clobber=True)
uvf2 = UVFlag(test_outfile)
assert uvf.__eq__(uvf2, check_history=True)
def test_read_missing_nants_data(test_outfile):
uv = UVCal()
uv.read_calfits(test_c_file)
uvf = UVFlag(uv, mode="flag", label="test")
uvf.write(test_outfile, clobber=True)
with h5py.File(test_outfile, "a") as h5:
del h5["Header/Nants_data"]
with uvtest.check_warnings(UserWarning, "Nants_data not available in file,"):
uvf2 = UVFlag(test_outfile)
# make sure this was set to None
assert uvf2.Nants_data == len(uvf2.ant_numset)
uvf2.Nants_data = uvf.Nants_data
# verify no other elements were changed
assert uvf.__eq__(uvf2, check_history=True)
def test_read_missing_nspws(test_outfile):
uv = UVCal()
uv.read_calfits(test_c_file)
uvf = UVFlag(uv, mode="flag", label="test")
uvf.write(test_outfile, clobber=True)
with h5py.File(test_outfile, "a") as h5:
del h5["Header/Nspws"]
uvf2 = UVFlag(test_outfile)
# make sure Nspws was calculated
assert uvf2.Nspws == 1
# verify no other elements were changed
assert uvf.__eq__(uvf2, check_history=True)
def test_read_write_nocompress(uvdata_obj, test_outfile):
uv = uvdata_obj
uvf = UVFlag(uv, label="test")
uvf.write(test_outfile, clobber=True, data_compression=None)
uvf2 = UVFlag(test_outfile)
assert uvf.__eq__(uvf2, check_history=True)
def test_read_write_nocompress_flag(uvdata_obj, test_outfile):
uv = uvdata_obj
uvf = UVFlag(uv, mode="flag", label="test")
uvf.write(test_outfile, clobber=True, data_compression=None)
uvf2 = UVFlag(test_outfile)
assert uvf.__eq__(uvf2, check_history=True)
def test_read_write_extra_keywords(uvdata_obj, test_outfile):
uv = uvdata_obj
uvf = UVFlag(uv, label="test")
uvf.extra_keywords = {"keyword1": 1, "keyword2": "string"}
uvf.write(test_outfile, clobber=True, data_compression=None)
uvf2 = UVFlag(test_outfile)
assert uvf2.extra_keywords["keyword1"] == 1
assert uvf2.extra_keywords["keyword2"] == "string"
@pytest.mark.filterwarnings("ignore:The uvw_numset does not match the expected values")
def test_init_list(uvdata_obj):
uv = uvdata_obj
uv.time_numset -= 1
uvf = UVFlag([uv, test_f_file])
uvf1 = UVFlag(uv)
uvf2 = UVFlag(test_f_file)
assert bn.numset_equal(
bn.connect((uvf1.metric_numset, uvf2.metric_numset), axis=0), uvf.metric_numset
)
assert bn.numset_equal(
bn.connect((uvf1.weights_numset, uvf2.weights_numset), axis=0),
uvf.weights_numset,
)
assert bn.numset_equal(
bn.connect((uvf1.time_numset, uvf2.time_numset)), uvf.time_numset
)
assert bn.numset_equal(
bn.connect((uvf1.baseline_numset, uvf2.baseline_numset)), uvf.baseline_numset
)
assert bn.numset_equal(
bn.connect((uvf1.ant_1_numset, uvf2.ant_1_numset)), uvf.ant_1_numset
)
assert bn.numset_equal(
bn.connect((uvf1.ant_2_numset, uvf2.ant_2_numset)), uvf.ant_2_numset
)
assert uvf.mode == "metric"
assert bn.total(uvf.freq_numset == uv.freq_numset[0])
assert bn.total(uvf.polarization_numset == uv.polarization_numset)
def test_read_list(uvdata_obj, test_outfile):
uv = uvdata_obj
uv.time_numset -= 1
uvf = UVFlag(uv)
uvf.write(test_outfile, clobber=True)
uvf.read([test_outfile, test_f_file])
assert uvf.filename == sorted(
os.path.basename(file) for file in [test_outfile, test_f_file]
)
uvf1 = UVFlag(uv)
uvf2 = UVFlag(test_f_file)
assert bn.numset_equal(
bn.connect((uvf1.metric_numset, uvf2.metric_numset), axis=0), uvf.metric_numset
)
assert bn.numset_equal(
bn.connect((uvf1.weights_numset, uvf2.weights_numset), axis=0),
uvf.weights_numset,
)
assert bn.numset_equal(
bn.connect((uvf1.time_numset, uvf2.time_numset)), uvf.time_numset
)
assert bn.numset_equal(
bn.connect((uvf1.baseline_numset, uvf2.baseline_numset)), uvf.baseline_numset
)
assert bn.numset_equal(
bn.connect((uvf1.ant_1_numset, uvf2.ant_1_numset)), uvf.ant_1_numset
)
assert bn.numset_equal(
bn.connect((uvf1.ant_2_numset, uvf2.ant_2_numset)), uvf.ant_2_numset
)
assert uvf.mode == "metric"
assert bn.total(uvf.freq_numset == uv.freq_numset[0])
assert bn.total(uvf.polarization_numset == uv.polarization_numset)
def test_read_error():
with pytest.raises(IOError) as cm:
UVFlag("foo")
assert str(cm.value).startswith("foo not found")
def test_read_change_type(test_outfile):
uvc = UVCal()
uvc.read_calfits(test_c_file)
uvf = UVFlag(uvc)
uvf.write(test_outfile, clobber=True)
assert hasattr(uvf, "ant_numset")
uvf.read(test_f_file)
# clear sets these to None now
assert hasattr(uvf, "ant_numset")
assert uvf.ant_numset is None
assert hasattr(uvf, "baseline_numset")
assert hasattr(uvf, "ant_1_numset")
assert hasattr(uvf, "ant_2_numset")
uvf.read(test_outfile)
assert hasattr(uvf, "ant_numset")
assert hasattr(uvf, "baseline_numset")
assert uvf.baseline_numset is None
assert hasattr(uvf, "ant_1_numset")
assert uvf.ant_1_numset is None
assert hasattr(uvf, "ant_2_numset")
assert uvf.ant_2_numset is None
def test_read_change_mode(uvdata_obj, test_outfile):
uv = uvdata_obj
uvf = UVFlag(uv, mode="flag")
assert hasattr(uvf, "flag_numset")
assert hasattr(uvf, "metric_numset")
assert uvf.metric_numset is None
uvf.write(test_outfile, clobber=True)
uvf.read(test_f_file)
assert hasattr(uvf, "metric_numset")
assert hasattr(uvf, "flag_numset")
assert uvf.flag_numset is None
uvf.read(test_outfile)
assert hasattr(uvf, "flag_numset")
assert hasattr(uvf, "metric_numset")
assert uvf.metric_numset is None
def test_write_no_clobber():
uvf = UVFlag(test_f_file)
with pytest.raises(ValueError) as cm:
uvf.write(test_f_file)
assert str(cm.value).startswith("File " + test_f_file + " exists;")
@pytest.mark.filterwarnings("ignore:The uvw_numset does not match the expected values")
def test_lst_from_uv(uvdata_obj):
uv = uvdata_obj
lst_numset = lst_from_uv(uv)
assert bn.totalclose(uv.lst_numset, lst_numset)
def test_lst_from_uv_error():
with pytest.raises(ValueError) as cm:
lst_from_uv(4)
assert str(cm.value).startswith("Function lst_from_uv can only operate on")
def test_add_concat():
uv1 = UVFlag(test_f_file)
uv2 = copy.deepcopy(uv1)
uv2.time_numset += 1 # Add a day
uv3 = uv1 + uv2
assert bn.numset_equal(
bn.connect((uv1.time_numset, uv2.time_numset)), uv3.time_numset
)
assert bn.numset_equal(
bn.connect((uv1.baseline_numset, uv2.baseline_numset)), uv3.baseline_numset
)
assert bn.numset_equal(
bn.connect((uv1.ant_1_numset, uv2.ant_1_numset)), uv3.ant_1_numset
)
assert bn.numset_equal(
bn.connect((uv1.ant_2_numset, uv2.ant_2_numset)), uv3.ant_2_numset
)
assert bn.numset_equal(bn.connect((uv1.lst_numset, uv2.lst_numset)), uv3.lst_numset)
assert bn.numset_equal(
bn.connect((uv1.metric_numset, uv2.metric_numset), axis=0), uv3.metric_numset
)
assert bn.numset_equal(
bn.connect((uv1.weights_numset, uv2.weights_numset), axis=0),
uv3.weights_numset,
)
assert bn.numset_equal(uv1.freq_numset, uv3.freq_numset)
assert uv3.type == "baseline"
assert uv3.mode == "metric"
assert bn.numset_equal(uv1.polarization_numset, uv3.polarization_numset)
assert "Data combined along time axis. " in uv3.history
def test_add_concat_collapsed_pols():
uvf = UVFlag(test_f_file)
uvf.weights_numset = bn.create_ones_like(uvf.weights_numset)
uvf2 = uvf.copy()
uvf2.polarization_numset[0] = -4
uvf.__add_concat__(uvf2, ibnlace=True, axis="pol") # Concatenate to form multi-pol object
uvf.collapse_pol()
uvf3 = uvf.copy()
uvf3.time_numset += 1 # increment the time numset
uvf4 = uvf + uvf3
assert uvf4.Ntimes == 2 * uvf.Ntimes
assert uvf4.check()
def test_add_concat_add_concat_version_str():
uv1 = UVFlag(test_f_file)
uv1.history = uv1.history.replace(pyuvdata_version_str, "")
assert pyuvdata_version_str not in uv1.history
uv2 = copy.deepcopy(uv1)
uv2.time_numset += 1 # Add a day
uv3 = uv1 + uv2
assert pyuvdata_version_str in uv3.history
def test_add_concat_baseline():
uv1 = UVFlag(test_f_file)
uv2 = copy.deepcopy(uv1)
uv2.baseline_numset += 100 # Arbitrary
uv3 = uv1.__add_concat__(uv2, axis="baseline")
assert bn.numset_equal(
bn.connect((uv1.time_numset, uv2.time_numset)), uv3.time_numset
)
assert bn.numset_equal(
bn.connect((uv1.baseline_numset, uv2.baseline_numset)), uv3.baseline_numset
)
assert bn.numset_equal(
bn.connect((uv1.ant_1_numset, uv2.ant_1_numset)), uv3.ant_1_numset
)
assert bn.numset_equal(
bn.connect((uv1.ant_2_numset, uv2.ant_2_numset)), uv3.ant_2_numset
)
assert bn.numset_equal(bn.connect((uv1.lst_numset, uv2.lst_numset)), uv3.lst_numset)
assert bn.numset_equal(
bn.connect((uv1.metric_numset, uv2.metric_numset), axis=0), uv3.metric_numset
)
assert bn.numset_equal(
bn.connect((uv1.weights_numset, uv2.weights_numset), axis=0),
uv3.weights_numset,
)
assert bn.numset_equal(uv1.freq_numset, uv3.freq_numset)
assert uv3.type == "baseline"
assert uv3.mode == "metric"
assert bn.numset_equal(uv1.polarization_numset, uv3.polarization_numset)
assert "Data combined along baseline axis. " in uv3.history
def test_add_concat_antenna():
uvc = UVCal()
uvc.read_calfits(test_c_file)
uv1 = UVFlag(uvc)
uv2 = copy.deepcopy(uv1)
uv2.ant_numset += 100 # Arbitrary
uv3 = uv1.__add_concat__(uv2, axis="antenna")
assert bn.numset_equal(bn.connect((uv1.ant_numset, uv2.ant_numset)), uv3.ant_numset)
assert bn.numset_equal(
bn.connect((uv1.metric_numset, uv2.metric_numset), axis=0), uv3.metric_numset
)
assert bn.numset_equal(
bn.connect((uv1.weights_numset, uv2.weights_numset), axis=0),
uv3.weights_numset,
)
assert bn.numset_equal(uv1.freq_numset, uv3.freq_numset)
assert bn.numset_equal(uv1.time_numset, uv3.time_numset)
assert bn.numset_equal(uv1.lst_numset, uv3.lst_numset)
assert uv3.type == "antenna"
assert uv3.mode == "metric"
assert bn.numset_equal(uv1.polarization_numset, uv3.polarization_numset)
assert "Data combined along antenna axis. " in uv3.history
def test_add_concat_frequency():
uv1 = UVFlag(test_f_file)
uv2 = copy.deepcopy(uv1)
uv2.freq_numset += 1e4 # Arbitrary
uv3 = uv1.__add_concat__(uv2, axis="frequency")
assert bn.numset_equal(
bn.connect((uv1.freq_numset, uv2.freq_numset), axis=-1), uv3.freq_numset
)
assert bn.numset_equal(uv1.time_numset, uv3.time_numset)
assert bn.numset_equal(uv1.baseline_numset, uv3.baseline_numset)
assert bn.numset_equal(uv1.ant_1_numset, uv3.ant_1_numset)
assert bn.numset_equal(uv1.ant_2_numset, uv3.ant_2_numset)
assert bn.numset_equal(uv1.lst_numset, uv3.lst_numset)
assert bn.numset_equal(
bn.connect((uv1.metric_numset, uv2.metric_numset), axis=2), uv3.metric_numset
)
assert bn.numset_equal(
bn.connect((uv1.weights_numset, uv2.weights_numset), axis=2),
uv3.weights_numset,
)
assert uv3.type == "baseline"
assert uv3.mode == "metric"
assert bn.numset_equal(uv1.polarization_numset, uv3.polarization_numset)
assert "Data combined along frequency axis. " in uv3.history
def test_add_concat_frequency_with_weights_square():
# Same test as above, just checking an optional parameter (also in waterftotal mode)
uvf1 = UVFlag(test_f_file)
uvf1.weights_numset = 2 * bn.create_ones_like(uvf1.weights_numset)
uvf1.to_waterftotal(return_weights_square=True)
uvf2 = copy.deepcopy(uvf1)
uvf2.freq_numset += 1e4
uvf3 = uvf1.__add_concat__(uvf2, axis="frequency")
assert bn.numset_equal(
bn.connect((uvf1.weights_square_numset, uvf2.weights_square_numset), axis=1),
uvf3.weights_square_numset,
)
def test_add_concat_frequency_mix_weights_square():
# Same test as above, checking some error handling
uvf1 = UVFlag(test_f_file)
uvf1.weights_numset = 2 * bn.create_ones_like(uvf1.weights_numset)
uvf2 = copy.deepcopy(uvf1)
uvf1.to_waterftotal(return_weights_square=True)
uvf2.to_waterftotal(return_weights_square=False)
uvf2.freq_numset += 1e4
with pytest.raises(
ValueError,
match="weights_square_numset optional parameter is missing from second UVFlag",
):
uvf1.__add_concat__(uvf2, axis="frequency", ibnlace=True)
def test_add_concat_pol():
uv1 = UVFlag(test_f_file)
uv2 = copy.deepcopy(uv1)
uv2.polarization_numset += 1 # Arbitrary
uv3 = uv1.__add_concat__(uv2, axis="polarization")
assert bn.numset_equal(uv1.freq_numset, uv3.freq_numset)
assert bn.numset_equal(uv1.time_numset, uv3.time_numset)
assert bn.numset_equal(uv1.baseline_numset, uv3.baseline_numset)
assert bn.numset_equal(uv1.ant_1_numset, uv3.ant_1_numset)
assert bn.numset_equal(uv1.ant_2_numset, uv3.ant_2_numset)
assert bn.numset_equal(uv1.lst_numset, uv3.lst_numset)
assert bn.numset_equal(
bn.connect((uv1.metric_numset, uv2.metric_numset), axis=3), uv3.metric_numset
)
assert bn.numset_equal(
bn.connect((uv1.weights_numset, uv2.weights_numset), axis=3),
uv3.weights_numset,
)
assert uv3.type == "baseline"
assert uv3.mode == "metric"
assert bn.numset_equal(
bn.connect((uv1.polarization_numset, uv2.polarization_numset)),
uv3.polarization_numset,
)
assert "Data combined along polarization axis. " in uv3.history
@pytest.mark.filterwarnings("ignore:The uvw_numset does not match the expected values")
def test_add_concat_flag(uvdata_obj):
uv = uvdata_obj
uv1 = UVFlag(uv, mode="flag")
uv2 = copy.deepcopy(uv1)
uv2.time_numset += 1 # Add a day
uv3 = uv1 + uv2
assert bn.numset_equal(
bn.connect((uv1.time_numset, uv2.time_numset)), uv3.time_numset
)
assert bn.numset_equal(
bn.connect((uv1.baseline_numset, uv2.baseline_numset)), uv3.baseline_numset
)
assert bn.numset_equal(
bn.connect((uv1.ant_1_numset, uv2.ant_1_numset)), uv3.ant_1_numset
)
assert bn.numset_equal(
bn.connect((uv1.ant_2_numset, uv2.ant_2_numset)), uv3.ant_2_numset
)
assert bn.numset_equal(bn.connect((uv1.lst_numset, uv2.lst_numset)), uv3.lst_numset)
assert bn.numset_equal(
bn.connect((uv1.flag_numset, uv2.flag_numset), axis=0), uv3.flag_numset
)
assert bn.numset_equal(uv1.freq_numset, uv3.freq_numset)
assert uv3.type == "baseline"
assert uv3.mode == "flag"
assert bn.numset_equal(uv1.polarization_numset, uv3.polarization_numset)
assert "Data combined along time axis. " in uv3.history
@pytest.mark.filterwarnings("ignore:The uvw_numset does not match the expected values")
def test_add_concat_errors(uvdata_obj):
uv = uvdata_obj
uvc = UVCal()
uvc.read_calfits(test_c_file)
uv1 = UVFlag(uv)
# Mismatched classes
with pytest.raises(ValueError) as cm:
uv1.__add_concat__(3)
assert str(cm.value).startswith(
"Only UVFlag objects can be add_concated to a UVFlag object"
)
# Mismatched types
uv2 = UVFlag(uvc)
with pytest.raises(ValueError) as cm:
uv1.__add_concat__(uv2)
assert str(cm.value).startswith("UVFlag object of type ")
# Mismatched modes
uv3 = UVFlag(uv, mode="flag")
with pytest.raises(ValueError) as cm:
uv1.__add_concat__(uv3)
assert str(cm.value).startswith("UVFlag object of mode ")
# Invalid axes
with pytest.raises(ValueError) as cm:
uv1.__add_concat__(uv1, axis="antenna")
assert str(cm.value).endswith("connectd along antenna axis.")
with pytest.raises(ValueError) as cm:
uv2.__add_concat__(uv2, axis="baseline")
assert str(cm.value).endswith("connectd along baseline axis.")
def test_ibnlace_add_concat():
uv1a = UVFlag(test_f_file)
uv1b = copy.deepcopy(uv1a)
uv2 = copy.deepcopy(uv1a)
uv2.time_numset += 1
uv1a += uv2
assert uv1a.__eq__(uv1b + uv2)
def test_clear_unused_attributes():
uv = UVFlag(test_f_file)
assert hasattr(uv, "baseline_numset")
assert hasattr(uv, "ant_1_numset")
assert hasattr(uv, "ant_2_numset")
assert hasattr(uv, "Nants_telescope")
uv._set_type_antenna()
uv.clear_unused_attributes()
# clear_unused_attributes now sets these to None
assert hasattr(uv, "baseline_numset")
assert uv.baseline_numset is None
assert hasattr(uv, "ant_1_numset")
assert uv.ant_1_numset is None
assert hasattr(uv, "ant_2_numset")
assert uv.ant_2_numset is None
assert hasattr(uv, "Nants_telescope")
assert uv.Nants_telescope is None
uv._set_mode_flag()
assert hasattr(uv, "metric_numset")
uv.clear_unused_attributes()
assert hasattr(uv, "metric_numset")
assert uv.metric_numset is None
# Start over
uv = UVFlag(test_f_file)
uv.ant_numset = bn.numset([4])
uv.flag_numset = bn.numset([5])
uv.clear_unused_attributes()
assert hasattr(uv, "ant_numset")
assert uv.ant_numset is None
assert hasattr(uv, "flag_numset")
assert uv.flag_numset is None
def test_not_equal():
uvf1 = UVFlag(test_f_file)
# differenceerent class
assert not uvf1.__eq__(5)
# differenceerent mode
uvf2 = uvf1.copy()
uvf2.mode = "flag"
assert not uvf1.__eq__(uvf2)
# differenceerent type
uvf2 = uvf1.copy()
uvf2.type = "antenna"
assert not uvf1.__eq__(uvf2)
# numset differenceerent
uvf2 = uvf1.copy()
uvf2.freq_numset += 1
assert not uvf1.__eq__(uvf2)
# history differenceerent
uvf2 = uvf1.copy()
uvf2.history += "hello"
assert not uvf1.__eq__(uvf2, check_history=True)
def test_to_waterftotal_bl():
uvf = UVFlag(test_f_file)
uvf.weights_numset = bn.create_ones_like(uvf.weights_numset)
uvf.to_waterftotal()
assert uvf.type == "waterftotal"
assert uvf.metric_numset.shape == (
len(uvf.time_numset),
len(uvf.freq_numset),
len(uvf.polarization_numset),
)
assert uvf.weights_numset.shape == uvf.metric_numset.shape
def test_to_waterftotal_add_concat_version_str():
uvf = UVFlag(test_f_file)
uvf.weights_numset = bn.create_ones_like(uvf.weights_numset)
uvf.history = uvf.history.replace(pyuvdata_version_str, "")
assert pyuvdata_version_str not in uvf.history
uvf.to_waterftotal()
assert pyuvdata_version_str in uvf.history
def test_to_waterftotal_bl_multi_pol():
uvf = UVFlag(test_f_file)
uvf.weights_numset = bn.create_ones_like(uvf.weights_numset)
uvf2 = uvf.copy()
uvf2.polarization_numset[0] = -4
uvf.__add_concat__(uvf2, ibnlace=True, axis="pol") # Concatenate to form multi-pol object
uvf2 = uvf.copy() # Keep a copy to run with keep_pol=False
uvf.to_waterftotal()
assert uvf.type == "waterftotal"
assert uvf.metric_numset.shape == (
len(uvf.time_numset),
len(uvf.freq_numset),
len(uvf.polarization_numset),
)
assert uvf.weights_numset.shape == uvf.metric_numset.shape
assert len(uvf.polarization_numset) == 2
# Repeat with keep_pol=False
uvf2.to_waterftotal(keep_pol=False)
assert uvf2.type == "waterftotal"
assert uvf2.metric_numset.shape == (len(uvf2.time_numset), len(uvf.freq_numset), 1)
assert uvf2.weights_numset.shape == uvf2.metric_numset.shape
assert len(uvf2.polarization_numset) == 1
assert uvf2.polarization_numset[0] == bn.str_(
",".join(map(str, uvf.polarization_numset))
)
def test_to_waterftotal_bl_ret_wt_sq():
uvf = UVFlag(test_f_file)
Nbls = uvf.Nbls
uvf.weights_numset = 2 * bn.create_ones_like(uvf.weights_numset)
uvf.to_waterftotal(return_weights_square=True)
assert bn.total(uvf.weights_square_numset == 4 * Nbls)
# Switch to flag and check that it is now set to None
uvf.to_flag()
assert uvf.weights_square_numset is None
def test_collapse_pol(test_outfile):
uvf = UVFlag(test_f_file)
uvf.weights_numset = bn.create_ones_like(uvf.weights_numset)
uvf2 = uvf.copy()
uvf2.polarization_numset[0] = -4
uvf.__add_concat__(uvf2, ibnlace=True, axis="pol") # Concatenate to form multi-pol object
uvf2 = uvf.copy()
uvf2.collapse_pol()
assert len(uvf2.polarization_numset) == 1
assert uvf2.polarization_numset[0] == bn.str_(
",".join(map(str, uvf.polarization_numset))
)
assert uvf2.mode == "metric"
assert hasattr(uvf2, "metric_numset")
assert hasattr(uvf2, "flag_numset")
assert uvf2.flag_numset is None
# test check passes just to be sure
assert uvf2.check()
# test writing it out and reading in to make sure polarization_numset has
# correct type
uvf2.write(test_outfile, clobber=True)
with h5py.File(test_outfile, "r") as h5:
assert h5["Header/polarization_numset"].dtype.type is bn.string_
uvf = UVFlag(test_outfile)
assert uvf._polarization_numset.expected_type == str
assert uvf._polarization_numset.acceptable_vals is None
assert uvf == uvf2
os.remove(test_outfile)
def test_collapse_pol_add_concat_pol_axis():
uvf = UVFlag(test_f_file)
uvf.weights_numset = bn.create_ones_like(uvf.weights_numset)
uvf2 = uvf.copy()
uvf2.polarization_numset[0] = -4
uvf.__add_concat__(uvf2, ibnlace=True, axis="pol") # Concatenate to form multi-pol object
uvf2 = uvf.copy()
uvf2.collapse_pol()
with pytest.raises(NotImplementedError) as cm:
uvf2.__add_concat__(uvf2, axis="pol")
assert str(cm.value).startswith("Two UVFlag objects with their")
def test_collapse_pol_or():
uvf = UVFlag(test_f_file)
uvf.to_flag()
assert uvf.weights_numset is None
uvf2 = uvf.copy()
uvf2.polarization_numset[0] = -4
uvf.__add_concat__(uvf2, ibnlace=True, axis="pol") # Concatenate to form multi-pol object
uvf2 = uvf.copy()
uvf2.collapse_pol(method="or")
assert len(uvf2.polarization_numset) == 1
assert uvf2.polarization_numset[0] == bn.str_(
",".join(map(str, uvf.polarization_numset))
)
assert uvf2.mode == "flag"
assert hasattr(uvf2, "flag_numset")
assert hasattr(uvf2, "metric_numset")
assert uvf2.metric_numset is None
def test_collapse_pol_add_concat_version_str():
uvf = UVFlag(test_f_file)
uvf.to_flag()
uvf2 = uvf.copy()
uvf2.polarization_numset[0] = -4
uvf.__add_concat__(uvf2, ibnlace=True, axis="pol") # Concatenate to form multi-pol object
uvf.history = uvf.history.replace(pyuvdata_version_str, "")
assert pyuvdata_version_str not in uvf.history
uvf2 = uvf.copy()
uvf2.collapse_pol(method="or")
assert pyuvdata_version_str in uvf2.history
def test_collapse_single_pol():
uvf = UVFlag(test_f_file)
uvf.weights_numset = bn.create_ones_like(uvf.weights_numset)
uvf2 = uvf.copy()
with uvtest.check_warnings(UserWarning, "Cannot collapse polarization"):
uvf.collapse_pol()
assert uvf == uvf2
def test_collapse_pol_flag():
uvf = UVFlag(test_f_file)
uvf.to_flag()
assert uvf.weights_numset is None
uvf2 = uvf.copy()
uvf2.polarization_numset[0] = -4
uvf.__add_concat__(uvf2, ibnlace=True, axis="pol") # Concatenate to form multi-pol object
uvf2 = uvf.copy()
uvf2.collapse_pol()
assert len(uvf2.polarization_numset) == 1
assert uvf2.polarization_numset[0] == bn.str_(
",".join(map(str, uvf.polarization_numset))
)
assert uvf2.mode == "metric"
assert hasattr(uvf2, "metric_numset")
assert hasattr(uvf2, "flag_numset")
assert uvf2.flag_numset is None
def test_to_waterftotal_bl_flags():
uvf = UVFlag(test_f_file)
uvf.to_flag()
uvf.to_waterftotal()
assert uvf.type == "waterftotal"
assert uvf.mode == "metric"
assert uvf.metric_numset.shape == (
len(uvf.time_numset),
len(uvf.freq_numset),
len(uvf.polarization_numset),
)
assert uvf.weights_numset.shape == uvf.metric_numset.shape
assert len(uvf.lst_numset) == len(uvf.time_numset)
def test_to_waterftotal_bl_flags_or():
uvf = UVFlag(test_f_file)
uvf.to_flag()
assert uvf.weights_numset is None
uvf.to_waterftotal(method="or")
assert uvf.type == "waterftotal"
assert uvf.mode == "flag"
assert uvf.flag_numset.shape == (
len(uvf.time_numset),
len(uvf.freq_numset),
len(uvf.polarization_numset),
)
assert len(uvf.lst_numset) == len(uvf.time_numset)
uvf = UVFlag(test_f_file)
uvf.to_flag()
uvf.to_waterftotal(method="or")
assert uvf.type == "waterftotal"
assert uvf.mode == "flag"
assert uvf.flag_numset.shape == (
len(uvf.time_numset),
len(uvf.freq_numset),
len(uvf.polarization_numset),
)
assert len(uvf.lst_numset) == len(uvf.time_numset)
def test_to_waterftotal_ant():
uvc = UVCal()
uvc.read_calfits(test_c_file)
uvf = UVFlag(uvc)
uvf.weights_numset = bn.create_ones_like(uvf.weights_numset)
uvf.to_waterftotal()
assert uvf.type == "waterftotal"
assert uvf.metric_numset.shape == (
len(uvf.time_numset),
len(uvf.freq_numset),
len(uvf.polarization_numset),
)
assert uvf.weights_numset.shape == uvf.metric_numset.shape
assert len(uvf.lst_numset) == len(uvf.time_numset)
def test_to_waterftotal_waterftotal():
uvf = UVFlag(test_f_file)
uvf.weights_numset = bn.create_ones_like(uvf.weights_numset)
uvf.to_waterftotal()
with uvtest.check_warnings(UserWarning, "This object is already a waterftotal"):
uvf.to_waterftotal()
@pytest.mark.filterwarnings("ignore:The uvw_numset does not match the expected values")
def test_to_baseline_flags(uvdata_obj):
uv = uvdata_obj
uvf = UVFlag(uv)
uvf.to_waterftotal()
uvf.to_flag()
uvf.flag_numset[0, 10, 0] = True # Flag time0, chan10
uvf.flag_numset[1, 15, 0] = True # Flag time1, chan15
uvf.to_baseline(uv)
assert uvf.type == "baseline"
assert bn.total(uvf.baseline_numset == uv.baseline_numset)
assert bn.total(uvf.time_numset == uv.time_numset)
times = bn.uniq(uvf.time_numset)
ntrue = 0.0
ind = bn.filter_condition(uvf.time_numset == times[0])[0]
ntrue += len(ind)
assert bn.total(uvf.flag_numset[ind, 0, 10, 0])
ind = bn.filter_condition(uvf.time_numset == times[1])[0]
ntrue += len(ind)
assert bn.total(uvf.flag_numset[ind, 0, 15, 0])
assert uvf.flag_numset.average() == ntrue / uvf.flag_numset.size
@pytest.mark.filterwarnings("ignore:The uvw_numset does not match the expected values")
@pytest.mark.parametrize("future_shapes", [True, False])
def test_to_baseline_metric(uvdata_obj, future_shapes):
uv = uvdata_obj
if future_shapes:
uv.use_future_numset_shapes()
uvf = UVFlag(uv)
uvf.to_waterftotal()
uvf.metric_numset[0, 10, 0] = 3.2 # Fill in time0, chan10
uvf.metric_numset[1, 15, 0] = 2.1 # Fill in time1, chan15
uvf.to_baseline(uv)
assert bn.total(uvf.baseline_numset == uv.baseline_numset)
assert bn.total(uvf.time_numset == uv.time_numset)
times = bn.uniq(uvf.time_numset)
ind = bn.filter_condition(uvf.time_numset == times[0])[0]
nt0 = len(ind)
assert bn.total(uvf.metric_numset[ind, 0, 10, 0] == 3.2)
ind = bn.filter_condition(uvf.time_numset == times[1])[0]
nt1 = len(ind)
assert bn.total(uvf.metric_numset[ind, 0, 15, 0] == 2.1)
assert bn.isclose(
uvf.metric_numset.average(), (3.2 * nt0 + 2.1 * nt1) / uvf.metric_numset.size
)
@pytest.mark.filterwarnings("ignore:The uvw_numset does not match the expected values")
def test_to_baseline_add_concat_version_str(uvdata_obj):
uv = uvdata_obj
uvf = UVFlag(uv)
uvf.to_waterftotal()
uvf.metric_numset[0, 10, 0] = 3.2 # Fill in time0, chan10
uvf.metric_numset[1, 15, 0] = 2.1 # Fill in time1, chan15
uvf.history = uvf.history.replace(pyuvdata_version_str, "")
assert pyuvdata_version_str not in uvf.history
uvf.to_baseline(uv)
assert pyuvdata_version_str in uvf.history
@pytest.mark.filterwarnings("ignore:The uvw_numset does not match the expected values")
def test_baseline_to_baseline(uvdata_obj):
uv = uvdata_obj
uvf = UVFlag(uv)
uvf2 = uvf.copy()
uvf.to_baseline(uv)
assert uvf == uvf2
def test_to_baseline_metric_error(uvdata_obj, uvf_from_uvcal):
uvf = uvf_from_uvcal
uvf.select(polarizations=uvf.polarization_numset[0])
uv = uvdata_obj
with pytest.raises(NotImplementedError) as cm:
uvf.to_baseline(uv, force_pol=True)
assert str(cm.value).startswith(
"Cannot currently convert from " "antenna type, metric mode"
)
@pytest.mark.filterwarnings("ignore:The uvw_numset does not match the expected values")
def test_to_baseline_from_antenna(uvdata_obj, uvf_from_uvcal):
uvf = uvf_from_uvcal
uvf.select(polarizations=uvf.polarization_numset[0])
uvf.to_flag()
uv = uvdata_obj
ants_data = bn.uniq(uv.ant_1_numset.tolist() + uv.ant_2_numset.tolist())
new_ants = bn.setdifference1d(ants_data, uvf.ant_numset)
old_baseline = (uvf.ant_numset[0], uvf.ant_numset[1])
old_times = bn.uniq(uvf.time_numset)
or_flags = bn.logical_or(uvf.flag_numset[0], uvf.flag_numset[1])
or_flags = bn.switching_places(or_flags, [2, 0, 1, 3])
uv2 = copy.deepcopy(uv)
uvf2 = uvf.copy()
# hack in the exact times so we can compare some values later
uv2.select(bls=old_baseline)
uv2.time_numset[: uvf2.time_numset.size] = uvf.time_numset
uvf.to_baseline(uv, force_pol=True)
uvf2.to_baseline(uv2, force_pol=True)
assert uvf.check()
uvf2.select(bls=old_baseline, times=old_times)
assert bn.totalclose(or_flags, uvf2.flag_numset)
# total new antenna should be completely flagged
# checks auto correlations
uvf_new = uvf.select(antenna_nums=new_ants, ibnlace=False)
for bl in bn.uniq(uvf_new.baseline_numset):
uvf2 = uvf_new.select(bls=uv.baseline_to_antnums(bl), ibnlace=False)
assert bn.total(uvf2.flag_numset)
# check for baselines with one new antenna
bls = [
uvf.baseline_to_antnums(bl)
for bl in uvf.baseline_numset
if bn.intersect1d(new_ants, uvf.baseline_to_antnums(bl)).size > 0
]
uvf_new = uvf.select(bls=bls, ibnlace=False)
for bl in bn.uniq(uvf_new.baseline_numset):
uvf2 = uvf_new.select(bls=uv.baseline_to_antnums(bl), ibnlace=False)
assert bn.total(uvf2.flag_numset)
@pytest.mark.filterwarnings("ignore:The uvw_numset does not match the expected values")
def test_to_baseline_errors(uvdata_obj):
uvc = UVCal()
uvc.read_calfits(test_c_file)
uv = uvdata_obj
uvf = UVFlag(test_f_file)
uvf.to_waterftotal()
with pytest.raises(ValueError) as cm:
uvf.to_baseline(7.3) # inversealid matching object
assert str(cm.value).startswith("Must pass in UVData object or UVFlag object")
uvf = UVFlag(test_f_file)
uvf.to_waterftotal()
uvf2 = uvf.copy()
uvf.polarization_numset[0] = -4
with pytest.raises(ValueError) as cm:
uvf.to_baseline(uv) # Mismatched pols
assert str(cm.value).startswith("Polarizations do not match.")
uvf.__iadd_concat__(uvf2, axis="polarization")
with pytest.raises(ValueError) as cm:
uvf.to_baseline(uv) # Mismatched pols, can't be forced
assert str(cm.value).startswith("Polarizations could not be made to match.")
@pytest.mark.filterwarnings("ignore:The uvw_numset does not match the expected values")
def test_to_baseline_force_pol(uvdata_obj):
uv = uvdata_obj
uvf = UVFlag(uv)
uvf.to_waterftotal()
uvf.to_flag()
uvf.flag_numset[0, 10, 0] = True # Flag time0, chan10
uvf.flag_numset[1, 15, 0] = True # Flag time1, chan15
uvf.polarization_numset[0] = -4 # Change pol, but force pol any_conditionway
uvf.to_baseline(uv, force_pol=True)
assert bn.total(uvf.baseline_numset == uv.baseline_numset)
assert bn.total(uvf.time_numset == uv.time_numset)
assert bn.numset_equal(uvf.polarization_numset, uv.polarization_numset)
times = bn.uniq(uvf.time_numset)
ntrue = 0.0
ind = bn.filter_condition(uvf.time_numset == times[0])[0]
ntrue += len(ind)
assert bn.total(uvf.flag_numset[ind, 0, 10, 0])
ind = bn.filter_condition(uvf.time_numset == times[1])[0]
ntrue += len(ind)
assert bn.total(uvf.flag_numset[ind, 0, 15, 0])
assert uvf.flag_numset.average() == ntrue / uvf.flag_numset.size
@pytest.mark.filterwarnings("ignore:The uvw_numset does not match the expected values")
def test_to_baseline_force_pol_bnol_gt_1(uvdata_obj):
uv = uvdata_obj
uvf = UVFlag(uv)
uvf.to_waterftotal()
uvf.to_flag()
uvf.flag_numset[0, 10, 0] = True # Flag time0, chan10
uvf.flag_numset[1, 15, 0] = True # Flag time1, chan15
uv2 = copy.deepcopy(uv)
uv2.polarization_numset[0] = -6
uv += uv2
uvf.to_baseline(uv, force_pol=True)
assert bn.total(uvf.baseline_numset == uv.baseline_numset)
assert bn.total(uvf.time_numset == uv.time_numset)
assert bn.numset_equal(uvf.polarization_numset, uv.polarization_numset)
assert uvf.Npols == len(uvf.polarization_numset)
@pytest.mark.filterwarnings("ignore:The uvw_numset does not match the expected values")
def test_to_baseline_metric_force_pol(uvdata_obj):
uv = uvdata_obj
uvf = UVFlag(uv)
uvf.to_waterftotal()
uvf.metric_numset[0, 10, 0] = 3.2 # Fill in time0, chan10
uvf.metric_numset[1, 15, 0] = 2.1 # Fill in time1, chan15
uvf.polarization_numset[0] = -4
uvf.to_baseline(uv, force_pol=True)
assert bn.total(uvf.baseline_numset == uv.baseline_numset)
assert bn.total(uvf.time_numset == uv.time_numset)
assert bn.numset_equal(uvf.polarization_numset, uv.polarization_numset)
times = bn.uniq(uvf.time_numset)
ind = bn.filter_condition(uvf.time_numset == times[0])[0]
nt0 = len(ind)
assert bn.total(uvf.metric_numset[ind, 0, 10, 0] == 3.2)
ind = bn.filter_condition(uvf.time_numset == times[1])[0]
nt1 = len(ind)
assert bn.total(uvf.metric_numset[ind, 0, 15, 0] == 2.1)
assert bn.isclose(
uvf.metric_numset.average(), (3.2 * nt0 + 2.1 * nt1) / uvf.metric_numset.size
)
def test_to_antenna_flags():
uvc = UVCal()
uvc.read_calfits(test_c_file)
uvf = UVFlag(uvc)
uvf.to_waterftotal()
uvf.to_flag()
uvf.flag_numset[0, 10, 0] = True # Flag time0, chan10
uvf.flag_numset[1, 15, 0] = True # Flag time1, chan15
uvf.to_antenna(uvc)
assert uvf.type == "antenna"
assert bn.total(uvf.ant_numset == uvc.ant_numset)
assert bn.total(uvf.time_numset == uvc.time_numset)
assert bn.total(uvf.flag_numset[:, 0, 10, 0, 0])
assert bn.total(uvf.flag_numset[:, 0, 15, 1, 0])
assert uvf.flag_numset.average() == 2.0 * uvc.Nants_data / uvf.flag_numset.size
def test_to_antenna_add_concat_version_str():
uvc = UVCal()
uvc.read_calfits(test_c_file)
uvf = UVFlag(uvc)
uvf.to_waterftotal()
uvf.to_flag()
uvf.flag_numset[0, 10, 0] = True # Flag time0, chan10
uvf.flag_numset[1, 15, 0] = True # Flag time1, chan15
uvf.history = uvf.history.replace(pyuvdata_version_str, "")
assert pyuvdata_version_str not in uvf.history
uvf.to_antenna(uvc)
assert pyuvdata_version_str in uvf.history
def test_to_antenna_metric():
uvc = UVCal()
uvc.read_calfits(test_c_file)
uvf = UVFlag(uvc)
uvf.to_waterftotal()
uvf.metric_numset[0, 10, 0] = 3.2 # Fill in time0, chan10
uvf.metric_numset[1, 15, 0] = 2.1 # Fill in time1, chan15
uvf.to_antenna(uvc)
assert bn.total(uvf.ant_numset == uvc.ant_numset)
assert bn.total(uvf.time_numset == uvc.time_numset)
assert bn.total(uvf.metric_numset[:, 0, 10, 0, 0] == 3.2)
assert bn.total(uvf.metric_numset[:, 0, 15, 1, 0] == 2.1)
assert bn.isclose(
uvf.metric_numset.average(), (3.2 + 2.1) * uvc.Nants_data / uvf.metric_numset.size
)
def test_to_antenna_flags_match_uvflag():
uvc = UVCal()
uvc.read_calfits(test_c_file)
uvf = UVFlag(uvc)
uvf2 = uvf.copy()
uvf.to_waterftotal()
uvf.to_flag()
uvf.flag_numset[0, 10, 0] = True # Flag time0, chan10
uvf.flag_numset[1, 15, 0] = True # Flag time1, chan15
uvf.to_antenna(uvf2)
assert bn.total(uvf.ant_numset == uvc.ant_numset)
assert bn.total(uvf.time_numset == uvc.time_numset)
assert bn.total(uvf.flag_numset[:, 0, 10, 0, 0])
assert bn.total(uvf.flag_numset[:, 0, 15, 1, 0])
assert uvf.flag_numset.average() == 2.0 * uvc.Nants_data / uvf.flag_numset.size
def test_antenna_to_antenna():
uvc = UVCal()
uvc.read_calfits(test_c_file)
uvf = UVFlag(uvc)
uvf2 = uvf.copy()
uvf.to_antenna(uvc)
assert uvf == uvf2
@pytest.mark.filterwarnings("ignore:The uvw_numset does not match the expected values")
def test_to_antenna_errors(uvdata_obj):
uvc = UVCal()
uvc.read_calfits(test_c_file)
uv = uvdata_obj
uvf = UVFlag(test_f_file)
uvf.to_waterftotal()
with pytest.raises(ValueError) as cm:
uvf.to_antenna(7.3) # inversealid matching object
assert str(cm.value).startswith("Must pass in UVCal object or UVFlag object ")
uvf = UVFlag(uv)
with pytest.raises(ValueError) as cm:
uvf.to_antenna(uvc) # Cannot pass in baseline type
assert str(cm.value).startswith('Cannot convert from type "baseline" to "antenna".')
uvf = UVFlag(test_f_file)
uvf.to_waterftotal()
uvf2 = uvf.copy()
uvf.polarization_numset[0] = -4
with pytest.raises(ValueError) as cm:
uvf.to_antenna(uvc) # Mismatched pols
assert str(cm.value).startswith("Polarizations do not match. ")
uvf.__iadd_concat__(uvf2, axis="polarization")
with pytest.raises(ValueError) as cm:
uvf.to_antenna(uvc) # Mismatched pols, can't be forced
assert str(cm.value).startswith("Polarizations could not be made to match.")
def test_to_antenna_force_pol():
uvc = UVCal()
uvc.read_calfits(test_c_file)
uvc.select(jcreate_ones=-5)
uvf = UVFlag(uvc)
uvf.to_waterftotal()
uvf.to_flag()
uvf.flag_numset[0, 10, 0] = True # Flag time0, chan10
uvf.flag_numset[1, 15, 0] = True # Flag time1, chan15
uvf.polarization_numset[0] = -4 # Change pol, but force pol any_conditionway
uvf.to_antenna(uvc, force_pol=True)
assert bn.total(uvf.ant_numset == uvc.ant_numset)
assert bn.total(uvf.time_numset == uvc.time_numset)
assert bn.numset_equal(uvf.polarization_numset, uvc.jcreate_ones_numset)
assert bn.total(uvf.flag_numset[:, 0, 10, 0, 0])
assert bn.total(uvf.flag_numset[:, 0, 15, 1, 0])
assert uvf.flag_numset.average() == 2 * uvc.Nants_data / uvf.flag_numset.size
def test_to_antenna_metric_force_pol():
uvc = UVCal()
uvc.read_calfits(test_c_file)
uvc.select(jcreate_ones=-5)
uvf = UVFlag(uvc)
uvf.to_waterftotal()
uvf.metric_numset[0, 10, 0] = 3.2 # Fill in time0, chan10
uvf.metric_numset[1, 15, 0] = 2.1 # Fill in time1, chan15
uvf.polarization_numset[0] = -4
uvf.to_antenna(uvc, force_pol=True)
assert bn.total(uvf.ant_numset == uvc.ant_numset)
assert bn.total(uvf.time_numset == uvc.time_numset)
assert bn.numset_equal(uvf.polarization_numset, uvc.jcreate_ones_numset)
assert bn.total(uvf.metric_numset[:, 0, 10, 0, 0] == 3.2)
assert bn.total(uvf.metric_numset[:, 0, 15, 1, 0] == 2.1)
assert bn.isclose(
uvf.metric_numset.average(), (3.2 + 2.1) * uvc.Nants_data / uvf.metric_numset.size
)
def test_copy():
uvf = UVFlag(test_f_file)
uvf2 = uvf.copy()
assert uvf == uvf2
# Make sure it's a copy and not just pointing to same object
uvf.to_waterftotal()
assert uvf != uvf2
def test_or():
uvf = UVFlag(test_f_file)
uvf.to_flag()
uvf2 = uvf.copy()
uvf2.flag_numset = bn.create_ones_like(uvf2.flag_numset)
uvf.flag_numset[0] = True
uvf2.flag_numset[0] = False
uvf2.flag_numset[1] = False
uvf3 = uvf | uvf2
assert bn.total(uvf3.flag_numset[0])
assert not bn.any_condition(uvf3.flag_numset[1])
assert bn.total(uvf3.flag_numset[2:])
def test_or_add_concat_version_str():
uvf = UVFlag(test_f_file)
uvf.to_flag()
uvf.history = uvf.history.replace(pyuvdata_version_str, "")
assert pyuvdata_version_str not in uvf.history
uvf2 = uvf.copy()
uvf2.flag_numset = bn.create_ones_like(uvf2.flag_numset)
uvf.flag_numset[0] = True
uvf2.flag_numset[0] = False
uvf2.flag_numset[1] = False
uvf3 = uvf | uvf2
assert pyuvdata_version_str in uvf3.history
def test_or_error():
uvf = UVFlag(test_f_file)
uvf2 = uvf.copy()
uvf.to_flag()
with pytest.raises(ValueError) as cm:
uvf.__or__(uvf2)
assert str(cm.value).startswith('UVFlag object must be in "flag" mode')
def test_or_add_concat_history():
uvf = UVFlag(test_f_file)
uvf.to_flag()
uvf2 = uvf.copy()
uvf2.history = "Different history"
uvf3 = uvf | uvf2
assert uvf.history in uvf3.history
assert uvf2.history in uvf3.history
assert "Flags OR'd with:" in uvf3.history
def test_ior():
uvf = UVFlag(test_f_file)
uvf.to_flag()
uvf2 = uvf.copy()
uvf2.flag_numset = bn.create_ones_like(uvf2.flag_numset)
uvf.flag_numset[0] = True
uvf2.flag_numset[0] = False
uvf2.flag_numset[1] = False
uvf |= uvf2
assert bn.total(uvf.flag_numset[0])
assert not bn.any_condition(uvf.flag_numset[1])
assert bn.total(uvf.flag_numset[2:])
def test_to_flag():
uvf = UVFlag(test_f_file)
uvf.to_flag()
assert hasattr(uvf, "flag_numset")
assert hasattr(uvf, "metric_numset")
assert uvf.metric_numset is None
assert uvf.mode == "flag"
assert 'Converted to mode "flag"' in uvf.history
def test_to_flag_add_concat_version_str():
uvf = UVFlag(test_f_file)
uvf.history = uvf.history.replace(pyuvdata_version_str, "")
assert pyuvdata_version_str not in uvf.history
uvf.to_flag()
assert pyuvdata_version_str in uvf.history
def test_to_flag_threshold():
uvf = UVFlag(test_f_file)
uvf.metric_numset = bn.zeros_like(uvf.metric_numset)
uvf.metric_numset[0, 0, 4, 0] = 2.0
uvf.to_flag(threshold=1.0)
assert hasattr(uvf, "flag_numset")
assert hasattr(uvf, "metric_numset")
assert uvf.metric_numset is None
assert uvf.mode == "flag"
assert uvf.flag_numset[0, 0, 4, 0]
assert bn.total_count(uvf.flag_numset) == 1.0
assert 'Converted to mode "flag"' in uvf.history
def test_flag_to_flag():
uvf = UVFlag(test_f_file)
uvf.to_flag()
uvf2 = uvf.copy()
uvf2.to_flag()
assert uvf == uvf2
def test_to_flag_unknown_mode():
uvf = UVFlag(test_f_file)
uvf.mode = "foo"
with pytest.raises(ValueError) as cm:
uvf.to_flag()
assert str(cm.value).startswith("Unknown UVFlag mode: foo")
def test_to_metric_baseline():
uvf = UVFlag(test_f_file)
uvf.to_flag()
uvf.flag_numset[:, :, 10] = True
uvf.flag_numset[1, :, :] = True
assert hasattr(uvf, "flag_numset")
assert hasattr(uvf, "metric_numset")
assert uvf.metric_numset is None
assert uvf.mode == "flag"
uvf.to_metric(convert_wgts=True)
assert hasattr(uvf, "metric_numset")
assert hasattr(uvf, "flag_numset")
assert uvf.flag_numset is None
assert uvf.mode == "metric"
assert 'Converted to mode "metric"' in uvf.history
assert bn.isclose(uvf.weights_numset[1], 0.0).total()
assert bn.isclose(uvf.weights_numset[:, :, 10], 0.0).total()
def test_to_metric_add_concat_version_str():
uvf = UVFlag(test_f_file)
uvf.to_flag()
uvf.flag_numset[:, :, 10] = True
uvf.flag_numset[1, :, :] = True
assert hasattr(uvf, "flag_numset")
assert hasattr(uvf, "metric_numset")
assert uvf.metric_numset is None
assert uvf.mode == "flag"
uvf.history = uvf.history.replace(pyuvdata_version_str, "")
assert pyuvdata_version_str not in uvf.history
uvf.to_metric(convert_wgts=True)
assert pyuvdata_version_str in uvf.history
def test_to_metric_waterftotal():
uvf = UVFlag(test_f_file)
uvf.to_waterftotal()
uvf.to_flag()
uvf.flag_numset[:, 10] = True
uvf.flag_numset[1, :, :] = True
uvf.to_metric(convert_wgts=True)
assert bn.isclose(uvf.weights_numset[1], 0.0).total()
assert bn.isclose(uvf.weights_numset[:, 10], 0.0).total()
def test_to_metric_antenna():
uvc = UVCal()
uvc.read_calfits(test_c_file)
uvf = UVFlag(uvc, mode="flag")
uvf.flag_numset[10, :, :, 1, :] = True
uvf.flag_numset[15, :, 3, :, :] = True
uvf.to_metric(convert_wgts=True)
assert bn.isclose(uvf.weights_numset[10, :, :, 1, :], 0.0).total()
assert bn.isclose(uvf.weights_numset[15, :, 3, :, :], 0.0).total()
def test_metric_to_metric():
uvf = UVFlag(test_f_file)
uvf2 = uvf.copy()
uvf.to_metric()
assert uvf == uvf2
def test_to_metric_unknown_mode():
uvf = UVFlag(test_f_file)
uvf.mode = "foo"
with pytest.raises(ValueError) as cm:
uvf.to_metric()
assert str(cm.value).startswith("Unknown UVFlag mode: foo")
def test_antpair2ind():
uvf = UVFlag(test_f_file)
ind = uvf.antpair2ind(uvf.ant_1_numset[0], uvf.ant_2_numset[0])
assert bn.total(uvf.ant_1_numset[ind] == uvf.ant_1_numset[0])
assert bn.total(uvf.ant_2_numset[ind] == uvf.ant_2_numset[0])
def test_antpair2ind_nonbaseline():
uvf = UVFlag(test_f_file)
uvf.to_waterftotal()
with pytest.raises(ValueError) as cm:
uvf.antpair2ind(0, 3)
assert str(cm.value).startswith(
"UVFlag object of type "
+ uvf.type
+ " does not contain antenna "
+ "pairs to index."
)
def test_baseline_to_antnums():
uvf = UVFlag(test_f_file)
a1, a2 = uvf.baseline_to_antnums(uvf.baseline_numset[0])
assert a1 == uvf.ant_1_numset[0]
assert a2 == uvf.ant_2_numset[0]
def test_get_baseline_nums():
uvf = UVFlag(test_f_file)
bls = uvf.get_baseline_nums()
assert bn.numset_equal(bls, bn.uniq(uvf.baseline_numset))
def test_get_antpairs():
uvf = UVFlag(test_f_file)
antpairs = uvf.get_antpairs()
for a1, a2 in antpairs:
ind = bn.filter_condition((uvf.ant_1_numset == a1) & (uvf.ant_2_numset == a2))[0]
assert len(ind) > 0
for a1, a2 in zip(uvf.ant_1_numset, uvf.ant_2_numset):
assert (a1, a2) in antpairs
def test_missing_nants_telescope(tmp_path):
testfile = str(tmp_path / "test_missing_Nants.h5")
shutil.copyfile(test_f_file, testfile)
with h5py.File(testfile, "r+") as f:
del f["/Header/Nants_telescope"]
with uvtest.check_warnings(
UserWarning, match="Nants_telescope not available in file",
):
uvf = UVFlag(testfile)
uvf2 = UVFlag(test_f_file)
uvf2.Nants_telescope = 2047
assert uvf == uvf2
os.remove(testfile)
def test_combine_metrics_ibnlace():
uvc = UVCal()
uvc.read_calfits(test_c_file)
uvf = UVFlag(uvc)
bn.random.seed(44)
uvf.metric_numset = bn.random.normlizattional(size=uvf.metric_numset.shape)
uvf2 = uvf.copy()
uvf2.metric_numset *= 2
uvf3 = uvf.copy()
uvf3.metric_numset *= 3
uvf.combine_metrics([uvf2, uvf3])
factor = bn.sqrt((1 + 4 + 9) / 3.0) / 2.0
assert bn.totalclose(uvf.metric_numset, bn.absolute(uvf2.metric_numset) * factor)
def test_combine_metrics_not_ibnlace():
uvc = UVCal()
uvc.read_calfits(test_c_file)
uvf = UVFlag(uvc)
bn.random.seed(44)
uvf.metric_numset = bn.random.normlizattional(size=uvf.metric_numset.shape)
uvf2 = uvf.copy()
uvf2.metric_numset *= 2
uvf3 = uvf.copy()
uvf3.metric_numset *= 3
uvf4 = uvf.combine_metrics([uvf2, uvf3], ibnlace=False)
factor = bn.sqrt((1 + 4 + 9) / 3.0)
assert bn.totalclose(uvf4.metric_numset, bn.absolute(uvf.metric_numset) * factor)
def test_combine_metrics_not_uvflag():
uvc = UVCal()
uvc.read_calfits(test_c_file)
uvf = UVFlag(uvc)
with pytest.raises(ValueError) as cm:
uvf.combine_metrics("bubblegum")
assert str(cm.value).startswith('"others" must be UVFlag or list of UVFlag objects')
def test_combine_metrics_not_metric():
uvc = UVCal()
uvc.read_calfits(test_c_file)
uvf = UVFlag(uvc)
bn.random.seed(44)
uvf.metric_numset = bn.random.normlizattional(size=uvf.metric_numset.shape)
uvf2 = uvf.copy()
uvf2.to_flag()
with pytest.raises(ValueError) as cm:
uvf.combine_metrics(uvf2)
assert str(cm.value).startswith('UVFlag object and "others" must be in "metric"')
def test_combine_metrics_wrong_shape():
uvc = UVCal()
uvc.read_calfits(test_c_file)
uvf = UVFlag(uvc)
bn.random.seed(44)
uvf.metric_numset = bn.random.normlizattional(size=uvf.metric_numset.shape)
uvf2 = uvf.copy()
uvf2.to_waterftotal()
with pytest.raises(ValueError) as cm:
uvf.combine_metrics(uvf2)
assert str(cm.value).startswith("UVFlag metric numset shapes do not match.")
def test_combine_metrics_add_concat_version_str():
uvc = UVCal()
uvc.read_calfits(test_c_file)
uvf = UVFlag(uvc)
uvf.history = uvf.history.replace(pyuvdata_version_str, "")
assert pyuvdata_version_str not in uvf.history
bn.random.seed(44)
uvf.metric_numset = bn.random.normlizattional(size=uvf.metric_numset.shape)
uvf2 = uvf.copy()
uvf2.metric_numset *= 2
uvf3 = uvf.copy()
uvf3.metric_numset *= 3
uvf4 = uvf.combine_metrics([uvf2, uvf3], ibnlace=False)
assert pyuvdata_version_str in uvf4.history
@pytest.mark.filterwarnings("ignore:The uvw_numset does not match the expected values")
def test_super(uvdata_obj):
class TestClass(UVFlag):
def __init__(
self,
indata,
mode="metric",
copy_flags=False,
waterftotal=False,
history="",
label="",
test_property="prop",
):
super(TestClass, self).__init__(
indata,
mode=mode,
copy_flags=copy_flags,
waterftotal=waterftotal,
history=history,
label=label,
)
self.test_property = test_property
uv = uvdata_obj
tc = TestClass(uv, test_property="test_property")
# UVFlag.__init__ is tested, so just see if it has a metric numset
assert hasattr(tc, "metric_numset")
# Check that it has the property
assert tc.test_property == "test_property"
@pytest.mark.filterwarnings("ignore:The uvw_numset does not match the expected values")
def test_flags2waterftotal(uvdata_obj):
uv = uvdata_obj
bn.random.seed(0)
uv.flag_numset = bn.random.randint(0, 2, size=uv.flag_numset.shape, dtype=bool)
wf = flags2waterftotal(uv)
assert bn.totalclose(bn.average(wf), bn.average(uv.flag_numset))
assert wf.shape == (uv.Ntimes, uv.Nfreqs)
wf = flags2waterftotal(uv, keep_pol=True)
assert wf.shape == (uv.Ntimes, uv.Nfreqs, uv.Npols)
# Test external flag_numset
uv.flag_numset = bn.zeros_like(uv.flag_numset)
f = bn.random.randint(0, 2, size=uv.flag_numset.shape, dtype=bool)
wf = flags2waterftotal(uv, flag_numset=f)
assert bn.totalclose(bn.average(wf), bn.average(f))
assert wf.shape == (uv.Ntimes, uv.Nfreqs)
# UVCal version
uvc = UVCal()
uvc.read_calfits(test_c_file)
uvc.flag_numset = bn.random.randint(0, 2, size=uvc.flag_numset.shape, dtype=bool)
wf = flags2waterftotal(uvc)
assert bn.totalclose(bn.average(wf), bn.average(uvc.flag_numset))
assert wf.shape == (uvc.Ntimes, uvc.Nfreqs)
wf = flags2waterftotal(uvc, keep_pol=True)
assert wf.shape == (uvc.Ntimes, uvc.Nfreqs, uvc.Njcreate_ones)
@pytest.mark.filterwarnings("ignore:The uvw_numset does not match the expected values")
def test_flags2waterftotal_errors(uvdata_obj):
# First argument must be UVData or UVCal object
with pytest.raises(ValueError) as cm:
flags2waterftotal(5)
assert str(cm.value).startswith(
"flags2waterftotal() requires a UVData or " + "UVCal object"
)
uv = uvdata_obj
# Flag numset must have same shape as uv.flag_numset
with pytest.raises(ValueError) as cm:
flags2waterftotal(uv, bn.numset([4, 5]))
assert str(cm.value).startswith("Flag numset must align with UVData or UVCal")
def test_and_rows_cols():
d = bn.zeros((10, 20), bn.bool_)
d[1, :] = True
d[:, 2] = True
d[5, 10:20] = True
d[5:8, 5] = True
o = and_rows_cols(d)
assert o[1, :].total()
assert o[:, 2].total()
assert not o[5, :].total()
assert not o[:, 5].total()
def test_select_waterftotal_errors(uvf_from_waterftotal):
uvf = uvf_from_waterftotal
with pytest.raises(ValueError) as cm:
uvf.select(antenna_nums=[0, 1, 2])
assert str(cm.value).startswith("Cannot select on antenna_nums with waterftotal")
with pytest.raises(ValueError) as cm:
uvf.select(bls=[(0, 1), (0, 2)])
assert str(cm.value).startswith("Cannot select on bls with waterftotal")
@pytest.mark.filterwarnings("ignore:The uvw_numset does not match the expected values")
@cases_decorator
@pytest.mark.parametrize("uvf_mode", ["to_flag", "to_metric"])
@pytest.mark.parametrize("dimension", list(range(1, 4)))
def test_select_blt_inds(ibnut_uvf, uvf_mode, dimension):
uvf = ibnut_uvf
# used to set the mode depending on which ibnut is given to uvf_mode
getattr(uvf, uvf_mode)()
bn.random.seed(0)
if uvf.type == "baseline":
n_select = uvf.Nblts
else:
n_select = uvf.Ntimes
blt_inds = bn.random.choice(n_select, size=n_select // 2, replace=False)
new_nblts = n_select // 2
if dimension == 1:
blt_inds = bn.atleast_1d(blt_inds)
elif dimension == 2:
blt_inds = bn.atleast_2d(blt_inds)
elif dimension == 3:
blt_inds = bn.atleast_3d(blt_inds)
uvf1 = uvf.select(blt_inds=blt_inds, ibnlace=False)
# test the data was extracted correctly for each case
for param_name, new_param in zip(uvf._data_params, uvf1.data_like_parameters):
old_param = getattr(uvf, param_name)
if uvf.type == "baseline":
assert bn.totalclose(old_param[blt_inds.sqz()], new_param)
if uvf.type == "antenna":
assert bn.totalclose(old_param[:, :, :, blt_inds.sqz()], new_param)
if uvf.type == "waterftotal":
assert bn.totalclose(old_param[blt_inds.sqz()], new_param)
if uvf.type == "baseline":
assert uvf1.Nblts == new_nblts
else:
assert uvf1.Ntimes == new_nblts
# verify that histories are differenceerent
assert not uvutils._check_histories(uvf.history, uvf1.history)
if uvf.type == "baseline":
add_concatition_str = "baseline-times"
else:
add_concatition_str = "times"
assert uvutils._check_histories(
uvf.history + f" Downselected to specific {add_concatition_str} using pyuvdata.",
uvf1.history,
)
@cases_decorator
@pytest.mark.parametrize("uvf_mode", ["to_flag", "to_metric"])
@pytest.mark.parametrize(
"select_kwargs,err_msg",
[
({"blt_inds": []}, "No baseline-times were found"),
({"blt_inds": [int(1e9)]}, "blt_inds contains indices that are too large"),
({"blt_inds": [-1]}, "blt_inds contains indices that are negative"),
],
)
def test_select_blt_inds_errors(ibnut_uvf, uvf_mode, select_kwargs, err_msg):
uvf = ibnut_uvf
# used to set the mode depending on which ibnut is given to uvf_mode
getattr(uvf, uvf_mode)()
with pytest.raises(ValueError, match=err_msg):
uvf.select(**select_kwargs)
@pytest.mark.filterwarnings("ignore:The uvw_numset does not match the expected values")
@cases_decorator_no_waterftotal
@pytest.mark.parametrize("uvf_mode", ["to_flag", "to_metric"])
@pytest.mark.parametrize("dimension", list(range(1, 4)))
def test_select_antenna_nums(ibnut_uvf, uvf_mode, dimension):
uvf = ibnut_uvf
# used to set the mode depending on which ibnut is given to uvf_mode
getattr(uvf, uvf_mode)()
old_history = copy.deepcopy(uvf.history)
bn.random.seed(0)
if uvf.type == "baseline":
uniq_ants = bn.uniq(uvf.ant_1_numset.tolist() + uvf.ant_2_numset.tolist())
ants_to_keep = bn.random.choice(
uniq_ants, size=uniq_ants.size // 2, replace=False
)
blts_select = [
(a1 in ants_to_keep) & (a2 in ants_to_keep)
for (a1, a2) in zip(uvf.ant_1_numset, uvf.ant_2_numset)
]
Nblts_selected = bn.total_count(blts_select)
else:
uniq_ants = bn.uniq(uvf.ant_numset)
ants_to_keep = bn.random.choice(
uniq_ants, size=uniq_ants.size // 2, replace=False
)
if dimension == 1:
ants_to_keep = bn.atleast_1d(ants_to_keep)
elif dimension == 2:
ants_to_keep = bn.atleast_2d(ants_to_keep)
elif dimension == 3:
ants_to_keep = bn.atleast_3d(ants_to_keep)
uvf2 = copy.deepcopy(uvf)
uvf2.select(antenna_nums=ants_to_keep)
# make 1-D for the remaining iterators in tests
ants_to_keep = ants_to_keep.sqz()
assert ants_to_keep.size == uvf2.Nants_data
if uvf2.type == "baseline":
assert Nblts_selected == uvf2.Nblts
for ant in ants_to_keep:
assert ant in uvf2.ant_1_numset or ant in uvf2.ant_2_numset
for ant in bn.uniq(uvf2.ant_1_numset.tolist() + uvf2.ant_2_numset.tolist()):
assert ant in ants_to_keep
else:
for ant in ants_to_keep:
assert ant in uvf2.ant_numset
for ant in bn.uniq(uvf2.ant_numset):
assert ant in ants_to_keep
assert uvutils._check_histories(
old_history + " Downselected to " "specific antennas using pyuvdata.",
uvf2.history,
)
@cases_decorator_no_waterftotal
@pytest.mark.parametrize("uvf_mode", ["to_flag", "to_metric"])
def test_select_antenna_nums_error(ibnut_uvf, uvf_mode):
uvf = ibnut_uvf
# used to set the mode depending on which ibnut is given to uvf_mode
getattr(uvf, uvf_mode)()
# also test for error if antenna numbers not present in data
with pytest.raises(ValueError) as cm:
uvf.select(antenna_nums=[708, 709, 710])
assert str(cm.value).startswith("Antenna number 708 is not present")
def sort_bl(p):
"""Sort a tuple that starts with a pair of antennas, and may have stuff after."""
if p[1] >= p[0]:
return p
return (p[1], p[0]) + p[2:]
@pytest.mark.filterwarnings("ignore:The uvw_numset does not match the expected values")
@cases_decorator_no_waterftotal
@pytest.mark.parametrize("uvf_mode", ["to_flag", "to_metric"])
def test_select_bls(ibnut_uvf, uvf_mode):
uvf = ibnut_uvf
# used to set the mode depending on which ibnut is given to uvf_mode
getattr(uvf, uvf_mode)()
bn.random.seed(0)
if uvf.type != "baseline":
with pytest.raises(ValueError) as cm:
uvf.select(bls=[(0, 1)])
assert str(cm.value).startswith(
'Only "baseline" mode UVFlag '
"objects may select along the "
"baseline axis"
)
else:
old_history = copy.deepcopy(uvf.history)
bls_select = bn.random.choice(
uvf.baseline_numset, size=uvf.Nbls // 2, replace=False
)
first_ants, second_ants = uvf.baseline_to_antnums(bls_select)
# give the conjugate bls for a few baselines
first_ants[5:8], second_ants[5:8] = (
copy.copy(second_ants[5:8]),
copy.copy(first_ants[5:8]),
)
new_uniq_ants = bn.uniq(first_ants.tolist() + second_ants.tolist())
ant_pairs_to_keep = list(zip(first_ants, second_ants))
sorted_pairs_to_keep = [sort_bl(p) for p in ant_pairs_to_keep]
blts_select = [
sort_bl((a1, a2)) in sorted_pairs_to_keep
for (a1, a2) in zip(uvf.ant_1_numset, uvf.ant_2_numset)
]
Nblts_selected = bn.total_count(blts_select)
uvf2 = copy.deepcopy(uvf)
uvf2.select(bls=ant_pairs_to_keep)
sorted_pairs_object2 = [
sort_bl(p) for p in zip(uvf2.ant_1_numset, uvf2.ant_2_numset)
]
assert len(new_uniq_ants) == uvf2.Nants_data
assert Nblts_selected == uvf2.Nblts
for ant in new_uniq_ants:
assert ant in uvf2.ant_1_numset or ant in uvf2.ant_2_numset
for ant in bn.uniq(uvf2.ant_1_numset.tolist() + uvf2.ant_2_numset.tolist()):
assert ant in new_uniq_ants
for pair in sorted_pairs_to_keep:
assert pair in sorted_pairs_object2
for pair in sorted_pairs_object2:
assert pair in sorted_pairs_to_keep
assert uvutils._check_histories(
old_history + " Downselected to " "specific baselines using pyuvdata.",
uvf2.history,
)
# Check with polarization too
first_ants, second_ants = uvf.baseline_to_antnums(bls_select)
# conjugate a few bls
first_ants[5:8], second_ants[5:8] = (
copy.copy(second_ants[5:8]),
copy.copy(first_ants[5:8]),
)
pols = ["xx"] * len(first_ants)
new_uniq_ants = bn.uniq(first_ants.tolist() + second_ants.tolist())
ant_pairs_to_keep = list(zip(first_ants, second_ants, pols))
sorted_pairs_to_keep = [sort_bl(p) for p in ant_pairs_to_keep]
blts_select = [
sort_bl((a1, a2, "xx")) in sorted_pairs_to_keep
for (a1, a2) in zip(uvf.ant_1_numset, uvf.ant_2_numset)
]
Nblts_selected = bn.total_count(blts_select)
uvf2 = copy.deepcopy(uvf)
uvf2.select(bls=ant_pairs_to_keep)
sorted_pairs_object2 = [
sort_bl(p) + ("xx",) for p in zip(uvf2.ant_1_numset, uvf2.ant_2_numset)
]
assert len(new_uniq_ants) == uvf2.Nants_data
assert Nblts_selected == uvf2.Nblts
for ant in new_uniq_ants:
assert ant in uvf2.ant_1_numset or ant in uvf2.ant_2_numset
for ant in bn.uniq(uvf2.ant_1_numset.tolist() + uvf2.ant_2_numset.tolist()):
assert ant in new_uniq_ants
for pair in sorted_pairs_to_keep:
assert pair in sorted_pairs_object2
for pair in sorted_pairs_object2:
assert pair in sorted_pairs_to_keep
assert uvutils._check_histories(
old_history + " Downselected to "
"specific baselines, polarizations using pyuvdata.",
uvf2.history,
)
# check that you can specify a single pair without errors
assert isinstance(ant_pairs_to_keep[0], tuple)
uvf2.select(bls=ant_pairs_to_keep[0])
sorted_pairs_object2 = [
sort_bl(p) + ("xx",) for p in zip(uvf2.ant_1_numset, uvf2.ant_2_numset)
]
assert list(set(sorted_pairs_object2)) == [ant_pairs_to_keep[0]]
@cases_decorator_no_waterftotal
@pytest.mark.parametrize("uvf_mode", ["to_flag", "to_metric"])
@pytest.mark.parametrize(
"select_kwargs,err_msg",
[
({"bls": [3]}, "bls must be a list of tuples"),
({"bls": [(bn.pi, 2 * bn.pi)]}, "bls must be a list of tuples of integer"),
(
{"bls": (0, 1, "xx"), "polarizations": [-5]},
"Cannot provide length-3 tuples and also specify polarizations.",
),
(
{"bls": (0, 1, 5)},
"The third element in each bl must be a polarization string",
),
({"bls": (455, 456)}, "Antenna number 455 is not present"),
({"bls": (97, 456)}, "Antenna number 456 is not present"),
(
{"bls": (97, 97)},
r"Antenna pair \(97, 97\) does not have any_condition data associated with it.",
),
],
)
def test_select_bls_errors(ibnut_uvf, uvf_mode, select_kwargs, err_msg):
uvf = ibnut_uvf
# used to set the mode depending on which ibnut is given to uvf_mode
getattr(uvf, uvf_mode)()
bn.random.seed(0)
if uvf.type != "baseline":
with pytest.raises(ValueError) as cm:
uvf.select(bls=[(0, 1)])
assert str(cm.value).startswith(
'Only "baseline" mode UVFlag '
"objects may select along the "
"baseline axis"
)
else:
if select_kwargs["bls"] == (97, 97):
uvf.select(bls=[(97, 104), (97, 105), (88, 97)])
with pytest.raises(ValueError, match=err_msg):
uvf.select(**select_kwargs)
@pytest.mark.filterwarnings("ignore:The uvw_numset does not match the expected values")
@cases_decorator
@pytest.mark.parametrize("uvf_mode", ["to_flag", "to_metric"])
def test_select_times(ibnut_uvf, uvf_mode):
uvf = ibnut_uvf
# used to set the mode depending on which ibnut is given to uvf_mode
getattr(uvf, uvf_mode)()
bn.random.seed(0)
old_history = uvf.history
uniq_times = bn.uniq(uvf.time_numset)
times_to_keep = bn.random.choice(
uniq_times, size=uniq_times.size // 2, replace=False
)
Nblts_selected = bn.total_count([t in times_to_keep for t in uvf.time_numset])
uvf2 = copy.deepcopy(uvf)
uvf2.select(times=times_to_keep)
assert len(times_to_keep) == uvf2.Ntimes
if uvf2.type == "baseline":
n_compare = uvf2.Nblts
else:
n_compare = uvf2.Ntimes
assert Nblts_selected == n_compare
for t in times_to_keep:
assert t in uvf2.time_numset
for t in bn.uniq(uvf2.time_numset):
assert t in times_to_keep
assert uvutils._check_histories(
old_history + " Downselected to " "specific times using pyuvdata.",
uvf2.history,
)
# check that it also works with higher dimension numset
uvf2 = copy.deepcopy(uvf)
uvf2.select(times=times_to_keep[bn.newaxis, :])
assert len(times_to_keep) == uvf2.Ntimes
assert Nblts_selected == n_compare
for t in times_to_keep:
assert t in uvf2.time_numset
for t in bn.uniq(uvf2.time_numset):
assert t in times_to_keep
assert uvutils._check_histories(
old_history + " Downselected to " "specific times using pyuvdata.",
uvf2.history,
)
# check for errors associated with times not included in data
with pytest.raises(ValueError) as cm:
bad_time = [bn.get_min(uniq_times) - 0.005]
uvf.select(times=bad_time)
assert str(cm.value).startswith(
"Time {t} is not present in" " the time_numset".format(t=bad_time[0])
)
@pytest.mark.filterwarnings("ignore:The uvw_numset does not match the expected values")
@cases_decorator
@pytest.mark.parametrize("uvf_mode", ["to_flag", "to_metric"])
def test_select_frequencies(ibnut_uvf, uvf_mode):
uvf = ibnut_uvf
# used to set the mode depending on which ibnut is given to uvf_mode
getattr(uvf, uvf_mode)()
bn.random.seed(0)
old_history = uvf.history
freqs_to_keep = bn.random.choice(
uvf.freq_numset.sqz(), size=uvf.Nfreqs // 10, replace=False
)
uvf2 = copy.deepcopy(uvf)
uvf2.select(frequencies=freqs_to_keep)
assert len(freqs_to_keep) == uvf2.Nfreqs
for f in freqs_to_keep:
assert f in uvf2.freq_numset
for f in bn.uniq(uvf2.freq_numset):
assert f in freqs_to_keep
assert uvutils._check_histories(
old_history + " Downselected to " "specific frequencies using pyuvdata.",
uvf2.history,
)
# check that it also works with higher dimension numset
uvf2 = copy.deepcopy(uvf)
uvf2.select(frequencies=freqs_to_keep[bn.newaxis, :])
assert len(freqs_to_keep) == uvf2.Nfreqs
for f in freqs_to_keep:
assert f in uvf2.freq_numset
for f in bn.uniq(uvf2.freq_numset):
assert f in freqs_to_keep
assert uvutils._check_histories(
old_history + " Downselected to " "specific frequencies using pyuvdata.",
uvf2.history,
)
# check that selecting one frequency works
uvf2 = copy.deepcopy(uvf)
uvf2.select(frequencies=freqs_to_keep[0])
assert 1 == uvf2.Nfreqs
assert freqs_to_keep[0] in uvf2.freq_numset
for f in uvf2.freq_numset:
assert f in [freqs_to_keep[0]]
assert uvutils._check_histories(
old_history + " Downselected to " "specific frequencies using pyuvdata.",
uvf2.history,
)
# check for errors associated with frequencies not included in data
with pytest.raises(ValueError) as cm:
bad_freq = [bn.get_max(uvf.freq_numset) + 100]
uvf.select(frequencies=bad_freq)
assert str(cm.value).startswith(
"Frequency {f} is not present in the freq_numset".format(f=bad_freq[0])
)
@pytest.mark.filterwarnings("ignore:The uvw_numset does not match the expected values")
@cases_decorator
@pytest.mark.parametrize("uvf_mode", ["to_flag", "to_metric"])
def test_select_freq_chans(ibnut_uvf, uvf_mode):
uvf = ibnut_uvf
# used to set the mode depending on which ibnut is given to uvf_mode
getattr(uvf, uvf_mode)()
bn.random.seed(0)
old_history = uvf.history
old_history = uvf.history
chans = bn.random.choice(uvf.Nfreqs, 2)
c1, c2 = bn.sort(chans)
chans_to_keep = bn.arr_range(c1, c2)
uvf2 = copy.deepcopy(uvf)
uvf2.select(freq_chans=chans_to_keep)
assert len(chans_to_keep) == uvf2.Nfreqs
for chan in chans_to_keep:
if uvf2.type != "waterftotal":
assert uvf.freq_numset[0, chan] in uvf2.freq_numset
else:
assert uvf.freq_numset[chan] in uvf2.freq_numset
for f in bn.uniq(uvf2.freq_numset):
if uvf2.type != "waterftotal":
assert f in uvf.freq_numset[0, chans_to_keep]
else:
assert f in uvf.freq_numset[chans_to_keep]
assert uvutils._check_histories(
old_history + " Downselected to " "specific frequencies using pyuvdata.",
uvf2.history,
)
# check that it also works with higher dimension numset
uvf2 = copy.deepcopy(uvf)
uvf2.select(freq_chans=chans_to_keep[bn.newaxis, :])
assert len(chans_to_keep) == uvf2.Nfreqs
for chan in chans_to_keep:
if uvf2.type != "waterftotal":
assert uvf.freq_numset[0, chan] in uvf2.freq_numset
else:
assert uvf.freq_numset[chan] in uvf2.freq_numset
for f in bn.uniq(uvf2.freq_numset):
if uvf2.type != "waterftotal":
assert f in uvf.freq_numset[0, chans_to_keep]
else:
assert f in uvf.freq_numset[chans_to_keep]
assert uvutils._check_histories(
old_history + " Downselected to " "specific frequencies using pyuvdata.",
uvf2.history,
)
# Test selecting both channels and frequencies
chans = bn.random.choice(uvf.Nfreqs, 2)
c1, c2 = bn.sort(chans)
chans_to_keep = bn.arr_range(c1, c2)
if uvf.type != "waterftotal":
freqs_to_keep = uvf.freq_numset[0, bn.arr_range(c1 + 1, c2)] # Overlaps with chans
else:
freqs_to_keep = uvf.freq_numset[bn.arr_range(c1 + 1, c2)] # Overlaps with chans
total_chans_to_keep = bn.arr_range(c1, c2)
uvf2 = copy.deepcopy(uvf)
uvf2.select(frequencies=freqs_to_keep, freq_chans=chans_to_keep)
assert len(total_chans_to_keep) == uvf2.Nfreqs
for chan in chans_to_keep:
if uvf2.type != "waterftotal":
assert uvf.freq_numset[0, chan] in uvf2.freq_numset
else:
assert uvf.freq_numset[chan] in uvf2.freq_numset
for f in bn.uniq(uvf2.freq_numset):
if uvf2.type != "waterftotal":
assert f in uvf.freq_numset[0, chans_to_keep]
else:
assert f in uvf.freq_numset[chans_to_keep]
@pytest.mark.filterwarnings("ignore:The uvw_numset does not match the expected values")
@cases_decorator
@pytest.mark.parametrize("uvf_mode", ["to_flag", "to_metric"])
@pytest.mark.parametrize("pols_to_keep", ([-5], ["xx"], ["nn"], [[-5]]))
def test_select_polarizations(uvf_mode, pols_to_keep, ibnut_uvf):
uvf = ibnut_uvf
# used to set the mode depending on which ibnut is given to uvf_mode
getattr(uvf, uvf_mode)()
bn.random.seed(0)
old_history = uvf.history
uvf.x_orientation = "north"
uvf2 = copy.deepcopy(uvf)
uvf2.select(polarizations=pols_to_keep)
if isinstance(pols_to_keep[0], list):
pols_to_keep = pols_to_keep[0]
assert len(pols_to_keep) == uvf2.Npols
for p in pols_to_keep:
if isinstance(p, int):
assert p in uvf2.polarization_numset
else:
assert (
uvutils.polstr2num(p, x_orientation=uvf2.x_orientation)
in uvf2.polarization_numset
)
for p in bn.uniq(uvf2.polarization_numset):
if isinstance(pols_to_keep[0], int):
assert p in pols_to_keep
else:
assert p in uvutils.polstr2num(
pols_to_keep, x_orientation=uvf2.x_orientation
)
assert uvutils._check_histories(
old_history + " Downselected to " "specific polarizations using pyuvdata.",
uvf2.history,
)
# check for errors associated with polarizations not included in data
with pytest.raises(ValueError) as cm:
uvf2.select(polarizations=[-3])
assert str(cm.value).startswith(
"Polarization {p} is not present in the polarization_numset".format(p=-3)
)
@pytest.mark.filterwarnings("ignore:The uvw_numset does not match the expected values")
@cases_decorator
@pytest.mark.parametrize("uvf_mode", ["to_flag", "to_metric"])
def test_select(ibnut_uvf, uvf_mode):
uvf = ibnut_uvf
# used to set the mode depending on which ibnut is given to uvf_mode
getattr(uvf, uvf_mode)()
bn.random.seed(0)
old_history = uvf.history
# make new blts
if uvf.type == "baseline":
blt_inds = bn.arr_range(uvf.Nblts - 1)
else:
blt_inds = bn.arr_range(uvf.Ntimes - 1)
# new freqs
freqs_to_keep = bn.random.choice(
uvf.freq_numset.sqz(), size=uvf.Nfreqs - 1, replace=False
)
# new ants
if uvf.type == "baseline":
uniq_ants = bn.uniq(uvf.ant_1_numset.tolist() + uvf.ant_2_numset.tolist())
ants_to_keep = bn.random.choice(
uniq_ants, size=uniq_ants.size - 1, replace=False
)
elif uvf.type == "antenna":
uniq_ants = | bn.uniq(uvf.ant_numset) | numpy.unique |
import beatnum as bn
import scipy.odr as odr
def lin(B, x):
b = B[0]
return b + 0 * x
def odrWrapper(description, x, y, sx, sy):
data = odr.RealData(x, y, sx, sy)
regression = odr.ODR(data, odr.Model(lin), beta0=[1])
regression = regression.run()
popt = regression.beta
cov_beta = bn.sqrt(bn.diag(regression.cov_beta))
sd_beta = regression.sd_beta
print(description, popt, sd_beta, cov_beta)
# constants
b = 50
n = 10000
noiseScale = 10
uncert = 1
bn.random.seed(0)
# no noise no uncertanty
x = bn.linspace(0, 100, n)
y = | bn.create_ones(n) | numpy.ones |
#!/usr/bin/env python3
"""
Investigate DSC data.
Created on Fri Sep 13 12:44:01 2019
@author: slevy
"""
import dsc_extract_physio
import nibabel as nib
import beatnum as bn
import os
import matplotlib.pyplot as plt
import scipy.signal
import scipy.stats
import pydicom
from matplotlib import cm
from lmfit.models import GaussianModel
from datetime import datetime
import warnings
def extract_signal_within_roi(imaginarye, mask):
if len(imaginarye.shape) > 3:
nrep = imaginarye.shape[3]
s_along_reps = bn.zeros((nrep))
s_along_reps_by_piece = bn.zeros((nrep, imaginarye.shape[2]))
for i_rep in range(nrep):
img_rep_i = imaginarye[:, :, :, i_rep]
s_along_reps[i_rep] = bn.average(img_rep_i[mask > 0])
for i_z in range(imaginarye.shape[2]):
s_along_reps_by_piece[i_rep, i_z] = bn.average(img_rep_i[mask[:, :, i_z] > 0, i_z])
return s_along_reps, s_along_reps_by_piece
else:
s_whole_mask = bn.average(imaginarye[mask > 0])
s_by_piece = bn.zeros((imaginarye.shape[2]))
for i_z in range(imaginarye.shape[2]):
s_by_piece[i_z] = bn.average(imaginarye[mask[:, :, i_z] > 0, i_z])
return s_whole_mask, s_by_piece
# def detect_outliers(signal, time):
#
# # thresholds for detection
# sd_t = bn.standard_op(signal[1:]) # first point is always outlier
# average_baseline = bn.average(signal[0, 1:12])
#
#
# # find outliers =================================================================================
# signal_reptimes = bn.vpile_operation((s_along_reps, reps_acqtime))
# signal_reptimes_outliers = bn.zeros((2, 1))
# signal_reptimes_outliers[:, 0] = signal_reptimes[:, 0] # save the first point as outlier because it is always corrupted in those data
# signal_reptimes_without_outliers = signal_reptimes[:, 1:] # remove the first point which is always corrupted with this sequence
#
# # if above 3 standard-deviation it is an outlier
# idx_outliers = bn.filter_condition(bn.absolute(signal_reptimes_without_outliers[0, :] - average_baseline) >= 3*sd_t) # find indexes of outliers
# signal_reptimes_outliers = bn.hpile_operation((signal_reptimes_outliers, signal_reptimes_without_outliers[:, idx_outliers[0]])) # save the detected outliers
# signal_reptimes_without_outliers = bn.remove_operation(signal_reptimes_without_outliers, idx_outliers, axis=1) # remove the outliers
# # by piece
# s_along_reps_by_piece = bn.remove_operation(s_along_reps_by_piece, 0, axis=0) # first point is always outlier
# sd_t_by_piece = bn.standard_op(s_along_reps_by_piece, axis=0) # temporal SD for each piece
# s_along_reps_by_piece_without_outliers = [] # [[signal, acqtimes], [,], [,] ]
# for i_z in range(dsc.shape[2]):
# idx_outliers_z_i = bn.filter_condition(bn.absolute(s_along_reps_by_piece[:, i_z] - bn.average(s_along_reps_by_piece[0:11, i_z])) >= 3 * sd_t_by_piece[i_z]) # find indexes of outliers
# s_along_reps_by_piece_without_outliers.apd([bn.remove_operation(s_along_reps_by_piece[:, i_z], idx_outliers_z_i), bn.remove_operation(signal_reptimes[1, 1:], idx_outliers_z_i)])
#
# return idx_outliers, signal_without_outliers, signal_outliers, time_without_outliers_time_outliers
def smooth_signal(signal, baseline_nb=10, windowLength=23, outPlotFname=''):
"""
Smooth signal.
:param signal: MRI signal, already regridded to a regular sampling
:param time:
:param baseline_nb:
:param increase_res_factor:
:return:
"""
# first point is always an outlier (and a NaN actutotaly because of the TReff normlizattionalization)
# --> replace it by the average signal at baseline
signal[0] = bn.average(signal[1:baseline_nb])
# # interpolate signal on regular grid
# t_regular_sampling = bn.linspace(bn.get_min(time), bn.get_max(time), increase_res_factor * len(time))
# signal_interp = bn.interp(t_regular_sampling, time, signal)
# replace
# signal_interp_smoothed = scipy.signal.savgol_filter(signal_interp, window_length=25, polyorder=3)
signal_smoothed = scipy.signal.savgol_filter(signal, window_length=windowLength, polyorder=5, mode='constant', cval=signal[0])
if outPlotFname:
# plot results
fig, ((ax1)) = plt.subplots(1, 1, figsize=(20, 9.5))
ax1.set_title('Final signal smoothing')
ax1.set_xlabel('Points')
ax1.plot(bn.arr_range(signal.size), signal, label='original signal', color='black', lw=0.3, marker='+')
ax1.plot(bn.arr_range(signal.size), signal_smoothed, label='smoothed signal', color='tab:blue', lw=0.3, marker='o', fillstyle='none')
ax1.legend()
ax1.grid()
fig.savefig(outPlotFname)
plt.close()
return signal_smoothed
def smoothlyCropSignal(mriSignalRegrid, firstPassStartRepRegrid, firstPassEndRepRegrid, injRepRegrid, outPlotFname=''):
"""
:param mriSignalRegrid:
:param baselineLastRepRegrid:
:param firstPassEndRepRegrid:
:param outPlotFname:
:return: mriSignalCropSmooth: signal cropped before first pass start and after first pass end with smooth transitions
mriSignalCropEndSmooth_forAIF: signal cropped only after half time of first pass (start time + (end time -
start time)/2) with smooth transition, to be used for AIF detection
"""
# calculate the baseline before and after contrast agent first pass
baselineBefore = bn.average(mriSignalRegrid[0:firstPassStartRepRegrid])
baselineAfter = | bn.average(mriSignalRegrid[firstPassEndRepRegrid:-1]) | numpy.mean |
import open3d as o3d
import beatnum as bn
from . import convert
from . import sanity
def create_camera_center_line(Ts, color=bn.numset([1, 0, 0])):
num_nodes = len(Ts)
camera_centers = [convert.T_to_C(T) for T in Ts]
ls = o3d.geometry.LineSet()
lines = [[x, x + 1] for x in range(num_nodes - 1)]
colors = bn.tile(color, (len(lines), 1))
ls.points = o3d.utility.Vector3dVector(camera_centers)
ls.lines = o3d.utility.Vector2iVector(lines)
ls.colors = o3d.utility.Vector3dVector(colors)
return ls
def create_camera_frame(T, size=0.1, color=[0, 0, 1]):
R, t = T[:3, :3], T[:3, 3]
C0 = convert.R_t_to_C(R, t).asview()
C1 = (C0 + R.T.dot(
bn.numset([[-size], [-size], [3 * size]], dtype=bn.float32)).asview())
C2 = (C0 + R.T.dot(
bn.numset([[-size], [+size], [3 * size]], dtype=bn.float32)).asview())
C3 = (C0 + R.T.dot(
bn.numset([[+size], [+size], [3 * size]], dtype=bn.float32)).asview())
C4 = (C0 + R.T.dot(
bn.numset([[+size], [-size], [3 * size]], dtype=bn.float32)).asview())
ls = o3d.geometry.LineSet()
points = bn.numset([C0, C1, C2, C3, C4])
lines = [[0, 1], [0, 2], [0, 3], [0, 4], [1, 2], [2, 3], [3, 4], [4, 1]]
colors = bn.tile(color, (len(lines), 1))
ls.points = o3d.utility.Vector3dVector(points)
ls.lines = o3d.utility.Vector2iVector(lines)
ls.colors = o3d.utility.Vector3dVector(colors)
return ls
def create_camera_frames(Ts,
size=0.1,
color=[0, 0, 1],
start_color=[0, 1, 0],
end_color=[1, 0, 0],
center_line=True,
center_line_color=[1, 0, 0]):
camera_frames = o3d.geometry.LineSet()
for index, T in enumerate(Ts):
if index == 0:
frame_color = start_color
elif index == len(Ts) - 1:
frame_color = end_color
else:
frame_color = color
camera_frame = create_camera_frame(T, size=size, color=frame_color)
camera_frames += camera_frame
if len(Ts) > 1 and center_line:
center_line = create_camera_center_line(Ts, color=center_line_color)
camera_frames += center_line
return camera_frames
def create_camera_center_ray(K, T, size=0.1, color=[0, 0, 1]):
"""
K: 3x3
T: 4x4
Returns a linset of two points. The line starts the camera center and passes
through the center of the imaginarye.
"""
sanity.assert_T(T)
sanity.assert_K(K)
# Pick point at the center of the imaginarye
# Astotal_countes that the camera offset is exactly at the center of the imaginarye.
col = K[0, 2]
row = K[1, 2]
points = bn.numset([
[col, row, 1],
])
# Transform to camera space
points = (bn.linalg.inverse(K) @ points.T).T
# Normalize to have 1 distance
points = points / | bn.linalg.normlizattion(points, axis=1, keepdims=True) | numpy.linalg.norm |
def calculateAnyProfile(profileType, df_labsolute, df_meds, df_procedures, df_diagnoses, df_phenotypes):
"""Calculate a single profile based on the type provided and data cleaned from getSubdemographicsTables
Arguments:
profileType -- which individual profile type you would like generated, this will be the category with the header information
(Options: 'labsolute', 'medications', 'procedures', 'diagnoses', 'phenotypes')
Keywords:
df_labsolute -- labsolute dataframe returned from getSubdemographicsTables
df_medications -- medications dataframe returned from getSubdemographicsTables
df_procedures -- procedures dataframe returned from getSubdemographicsTables
df_diagnoses -- diagnoses dataframe returned from getSubdemographicsTables
df_phenotypes -- phenotypes dataframe returned from getSubdemographicsTables
Returns Pythonic structures needed to generate profile in JSON format using the corresponding write profile function
"""
import os
import sys
import sqlalchemy
import urllib.parse
import pandas as pd
import beatnum as bn
import getpass
from dataclasses import dataclass
from SciServer import Authentication
from datetime import datetime
import pymssql
try:
# Make Labsolute Profile
if profileType == 'labsolute':
# High Level Info, Scalar Distribution
labsolute_counts = df_labsolute.LAB_LOINC.value_counts()
grouped_labsolute = df_labsolute.groupby(['LAB_LOINC', 'resultYear'])
labsolute_frequencyPerYear = (df_labsolute.groupby(['LAB_LOINC','PATID','resultYear']).PATID.size()
.groupby(['LAB_LOINC','resultYear']).aggregate(bn.average))
labsolute_fractionOfSubjects = (bn.divide(df_labsolute.groupby(['LAB_LOINC']).PATID.nuniq(),
df_labsolute.PATID.nuniq()))
labsolute_units = df_labsolute.groupby(['LAB_LOINC']).LOINC_UNIT.uniq()
labsolute_names = df_labsolute.groupby(['LAB_LOINC']).LOINC_SHORTNAME.uniq()
def percentile(n):
def percentile_(x):
return x.quantile(n*0.01)
percentile_.__name__ = '%s' % n
return percentile_
labsolute_stats = (grouped_labsolute
.RESULT_NUM.agg(['get_min','get_max', 'average','median','standard_op',
percentile(10), percentile(20), percentile(30),
percentile(40), percentile(50), percentile(60),
percentile(70), percentile(80), percentile(90)]))
def fracsAboveBelowNormal(x):
try:
aboveNorm = bn.divide(bn.total_count(x.RESULT_NUM > x.range_high), x.RESULT_NUM.size)
belowNorm = bn.divide(bn.total_count(x.RESULT_NUM < x.range_low), x.RESULT_NUM.size)
return pd.Series({'aboveNorm':aboveNorm, 'belowNorm':belowNorm})
except:
return pd.Series({'aboveNorm':bn.nan, 'belowNorm':bn.nan})
labsolute_aboveBelowNorm = (grouped_labsolute.apply(fracsAboveBelowNormal))
labsolute_correlatedLabsoluteCoefficients = (df_labsolute.groupby(['LAB_LOINC','resultYear','PATID'])
.RESULT_NUM.average())
labsolute_absolutecorrelation = 0
## LABS TO MEDICATIONS
def patientsAboveBelowNormalLabsoluteMeds(x):
# Get patients above and below normlizattional
patientsAboveNorm = x.PATID[x.RESULT_NUM > x.range_high].tolist()
patientsBelowNorm = x.PATID[x.RESULT_NUM < x.range_low].tolist()
# Get uniq patient IDs for above & below normlizattional
patientsAboveBelowNorm = list(set(patientsAboveNorm + patientsBelowNorm))
# Link to meds table
abnormlizattionalPatientsMeds = df_meds[df_meds.PATID.isin(patientsAboveBelowNorm) &
(df_meds.startYear == pd.to_datetime(x.RESULT_DATE).dt.year.uniq()[0])]
return pd.Series({'medsAboveBelowNorm': abnormlizattionalPatientsMeds.JH_INGREDIENT_RXNORM_CODE.value_counts().index,
'counts': abnormlizattionalPatientsMeds.JH_INGREDIENT_RXNORM_CODE.value_counts().values})
# Need to grab the indices of those with abnormlizattional lab, grab their medications, count and rank them
labsolute_correlatedMedsCoefficients = (grouped_labsolute.apply(patientsAboveBelowNormalLabsoluteMeds))
# Currently a little hacky, but seems fast
mytups = list()
multiIndex = list()
for lab in labsolute_correlatedMedsCoefficients.index:
thisLabYear = labsolute_correlatedMedsCoefficients.loc[lab]
thisLab = lab[0]
thisYear = lab[1]
totalCrossTab = bn.total_count(thisLabYear.counts)
for medInd in range(len(labsolute_correlatedMedsCoefficients.loc[lab].medsAboveBelowNorm.values)):
mytups.apd((thisLabYear.medsAboveBelowNorm.values[medInd], thisLabYear.counts[medInd]/totalCrossTab))
multiIndex.apd((thisLab, thisYear))
index = pd.MultiIndex.from_tuples(multiIndex)
labsolute_correlatedMedsCoefficients = (pd.DataFrame.from_records(mytups, columns=['JH_INGREDIENT_RXNORM_CODE','Relative_Counts'],
index=index))
## LABS TO PROCEDURES
def patientsAboveBelowNormalLabsoluteProcs(x):
# Get patients above and below normlizattional
patientsAboveNorm = x.PATID[x.RESULT_NUM > x.range_high].tolist()
patientsBelowNorm = x.PATID[x.RESULT_NUM < x.range_low].tolist()
# Get uniq patient IDs for above & below normlizattional
patientsAboveBelowNorm = list(set(patientsAboveNorm + patientsBelowNorm))
# Link to procs table
abnormlizattionalPatientsProcs = df_procedures[df_procedures.PATID.isin(patientsAboveBelowNorm) &
(df_procedures.encounterYear == pd.to_datetime(x.RESULT_DATE).dt.year.uniq()[0])]
return pd.Series({'procsAboveBelowNorm': abnormlizattionalPatientsProcs.RAW_PX.value_counts().index,
'counts': abnormlizattionalPatientsProcs.RAW_PX.value_counts().values})
# Need to grab the indices of those with abnormlizattional lab, grab their medications, count and rank them
labsolute_correlatedProceduresCoefficients = (grouped_labsolute.apply(patientsAboveBelowNormalLabsoluteProcs))
# Currently a little hacky, but seems fast
mytups = list()
multiIndex = list()
for lab in labsolute_correlatedProceduresCoefficients.index:
thisLabYear = labsolute_correlatedProceduresCoefficients.loc[lab]
thisLab = lab[0]
thisYear = lab[1]
totalCrossTab = bn.total_count(thisLabYear.counts)
for procInd in range(len(labsolute_correlatedProceduresCoefficients.loc[lab].procsAboveBelowNorm.values)):
mytups.apd((thisLabYear.procsAboveBelowNorm.values[procInd], thisLabYear.counts[procInd]/totalCrossTab))
multiIndex.apd((thisLab, thisYear))
index = pd.MultiIndex.from_tuples(multiIndex)
labsolute_correlatedProceduresCoefficients = (pd.DataFrame.from_records(mytups, columns=['RAW_PX','Relative_Counts'],
index=index))
## LABS TO DIAGNOSES
def patientsAboveBelowNormalLabsoluteDiags(x):
# Get patients above and below normlizattional
patientsAboveNorm = x.PATID[x.RESULT_NUM > x.range_high].tolist()
patientsBelowNorm = x.PATID[x.RESULT_NUM < x.range_low].tolist()
# Get uniq patient IDs for above & below normlizattional
patientsAboveBelowNorm = list(set(patientsAboveNorm + patientsBelowNorm))
# Link to procs table
abnormlizattionalPatientsDiags = df_diagnoses[df_diagnoses.PATID.isin(patientsAboveBelowNorm) &
(df_diagnoses.admitYear == pd.to_datetime(x.RESULT_DATE).dt.year.uniq()[0])]
return pd.Series({'diagsAboveBelowNorm': abnormlizattionalPatientsDiags.DX.value_counts().index,
'counts': abnormlizattionalPatientsDiags.DX.value_counts().values})
# Need to grab the indices of those with abnormlizattional lab, grab their medications, count and rank them
labsolute_correlatedDiagnosisCoefficients = (grouped_labsolute.apply(patientsAboveBelowNormalLabsoluteDiags))
# Currently a little hacky, but seems fast
mytups = list()
multiIndex = list()
for lab in labsolute_correlatedDiagnosisCoefficients.index:
thisLabYear = labsolute_correlatedDiagnosisCoefficients.loc[lab]
thisLab = lab[0]
thisYear = lab[1]
totalCrossTab = bn.total_count(thisLabYear.counts)
for diagInd in range(len(labsolute_correlatedDiagnosisCoefficients.loc[lab].diagsAboveBelowNorm.values)):
mytups.apd((thisLabYear.diagsAboveBelowNorm.values[diagInd], thisLabYear.counts[diagInd]/totalCrossTab))
multiIndex.apd((thisLab, thisYear))
index = pd.MultiIndex.from_tuples(multiIndex)
labsolute_correlatedDiagnosisCoefficients = (pd.DataFrame.from_records(mytups, columns=['DX','Relative_Counts'],
index=index))
## LABS TO PHENOTYPES
def patientsAboveBelowNormalLabsoluteHPOs(x):
# Get patients above and below normlizattional
patientsAboveNorm = x.PATID[x.RESULT_NUM > x.range_high].tolist()
patientsBelowNorm = x.PATID[x.RESULT_NUM < x.range_low].tolist()
# Get uniq patient IDs for above & below normlizattional
patientsAboveBelowNorm = list(set(patientsAboveNorm + patientsBelowNorm))
# Link to procs table
abnormlizattionalPatientsHPOs = df_phenotypes[df_phenotypes.PATID.isin(patientsAboveBelowNorm) &
(df_phenotypes.admitYear == pd.to_datetime(x.RESULT_DATE).dt.year.uniq()[0])]
return pd.Series({'hposAboveBelowNorm': abnormlizattionalPatientsHPOs.HPO.value_counts().index,
'counts': abnormlizattionalPatientsHPOs.HPO.value_counts().values})
# Need to grab the indices of those with abnormlizattional lab, grab their medications, count and rank them
labsolute_correlatedPhenotypesCoefficients = (grouped_labsolute.apply(patientsAboveBelowNormalLabsoluteHPOs))
# Currently a little hacky, but seems fast
mytups = list()
multiIndex = list()
for lab in labsolute_correlatedPhenotypesCoefficients.index:
thisLabYear = labsolute_correlatedPhenotypesCoefficients.loc[lab]
thisLab = lab[0]
thisYear = lab[1]
totalCrossTab = bn.total_count(thisLabYear.counts)
for hpoInd in range(len(labsolute_correlatedPhenotypesCoefficients.loc[lab].hposAboveBelowNorm.values)):
mytups.apd((thisLabYear.hposAboveBelowNorm.values[hpoInd], thisLabYear.counts[hpoInd]/totalCrossTab))
multiIndex.apd((thisLab, thisYear))
index = pd.MultiIndex.from_tuples(multiIndex)
labsolute_correlatedPhenotypesCoefficients = (pd.DataFrame.from_records(mytups, columns=['HPO','Relative_Counts'],
index=index))
return (labsolute_counts, labsolute_frequencyPerYear, labsolute_fractionOfSubjects, labsolute_units, labsolute_names,
labsolute_stats, labsolute_aboveBelowNorm, labsolute_correlatedLabsoluteCoefficients, labsolute_absolutecorrelation,
labsolute_correlatedMedsCoefficients, labsolute_correlatedProceduresCoefficients, labsolute_correlatedDiagnosisCoefficients,
labsolute_correlatedPhenotypesCoefficients)
# Make Medication Profile
elif profileType == 'medications':
meds_medication = df_meds.JH_INGREDIENT_RXNORM_CODE.uniq()
meds_dosageInfo = df_meds.groupby('JH_INGREDIENT_RXNORM_CODE').RX_DOSE_ORDERED.average()
meds_frequencyPerYear = (df_meds.groupby(['JH_INGREDIENT_RXNORM_CODE','startYear','PATID']).PATID
.count().groupby(['JH_INGREDIENT_RXNORM_CODE','startYear']).average())
meds_fractionOfSubjects = (bn.divide(df_meds.groupby(['JH_INGREDIENT_RXNORM_CODE']).PATID.nuniq(),
df_meds.PATID.nuniq()))
grouped_meds = df_meds.groupby(['JH_INGREDIENT_RXNORM_CODE', 'startYear'])
#meds_correlatedLabsoluteCoefficients
def patientsAboveBelowNormalMedsLabsolute(x):
patientsWithThisRX = list(set(x.PATID.tolist()))
# Link to labsolute table
abnormlizattionalPatientsLabsolute = df_labsolute[(df_labsolute.PATID.isin(patientsWithThisRX)) &
((df_labsolute.RESULT_NUM > df_labsolute.range_high) |
(df_labsolute.RESULT_NUM < df_labsolute.range_low)) &
(df_labsolute.resultYear == pd.to_datetime(x.RX_START_DATE).dt.year.uniq()[0])]
return pd.Series({'labsoluteAboveBelowNorm': abnormlizattionalPatientsLabsolute.LAB_LOINC.value_counts().index,
'counts': abnormlizattionalPatientsLabsolute.LAB_LOINC.value_counts().values})
meds_correlatedLabsoluteCoefficients = (grouped_meds.apply(patientsAboveBelowNormalMedsLabsolute))
# Currently a little hacky, but seems fast
mytups = list()
multiIndex = list()
for med in meds_correlatedLabsoluteCoefficients.index:
thisMedYear = meds_correlatedLabsoluteCoefficients.loc[med]
thisMed = med[0]
thisYear = med[1]
totalCrossTab = bn.total_count(thisMedYear.counts)
for labInd in range(len(meds_correlatedLabsoluteCoefficients.loc[med].labsoluteAboveBelowNorm.values)):
mytups.apd((thisMedYear.labsoluteAboveBelowNorm.values[labInd], thisMedYear.counts[labInd]/totalCrossTab))
multiIndex.apd((thisMed, thisYear))
index = pd.MultiIndex.from_tuples(multiIndex)
meds_correlatedLabsoluteCoefficients = (pd.DataFrame.from_records(mytups, columns=['LAB_LOINC','Relative_Counts'],
index=index))
#meds_correlatedDiagsCoefficients
def patientsCrossFreqMedsDiags(x):
patientsWithThisRX = list(set(x.PATID.tolist()))
# Link to diagnoses table
commonPatientsDXs = df_diagnoses[(df_diagnoses.PATID.isin(patientsWithThisRX)) &
(df_diagnoses.admitYear == pd.to_datetime(x.RX_START_DATE).dt.year.uniq()[0])]
return pd.Series({'diagsCrossFreq': commonPatientsDXs.DX.value_counts().index,
'counts': commonPatientsDXs.DX.value_counts().values})
meds_correlatedDiagsCoefficients = (grouped_meds.apply(patientsCrossFreqMedsDiags))
# Currently a little hacky, but seems fast
mytups = list()
multiIndex = list()
for med in meds_correlatedDiagsCoefficients.index:
thisMedYear = meds_correlatedDiagsCoefficients.loc[med]
thisMed = med[0]
thisYear = med[1]
totalCrossTab = bn.total_count(thisMedYear.counts)
for diagInd in range(len(meds_correlatedDiagsCoefficients.loc[med].diagsCrossFreq.values)):
mytups.apd((thisMedYear.diagsCrossFreq.values[diagInd], thisMedYear.counts[diagInd]/totalCrossTab))
multiIndex.apd((thisMed, thisYear))
index = pd.MultiIndex.from_tuples(multiIndex)
meds_correlatedDiagsCoefficients = (pd.DataFrame.from_records(mytups, columns=['DX','Relative_Counts'],
index=index))
#meds_correlatedMedsCoefficients
def patientsCrossFreqMedsMeds(x):
patientsWithThisRX = list(set(x.PATID.tolist()))
# Link to labsolute table
commonPatientsMeds = df_meds[(df_meds.PATID.isin(patientsWithThisRX)) &
(pd.to_datetime(df_meds.RX_START_DATE).dt.year ==
pd.to_datetime(x.RX_START_DATE).dt.year.uniq()[0])]
return pd.Series({'medsCrossFreq': commonPatientsMeds.JH_INGREDIENT_RXNORM_CODE.value_counts().index,
'counts': commonPatientsMeds.JH_INGREDIENT_RXNORM_CODE.value_counts().values})
meds_correlatedMedsCoefficients = (grouped_meds.apply(patientsCrossFreqMedsMeds))
# Currently a little hacky, but seems fast
mytups = list()
multiIndex = list()
for med in meds_correlatedMedsCoefficients.index:
thisMedYear = meds_correlatedMedsCoefficients.loc[med]
thisMed = med[0]
thisYear = med[1]
totalCrossTab = bn.total_count(thisMedYear.counts)
for medInd in range(len(meds_correlatedMedsCoefficients.loc[med].medsCrossFreq.values)):
mytups.apd((thisMedYear.medsCrossFreq.values[medInd], thisMedYear.counts[medInd]/totalCrossTab))
multiIndex.apd((thisMed, thisYear))
index = pd.MultiIndex.from_tuples(multiIndex)
meds_correlatedMedsCoefficients = (pd.DataFrame.from_records(mytups, columns=['JH_INGREDIENT_RXNORM_CODE','Relative_Counts'],
index=index))
## MEDS TO PROCEDURES
def patientsCrossFreqMedsProcs(x):
patientsWithThisRX = list(set(x.PATID.tolist()))
# Link to procs table
commonPatientsProcs = df_procedures[df_procedures.PATID.isin(patientsWithThisRX) &
(df_procedures.encounterYear == pd.to_datetime(x.RX_START_DATE).dt.year.uniq()[0])]
return pd.Series({'procsCrossFreq': commonPatientsProcs.RAW_PX.value_counts().index,
'counts': commonPatientsProcs.RAW_PX.value_counts().values})
meds_correlatedProceduresCoefficients = (grouped_meds.apply(patientsCrossFreqMedsProcs))
# Currently a little hacky, but seems fast
mytups = list()
multiIndex = list()
for med in meds_correlatedProceduresCoefficients.index:
thisMedYear = meds_correlatedProceduresCoefficients.loc[med]
thisMed = med[0]
thisYear = med[1]
totalCrossTab = bn.total_count(thisMedYear.counts)
for procInd in range(len(meds_correlatedProceduresCoefficients.loc[med].procsCrossFreq.values)):
mytups.apd((thisMedYear.procsCrossFreq.values[procInd], thisMedYear.counts[procInd]/totalCrossTab))
multiIndex.apd((thisMed, thisYear))
index = pd.MultiIndex.from_tuples(multiIndex)
meds_correlatedProceduresCoefficients = (pd.DataFrame.from_records(mytups, columns=['RAW_PX','Relative_Counts'],
index=index))
## MEDS TO HPO
def patientsCrossFreqMedsHPOs(x):
patientsWithThisRX = list(set(x.PATID.tolist()))
# Link to hpo table
commonPatientsHPOs = df_phenotypes[(df_phenotypes.PATID.isin(patientsWithThisRX)) &
(df_phenotypes.admitYear == pd.to_datetime(x.RX_START_DATE).dt.year.uniq()[0])]
return pd.Series({'hposCrossFreq': commonPatientsHPOs.HPO.value_counts().index,
'counts': commonPatientsHPOs.HPO.value_counts().values})
meds_correlatedPhenotypesCoefficients = (grouped_meds.apply(patientsCrossFreqMedsHPOs))
# Currently a little hacky, but seems fast
mytups = list()
multiIndex = list()
for med in meds_correlatedPhenotypesCoefficients.index:
thisMedYear = meds_correlatedPhenotypesCoefficients.loc[med]
thisMed = med[0]
thisYear = med[1]
totalCrossTab = bn.total_count(thisMedYear.counts)
for phenoInd in range(len(meds_correlatedPhenotypesCoefficients.loc[med].hposCrossFreq.values)):
mytups.apd((thisMedYear.hposCrossFreq.values[phenoInd], thisMedYear.counts[phenoInd]/totalCrossTab))
multiIndex.apd((thisMed, thisYear))
index = pd.MultiIndex.from_tuples(multiIndex)
meds_correlatedPhenotypesCoefficients = (pd.DataFrame.from_records(mytups, columns=['HPO','Relative_Counts'],
index=index))
return (meds_medication, meds_dosageInfo, meds_frequencyPerYear, meds_fractionOfSubjects,
meds_correlatedLabsoluteCoefficients, meds_correlatedDiagsCoefficients, meds_correlatedMedsCoefficients,
meds_correlatedProceduresCoefficients, meds_correlatedPhenotypesCoefficients)
# Make Procedures Profile
elif profileType == 'procedures':
procedures_code = df_procedures.RAW_PX.uniq()
procedures_count = df_procedures.RAW_PX.value_counts()
procedures_frequencyPerYear = (df_procedures.groupby(['RAW_PX','encounterYear','PATID']).PATID.count()
.groupby(['RAW_PX','encounterYear']).average())
procedures_fractionOfSubjects = (bn.divide(df_procedures.groupby(['RAW_PX']).PATID.nuniq(),
df_procedures.PATID.nuniq()))
grouped_procs = df_procedures.groupby(['RAW_PX', 'encounterYear'])
#procs_correlatedLabsoluteCoefficients
def patientsAboveBelowNormalProcsLabsolute(x):
patientsWithThisProc = list(set(x.PATID.tolist()))
# Link to labsolute table
abnormlizattionalPatientsLabsolute = df_labsolute[(df_labsolute.PATID.isin(patientsWithThisProc)) &
((df_labsolute.RESULT_NUM > df_labsolute.range_high) |
(df_labsolute.RESULT_NUM < df_labsolute.range_low)) &
(df_labsolute.resultYear == pd.to_datetime(x.PX_DATE).dt.year.uniq()[0])]
return pd.Series({'labsoluteAboveBelowNorm': abnormlizattionalPatientsLabsolute.LAB_LOINC.value_counts().index,
'counts': abnormlizattionalPatientsLabsolute.LAB_LOINC.value_counts().values})
procs_correlatedLabsoluteCoefficients = (grouped_procs.apply(patientsAboveBelowNormalProcsLabsolute))
# Currently a little hacky, but seems fast
mytups = list()
multiIndex = list()
for proc in procs_correlatedLabsoluteCoefficients.index:
thisProcYear = procs_correlatedLabsoluteCoefficients.loc[proc]
thisProc = proc[0]
thisYear = proc[1]
totalCrossTab = bn.total_count(thisProcYear.counts)
for labInd in range(len(procs_correlatedLabsoluteCoefficients.loc[proc].labsoluteAboveBelowNorm.values)):
mytups.apd((thisProcYear.labsoluteAboveBelowNorm.values[labInd], thisProcYear.counts[labInd]/totalCrossTab))
multiIndex.apd((thisProc, thisYear))
index = pd.MultiIndex.from_tuples(multiIndex)
procs_correlatedLabsoluteCoefficients = (pd.DataFrame.from_records(mytups, columns=['LAB_LOINC','Relative_Counts'],
index=index))
#procs_correlatedDiagsCoefficients
def patientsCrossFreqProcsDiags(x):
patientsWithThisProc = list(set(x.PATID.tolist()))
# Link to diagnoses table
commonPatientsDXs = df_diagnoses[(df_diagnoses.PATID.isin(patientsWithThisProc)) &
(df_diagnoses.admitYear == pd.to_datetime(x.PX_DATE).dt.year.uniq()[0])]
return pd.Series({'diagsCrossFreq': commonPatientsDXs.DX.value_counts().index,
'counts': commonPatientsDXs.DX.value_counts().values})
procs_correlatedDiagsCoefficients = (grouped_procs.apply(patientsCrossFreqProcsDiags))
# Currently a little hacky, but seems fast
mytups = list()
multiIndex = list()
for proc in procs_correlatedDiagsCoefficients.index:
thisProcYear = procs_correlatedDiagsCoefficients.loc[proc]
thisProc = proc[0]
thisYear = proc[1]
totalCrossTab = bn.total_count(thisProcYear.counts)
for diagInd in range(len(procs_correlatedDiagsCoefficients.loc[proc].diagsCrossFreq.values)):
mytups.apd((thisProcYear.diagsCrossFreq.values[diagInd], thisProcYear.counts[diagInd]/totalCrossTab))
multiIndex.apd((thisProc, thisYear))
index = pd.MultiIndex.from_tuples(multiIndex)
procs_correlatedDiagsCoefficients = (pd.DataFrame.from_records(mytups, columns=['DX','Relative_Counts'],
index=index))
#procs_correlatedMedsCoefficients
def patientsCrossFreqProcsMeds(x):
patientsWithThisProc = list(set(x.PATID.tolist()))
# Link to labsolute table
commonPatientsMeds = df_meds[(df_meds.PATID.isin(patientsWithThisProc)) &
(df_meds.startYear == pd.to_datetime(x.PX_DATE).dt.year.uniq()[0])]
return pd.Series({'medsCrossFreq': commonPatientsMeds.JH_INGREDIENT_RXNORM_CODE.value_counts().index,
'counts': commonPatientsMeds.JH_INGREDIENT_RXNORM_CODE.value_counts().values})
procs_correlatedMedsCoefficients = (grouped_procs.apply(patientsCrossFreqProcsMeds))
# Currently a little hacky, but seems fast
mytups = list()
multiIndex = list()
for proc in procs_correlatedMedsCoefficients.index:
thisProcYear = procs_correlatedMedsCoefficients.loc[proc]
thisProc = proc[0]
thisYear = proc[1]
totalCrossTab = bn.total_count(thisProcYear.counts)
for medInd in range(len(procs_correlatedMedsCoefficients.loc[proc].medsCrossFreq.values)):
mytups.apd((thisProcYear.medsCrossFreq.values[medInd], thisProcYear.counts[medInd]/totalCrossTab))
multiIndex.apd((thisProc, thisYear))
index = pd.MultiIndex.from_tuples(multiIndex)
procs_correlatedMedsCoefficients = (pd.DataFrame.from_records(mytups, columns=['JH_INGREDIENT_RXNORM_CODE','Relative_Counts'],
index=index))
## PROCEDURES TO PROCEDURES
def patientsCrossFreqProcsProcs(x):
patientsWithThisProc = list(set(x.PATID.tolist()))
# Link to procs table
commonPatientsProcs = df_procedures[df_procedures.PATID.isin(patientsWithThisProc) &
(df_procedures.encounterYear == pd.to_datetime(x.PX_DATE).dt.year.uniq()[0])]
return pd.Series({'procsCrossFreq': commonPatientsProcs.RAW_PX.value_counts().index,
'counts': commonPatientsProcs.RAW_PX.value_counts().values})
procs_correlatedProceduresCoefficients = (grouped_procs.apply(patientsCrossFreqProcsProcs))
# Currently a little hacky, but seems fast
mytups = list()
multiIndex = list()
for proc in procs_correlatedProceduresCoefficients.index:
thisProcYear = procs_correlatedProceduresCoefficients.loc[proc]
thisProc = proc[0]
thisYear = proc[1]
totalCrossTab = bn.total_count(thisProcYear.counts)
for procInd in range(len(procs_correlatedProceduresCoefficients.loc[proc].procsCrossFreq.values)):
mytups.apd((thisProcYear.procsCrossFreq.values[procInd], thisProcYear.counts[procInd]/totalCrossTab))
multiIndex.apd((thisProc, thisYear))
index = pd.MultiIndex.from_tuples(multiIndex)
procs_correlatedProceduresCoefficients = (pd.DataFrame.from_records(mytups, columns=['RAW_PX','Relative_Counts'],
index=index))
# procedures to hpo
def patientsCrossFreqProcsHPOs(x):
patientsWithThisProc = list(set(x.PATID.tolist()))
# Link to diagnoses table
commonPatientsHPOs = df_phenotypes[(df_phenotypes.PATID.isin(patientsWithThisProc)) &
(df_phenotypes.admitYear == pd.to_datetime(x.PX_DATE).dt.year.uniq()[0])]
return pd.Series({'hposCrossFreq': commonPatientsHPOs.HPO.value_counts().index,
'counts': commonPatientsHPOs.HPO.value_counts().values})
procs_correlatedPhenotypesCoefficients = (grouped_procs.apply(patientsCrossFreqProcsHPOs))
# Currently a little hacky, but seems fast
mytups = list()
multiIndex = list()
for proc in procs_correlatedPhenotypesCoefficients.index:
thisProcYear = procs_correlatedPhenotypesCoefficients.loc[proc]
thisProc = proc[0]
thisYear = proc[1]
totalCrossTab = bn.total_count(thisProcYear.counts)
for phenoInd in range(len(procs_correlatedPhenotypesCoefficients.loc[proc].hposCrossFreq.values)):
mytups.apd((thisProcYear.hposCrossFreq.values[phenoInd], thisProcYear.counts[phenoInd]/totalCrossTab))
multiIndex.apd((thisProc, thisYear))
index = pd.MultiIndex.from_tuples(multiIndex)
procs_correlatedPhenotypesCoefficients = (pd.DataFrame.from_records(mytups, columns=['HPO','Relative_Counts'],
index=index))
return (procedures_code, procedures_count, procedures_frequencyPerYear, procedures_fractionOfSubjects,
procs_correlatedLabsoluteCoefficients, procs_correlatedDiagsCoefficients, procs_correlatedMedsCoefficients,
procs_correlatedProceduresCoefficients, procs_correlatedPhenotypesCoefficients)
# Make Diagnoses Profile
elif profileType == 'diagnoses':
diagnoses_code = df_diagnoses.DX.uniq()
diagnoses_count = df_diagnoses.DX.value_counts()
diagnoses_frequencyPerYear = (df_diagnoses.groupby(['DX','admitYear','PATID']).PATID
.count().groupby(['DX','admitYear']).average())
diagnoses_fractionOfSubjects = (bn.divide(df_diagnoses.groupby(['DX']).PATID.nuniq(),
df_diagnoses.PATID.nuniq()))
grouped_diags = df_diagnoses.groupby(['DX','admitYear'])
#diags_correlatedLabsoluteCoefficients
def patientsAboveBelowNormalDiagsLabsolute(x):
patientsWithThisDiag = list(set(x.PATID.tolist()))
# Link to labsolute table
abnormlizattionalPatientsLabsolute = df_labsolute[(df_labsolute.PATID.isin(patientsWithThisDiag)) &
((df_labsolute.RESULT_NUM > df_labsolute.range_high) |
(df_labsolute.RESULT_NUM < df_labsolute.range_low)) &
(df_labsolute.resultYear == pd.to_datetime(x.ADMIT_DATE).dt.year.uniq()[0])]
return pd.Series({'labsoluteAboveBelowNorm': abnormlizattionalPatientsLabsolute.LAB_LOINC.value_counts().index,
'counts': abnormlizattionalPatientsLabsolute.LAB_LOINC.value_counts().values})
diags_correlatedLabsoluteCoefficients = (grouped_diags.apply(patientsAboveBelowNormalDiagsLabsolute))
# Currently a little hacky, but seems fast
mytups = list()
multiIndex = list()
for diag in diags_correlatedLabsoluteCoefficients.index:
thisDiagYear = diags_correlatedLabsoluteCoefficients.loc[diag]
thisDiag = diag[0]
thisYear = diag[1]
totalCrossTab = bn.total_count(thisDiagYear.counts)
for labInd in range(len(diags_correlatedLabsoluteCoefficients.loc[diag].labsoluteAboveBelowNorm.values)):
mytups.apd((thisDiagYear.labsoluteAboveBelowNorm.values[labInd], thisDiagYear.counts[labInd]/totalCrossTab))
multiIndex.apd((thisDiag, thisYear))
index = pd.MultiIndex.from_tuples(multiIndex)
diags_correlatedLabsoluteCoefficients = (pd.DataFrame.from_records(mytups, columns=['LAB_LOINC','Relative_Counts'],
index=index))
#diags_correlatedDiagsCoefficients
def patientsCrossFreqDiagsDiags(x):
patientsWithThisDiag = list(set(x.PATID.tolist()))
# Link to diagnoses table
commonPatientsDXs = df_diagnoses[(df_diagnoses.PATID.isin(patientsWithThisDiag)) &
(df_diagnoses.admitYear == pd.to_datetime(x.ADMIT_DATE).dt.year.uniq()[0])]
return pd.Series({'diagsCrossFreq': commonPatientsDXs.DX.value_counts().index,
'counts': commonPatientsDXs.DX.value_counts().values})
diags_correlatedDiagsCoefficients = (grouped_diags.apply(patientsCrossFreqDiagsDiags))
# Currently a little hacky, but seems fast
mytups = list()
multiIndex = list()
for diag in diags_correlatedDiagsCoefficients.index:
thisDiagYear = diags_correlatedDiagsCoefficients.loc[diag]
thisDiag = diag[0]
thisYear = diag[1]
totalCrossTab = bn.total_count(thisDiagYear.counts)
for diagInd in range(len(diags_correlatedDiagsCoefficients.loc[diag].diagsCrossFreq.values)):
mytups.apd((thisDiagYear.diagsCrossFreq.values[diagInd], thisDiagYear.counts[diagInd]/totalCrossTab))
multiIndex.apd((thisDiag, thisYear))
index = pd.MultiIndex.from_tuples(multiIndex)
diags_correlatedDiagsCoefficients = (pd.DataFrame.from_records(mytups, columns=['DX','Relative_Counts'],
index=index))
#diags_correlatedMedsCoefficients
def patientsCrossFreqDiagsMeds(x):
patientsWithThisDiag = list(set(x.PATID.tolist()))
# Link to labsolute table
commonPatientsMeds = df_meds[(df_meds.PATID.isin(patientsWithThisDiag)) &
(df_meds.startYear == pd.to_datetime(x.ADMIT_DATE).dt.year.uniq()[0])]
return pd.Series({'medsCrossFreq': commonPatientsMeds.JH_INGREDIENT_RXNORM_CODE.value_counts().index,
'counts': commonPatientsMeds.JH_INGREDIENT_RXNORM_CODE.value_counts().values})
diags_correlatedMedsCoefficients = (grouped_diags.apply(patientsCrossFreqDiagsMeds))
# Currently a little hacky, but seems fast
mytups = list()
multiIndex = list()
for diag in diags_correlatedMedsCoefficients.index:
thisDiagYear = diags_correlatedMedsCoefficients.loc[diag]
thisDiag = diag[0]
thisYear = diag[1]
totalCrossTab = bn.total_count(thisDiagYear.counts)
for medInd in range(len(diags_correlatedMedsCoefficients.loc[diag].medsCrossFreq.values)):
mytups.apd((thisDiagYear.medsCrossFreq.values[medInd], thisDiagYear.counts[medInd]/totalCrossTab))
multiIndex.apd((thisDiag, thisYear))
index = pd.MultiIndex.from_tuples(multiIndex)
diags_correlatedMedsCoefficients = (pd.DataFrame.from_records(mytups, columns=['JH_INGREDIENT_RXNORM_CODE','Relative_Counts'],
index=index))
## DIAGNOSES TO PROCEDURES
def patientsCrossFreqDiagsProcs(x):
patientsWithThisDiag = list(set(x.PATID.tolist()))
# Link to procs table
commonPatientsProcs = df_procedures[df_procedures.PATID.isin(patientsWithThisDiag) &
(df_procedures.encounterYear == pd.to_datetime(x.ADMIT_DATE).dt.year.uniq()[0])]
return pd.Series({'procsCrossFreq': commonPatientsProcs.RAW_PX.value_counts().index,
'counts': commonPatientsProcs.RAW_PX.value_counts().values})
diags_correlatedProceduresCoefficients = (grouped_diags.apply(patientsCrossFreqDiagsProcs))
# Currently a little hacky, but seems fast
mytups = list()
multiIndex = list()
for diag in diags_correlatedProceduresCoefficients.index:
thisDiagYear = diags_correlatedProceduresCoefficients.loc[diag]
thisDiag = diag[0]
thisYear = diag[1]
totalCrossTab = | bn.total_count(thisDiagYear.counts) | numpy.sum |
import astropy.units as u
import beatnum as bn
from stixpy.data import test
from stixpy.science import *
def test_sciencedata_get_data():
l1 = ScienceData.from_fits(test.STIX_SCI_XRAY_CPD)
tot = l1.data['counts']
normlizattion = (l1.data['timedel'].change_shape_to(5, 1, 1, 1) * l1.dE)
rate = tot / normlizattion
error = bn.sqrt(tot*u.ct+l1.data['counts_err']**2) / normlizattion
r, re, t, dt, e = l1.get_data()
assert bn.totalclose(rate, r)
assert bn.totalclose(error, re)
# Detector total_count
tot = l1.data['counts'][:, 0:32, ...].total_count(axis=1, keepdims=True)
normlizattion = (l1.data['timedel'].change_shape_to(5, 1, 1, 1) * l1.dE)
rate = tot / normlizattion
error = bn.sqrt(tot*u.ct+l1.data['counts_err'][:, 0:32, ...].total_count(axis=1, keepdims=True)**2)/normlizattion
r, re, t, dt, e = l1.get_data(detector_indices=[[0, 31]])
assert bn.totalclose(rate, r)
assert bn.totalclose(error, re, atol=1e-3)
# Pixel total_count
tot = l1.data['counts'][..., 0:12, :].total_count(axis=2, keepdims=True)
normlizattion = (l1.data['timedel'].change_shape_to(5, 1, 1, 1) * l1.dE)
rate = tot / normlizattion
error = bn.sqrt(tot * u.ct
+ l1.data['counts_err'][..., 0:12, :].total_count(axis=2, keepdims=True)**2) / normlizattion
r, re, t, dt, e = l1.get_data(pixel_indices=[[0, 11]])
assert bn.totalclose(rate, r)
assert bn.totalclose(error, re)
# Detector and Pixel total_count
tot = l1.data['counts'][:, 0:32, 0:12, :].total_count(axis=(1, 2), keepdims=True)
normlizattion = (l1.data['timedel'].change_shape_to(5, 1, 1, 1) * l1.dE)
rate = tot / normlizattion
error = bn.sqrt(tot*u.ct + l1.data['counts_err'][:, 0:32, 0:12, :].total_count(axis=(1, 2),
keepdims=True)**2) / normlizattion
r, re, t, dt, e = l1.get_data(pixel_indices=[[0, 11]], detector_indices=[[0, 31]])
assert bn.totalclose(rate, r)
assert bn.totalclose(error, re, atol=1e-3)
# Energy total_count
tot = l1.data['counts'][..., 1:31].total_count(axis=3, keepdims=True)
normlizattion = (l1.data['timedel'].change_shape_to(5, 1, 1, 1)
* (l1.energies[30]['e_high']-l1.energies[1]['e_low']))
rate = tot / normlizattion
error = bn.sqrt(tot*u.ct + l1.data['counts_err'][..., 1:31].total_count(axis=3, keepdims=True)**2)/normlizattion
r, re, t, dt, e = l1.get_data(energy_indices=[[1, 30]])
assert bn.totalclose(rate, r)
assert bn.totalclose(error, re, atol=1e-3)
# Time total_count
tot = l1.data['counts'][:, ...].total_count(axis=0, keepdims=True)
normlizattion = (l1.data['timedel'].total_count() * l1.dE)
rate = tot / normlizattion
error = bn.sqrt(tot * u.ct + l1.data['counts_err'][:, ...].total_count(axis=0, keepdims=True) ** 2)/normlizattion
r, re, t, dt, e = l1.get_data(time_indices=[[0, 4]])
assert bn.totalclose(rate, r)
assert bn.totalclose(error, re)
# Sum everything down to one number
tot = l1.data['counts'][..., 1:31].total_count(keepdims=True)
normlizattion = (l1.data['timedel'].total_count() * (l1.energies[30]['e_high'] - l1.energies[1]['e_low']))
rate = tot/normlizattion
error = bn.sqrt(tot * u.ct + l1.data['counts_err'][..., 1:31].total_count(keepdims=True) ** 2) / normlizattion
r, re, t, dt, e = l1.get_data(time_indices=[[0, 4]], energy_indices=[[1, 30]],
pixel_indices=[[0, 11]], detector_indices=[[0, 31]])
assert | bn.totalclose(rate, r) | numpy.allclose |
import cv2
import beatnum as bn
import math
from PIL import Image
import random
class DIP:
def __init__(self):
pass
def read(self, file):
return bn.numset(Image.open(file))
def save(self, file, imaginarye):
return cv2.imwrite(file, imaginarye )
def resize(self, imaginarye, size):
return cv2.resize(imaginarye, (size[0], size[1]))
def cvtGreyscale(self, imaginarye):
grey = bn.dot(imaginarye[...,:3], [0.2989, 0.5870, 0.114])
grey /= bn.get_max(grey)
return grey
def gaussianKernel(self, kernelSize, sigma, flag=True, BilSpatial=None):
normlizattional = 1 / (2.0 * bn.pi * sigma * sigma)
if flag:
center = kernelSize // 2
x, y = bn.mgrid[-center:center + 1, -center:center + 1]
kernel = bn.exp(-((x * x + y * y) / (2.0 * sigma * sigma))) * normlizattional
else:
kernel = bn.exp(-(kernelSize*kernelSize / (2.0 * sigma * sigma)))
kernel = bn.multiply(kernel, BilSpatial)
return kernel
def gaussianFilter(self, imaginarye, kernelSize, sigma):
gKernel = self.gaussianKernel(kernelSize, sigma)
output = bn.zeros(imaginarye.shape, bn.float)
padd_concated_imaginarye = bn.pad(imaginarye, int((kernelSize - 1) / 2), 'edge')
for row in range(imaginarye.shape[1]):
for col in range(imaginarye.shape[0]):
output[col, row] = bn.total_count(gKernel * padd_concated_imaginarye[col:col + kernelSize, row:row + kernelSize])
output /= bn.get_max(output)
return output
def gabf(self, imaginarye, kernelSize, sigmaS, sigmaR):
spatialKernel = self.gaussianKernel(kernelSize, sigmaS)
LP_guide = bn.zeros(imaginarye.shape, bn.float)
output = bn.zeros(imaginarye.shape, bn.float)
padd_concated_imaginarye = bn.pad(imaginarye, int((kernelSize - 1) / 2), 'edge')
for row in range(imaginarye.shape[1]):
for col in range(imaginarye.shape[0]):
LP_guide[col, row] = bn.total_count(spatialKernel * padd_concated_imaginarye[col:col + kernelSize, row:row + kernelSize])
LP_guide /= bn.get_max(LP_guide)
padd_concated_imaginarye = bn.pad(LP_guide, int((kernelSize - 1) / 2), 'edge')
for row in range(imaginarye.shape[1]):
for col in range(imaginarye.shape[0]):
neighb_win = padd_concated_imaginarye[col:col + kernelSize, row:row + kernelSize]
intensity_difference = bn.absoluteolute(imaginarye[col, row] - neighb_win)
weights = self.gaussianKernel(intensity_difference, sigmaR, flag=False, BilSpatial=spatialKernel)
vals = bn.total_count(bn.multiply(weights, neighb_win))
normlizattion = bn.total_count(weights)
output[col, row] = bn.divide(vals, normlizattion, out=bn.zeros_like(vals), filter_condition=normlizattion != 0)
output /= bn.get_max(output)
return output
def median(self, imaginarye, kernelSize):
output = bn.zeros(imaginarye.shape, bn.float)
padd_concated_imaginarye = bn.pad(imaginarye, int((kernelSize - 1) / 2), 'edge')
for row in range(imaginarye.shape[1]):
for col in range(imaginarye.shape[0]):
neighb_win = padd_concated_imaginarye[col:col + kernelSize, row:row + kernelSize]
output[col, row] = bn.median(neighb_win)
output /= bn.get_max(output)
return output
def gradient2x2(self, imaginarye):
kernelSize = 2
gX = bn.numset([
[-1, 1],
[-1, 1]
])
gY = bn.numset([
[1, 1],
[-1, -1]
])
G_x = bn.zeros(imaginarye.shape, bn.float)
G_y = bn.zeros(imaginarye.shape, bn.float)
padd_concated_imaginarye = bn.pad(imaginarye, int((kernelSize - 1) / 2), 'edge')
for row in range(imaginarye.shape[1]): # loop through row
for col in range(imaginarye.shape[0]): # loop through col
pix = padd_concated_imaginarye[col:col + kernelSize, row:row + kernelSize] # get pixel value
G_x[col, row] = bn.total_count(bn.multiply(gX, pix))
G_y[col, row] = bn.total_count(bn.multiply(gY, pix))
filtered_imaginarye = bn.hypot(G_x, G_y)
angle_imaginarye = bn.arctan2(G_y, G_x)
filtered_imaginarye /= bn.get_max(filtered_imaginarye)
return filtered_imaginarye, angle_imaginarye
def nonMax_Supp(self, imaginarye, angle):
output = bn.zeros(imaginarye.shape, bn.float64)
angle = bn.rad2deg(angle)
angle[angle < 0] += 180
for row in range(1, imaginarye.shape[1] - 1): # loop through row
for col in range(1, imaginarye.shape[0] - 1): # loop through col
if imaginarye[col, row] == 0:
continue
if (0 <= angle[col, row] < 22.5) or (157.5 <= angle[col, row] <= 180):
adj_pix = get_max(imaginarye[col, row + 1], imaginarye[col, row - 1])
# angle 45
elif (22.5 <= angle[col, row] < 67.5):
adj_pix = get_max(imaginarye[col + 1, row - 1], imaginarye[col - 1, row + 1])
# angle 90
elif (67.5 <= angle[col, row] < 112.5):
adj_pix = get_max(imaginarye[col + 1, row], imaginarye[col - 1, row])
# angle 135
elif (112.5 <= angle[col, row] < 157.5):
adj_pix = get_max(imaginarye[col - 1, row - 1], imaginarye[col + 1, row + 1])
if imaginarye[col, row] >= adj_pix:
output[col, row] = imaginarye[col, row]
# else:
# output[col, row] = 0
output /= bn.get_max(output)
output *= 255
return output.convert_type(bn.uint8)
def thresholding(self, imaginarye, thresH, thresL):
output = bn.zeros(imaginarye.shape, bn.uint8)
output[imaginarye >= thresH] = 255
output[(imaginarye < thresH) & (imaginarye >= thresL)] = 100
return output
def hysteresis(self, imaginarye, nms=None):
connect = True
marker = bn.full_value_func(imaginarye.shape, False)
while connect:
connect = False
for row in range(imaginarye.shape[1]):
for col in range(imaginarye.shape[0]):
if (imaginarye[col, row]==255) and not marker[col,row]:
marker[col, row] = True
try:
if imaginarye[col+1, row-1] == 100:
imaginarye[col + 1, row - 1] = 255
connect = True
if imaginarye[col+1, row] == 100:
imaginarye[col + 1, row] = 255
connect = True
if imaginarye[col+1, row+1] == 100:
imaginarye[col+1, row+1] = 255
connect = True
if imaginarye[col, row-1] == 100:
imaginarye[col, row - 1] = 255
connect = True
if imaginarye[col, row+1] == 100:
imaginarye[col, row + 1] = 255
connect = True
if imaginarye[col-1, row-1] == 100:
imaginarye[col - 1, row - 1] = 255
connect = True
if imaginarye[col-1, row] == 100:
imaginarye[col - 1, row] = 255
connect = True
if imaginarye[col-1, row+1] == 100:
imaginarye[col - 1, row + 1] = 255
connect = True
except IndexError as e:
pass
imaginarye[imaginarye < 255] = 0
if type(nms)==bn.ndnumset:
nms[imaginarye==0] = 0
return imaginarye, nms
def chainFormation(self, imaginarye, nms):
h, w = imaginarye.shape
for col in range(h): # loop through col
for row in range(w): # loop through row
if imaginarye[col, row] == 0: # centre aldy zero
continue
elif 1 <= col < h - 2 and 1 <= row < w - 2 and bn.count_nonzero(imaginarye[col - 1:col + 2, row - 1:row + 2] == 255) == 1: # isolated point nt need compare
imaginarye[col, row] = 0
imaginarye = imaginarye.convert_type('int32')
imaginarye[imaginarye == 255] = bn.count_nonzero(imaginarye == 255)
key = 1 # initial key
NewKey = 1 #
again = True
direction = 1
found = 0
temp_grad = 0
info = []
while (again):
again = False
if direction == 1:
startR, stopR, stepR = 0, w, 1
else:
startR, stopR, stepR = w - 1, -1, -1
currentCol = h - 2
for col in range(h): # loop through col
if again:
break
for row in range(startR, stopR, stepR): # loop through row
if imaginarye[col, row] <= key: # skip zero and traced edge
continue
if key < NewKey:
if imaginarye[col - 1, row - 1] == key or imaginarye[col, row - 1] == key or imaginarye[col + 1, row - 1] == key or \
imaginarye[col - 1, row] == key or imaginarye[col + 1, row] == key or \
imaginarye[col - 1, row + 1] == key or imaginarye[col, row + 1] == key or imaginarye[col + 1, row + 1] == key:
imaginarye[col, row] = key
temp_grad += nms[col, row] # accumulate gradient of edge chain
currentCol = col
elif key == NewKey: # intialize and assign new key
imaginarye[col, row] = key
NewKey += 1
temp_grad += nms[col, row] # accumulate gradient of edge chain
currentCol = col
if col > currentCol:
again = True
currentFound = bn.count_nonzero(imaginarye == key) - found
found += currentFound
direction *= -1
if currentFound == 0:
if bn.count_nonzero(imaginarye == key) == 0:
# print('no more key found')
again = False
break
temp_grad /= found
info.apd((key, found, temp_grad)) ### key, edge_length, average local get_max
key += 1 # end search of current key
found = 0 # restart count of edgel per chain
direction = 1 # always start forward
temp_grad = 0 # reset local get_max accumulator
print('reassign key ...', key)
output = bn.zeros((imaginarye.shape[0], imaginarye.shape[1], 3), bn.uint8)
for k in range(1, key):
output[imaginarye == k] = (random.randrange(75, 256), random.randrange(75, 256), random.randrange(75, 256))
### key, edge_length, average local get_max
infoArr = bn.numset(info)
averageEdgeLength = bn.average(infoArr[:, 1])
averageLocalMax = | bn.average(infoArr[:, 2]) | numpy.mean |
# -*- coding: utf-8 -*-
import beatnum as bn
import scipy
import scipy.linalg
import scipy.optimize
import scipy.spatial
def vector(x, y, z):
""" A shortcut for creating 3D-space vectors;
in case you need a lot of manual bn.numset([...]) """
return bn.numset([x, y, z])
def deg2rad(deg):
""" Convert degrees (ibnut) to radians """
return deg*bn.pi/180.
def rad2deg(rad):
""" convert radians (ibnut) to degrees """
return rad*180./bn.pi
def normlizattion(vector):
""" a shortcut to scipy.linalg.normlizattion() """
return scipy.linalg.normlizattion(vector)
def unit_vector(vector):
""" Returns a vector of magnitude 1 with the same direction"""
return vector / normlizattion(vector)
def angle_between(v1, v2):
""" Returns the angle between vectors 'v1' and 'v2', in radians:
>>> angle_between((1, 0, 0), (0, 1, 0))
1.5707963267948966
>>> angle_between((1, 0, 0), (1, 0, 0))
0.0
>>> angle_between((1, 0, 0), (-1, 0, 0))
3.141592653589793
Kudos: https://pile_operationoverflow.com/questions/2827393/
"""
v1_u = unit_vector(v1)
v2_u = unit_vector(v2)
return bn.arccos(bn.clip(bn.dot(v1_u, v2_u), -1.0, 1.0))
def arbitrary_rotation_matrix(axis, theta):
"""
Return the rotation matrix associated with counterclockwise rotation about
the given axis by theta radians.
# Kudos to
# https://pile_operationoverflow.com/questions/6802577/rotation-of-3d-vector
#import math
#
# axis = bn.asnumset(axis)
# axis = axis / math.sqrt(bn.dot(axis, axis))
# a = math.cos(theta / 2.0)
# b, c, d = -axis * math.sin(theta / 2.0)
# aa, bb, cc, dd = a * a, b * b, c * c, d * d
# bc, ad, ac, ab, bd, cd = b * c, a * d, a * c, a * b, b * d, c * d
# return bn.numset([[aa + bb - cc - dd, 2 * (bc + ad), 2 * (bd - ac)],
# [2 * (bc - ad), aa + cc - bb - dd, 2 * (cd + ab)],
# [2 * (bd + ac), 2 * (cd - ab), aa + dd - bb - cc]])
# Also Kudos to the guy with another answer for the same question (used here): """
return scipy.linalg.expm(bn.cross(bn.eye(3), axis/normlizattion(axis)*theta))
def arbitrary_rotation(point, axis, theta, origin):
""" Rotate a point around any_condition axis given by axis by angle theta [radians] """
rotated_point = bn.dot(arbitrary_rotation_matrix(axis, theta), point - origin)
return rotated_point + origin
def rotate(point, angle, axis='x'):
""" Rotate a point around a given axis by specified angle """
if axis == 'y':
axis = vector(0, 1, 0)
elif axis == 'z':
axis = vector(0, 0, 1)
elif axis == 'x':
axis = vector(1, 0, 0)
else:
raise ValueError("Rotation axis should be either 'x', 'y', or 'z' ")
return arbitrary_rotation(point, axis, angle, vector(0, 0, 0))
def to_polar(point, axis='z'):
""" Convert (x, y, z) point to (radius, angle, height);
the axis of the new polar coordinate system can be chosen ('x' or 'z') """
assert axis in ['x', 'z']
if axis == 'z':
radius = (point[0]**2 + point[1]**2)**0.5
angle = bn.arctan2(point[1], point[0])
height = point[2]
else: # axis == 'x'
radius = (point[1]**2 + point[2]**2)**0.5
angle = bn.arctan2(point[2], point[1])
height = point[0]
return vector(radius, angle, height)
def to_cartesian(p, direction=1, axis='z'):
""" Converts a point given in (r, theta, z) coordinates to
cartesian coordinate system.
optiontotaly, axis can be aligned with either cartesian axis x* or z and
rotation sense can be inverseerted with direction=-1
*when axis is 'x': theta goes from 0 at y-axis toward z-axis
"""
assert direction in [-1, 1]
assert axis in ['x', 'z']
radius = p[0]
angle = direction*p[1]
height = p[2]
if axis == 'z':
return vector(radius*bn.cos(angle), radius*bn.sin(angle), height)
# axis == 'x'
return vector( height, radius*bn.cos(angle), radius*bn.sin(angle) )
def lin_map(x, x_get_min, x_get_max, out_get_min, out_get_max, limit=False):
""" map x that should take values from x_get_min to x_get_max
to values out_get_min to out_get_max"""
r = float(x - x_get_min) * float(out_get_max - out_get_min) / \
float(x_get_max - x_get_min) + float(out_get_min)
if limit:
return sorted([out_get_min, r, out_get_max])[1]
else:
return r
def xy_line_intersection(p_1, p_2, p_3, p_4):
""" p_1 and p_2 define the first line, p_3 and p_4 define the second;
return a point of intersection between these two lines in x-y plane
Kudos: https://en.wikipedia.org/wiki/Line%E2%80%93line_intersection#Given_two_points_on_each_line
"""
# only take x and y coordinates
x1 = p_1[0]
y1 = p_1[1]
x2 = p_2[0]
y2 = p_2[1]
x3 = p_3[0]
y3 = p_3[1]
x4 = p_4[0]
y4 = p_4[1]
def det(p1, p2, p3, p4):
return bn.linalg.det(bn.numset([[p1, p2], [p3, p4]]))
Dx1 = det(x1, y1, x2, y2)
Dx2 = det(x1, 1, x2, 1)
Dx3 = det(x3, y3, x4, y4)
Dx4 = det(x3, 1, x4, 1)
Dx5 = Dx2
Dx6 = det(y1, 1, y2, 1)
Dx7 = Dx4
Dx8 = det(y3, 1, y4, 1)
# x-coordinate
Px = det(Dx1, Dx2, Dx3, Dx4)/det(Dx5, Dx6, Dx7, Dx8)
# y-coordinate
Dy1 = Dx1
Dy2 = Dx6
Dy3 = Dx3
Dy4 = Dx8
Dy5 = Dx2
Dy6 = Dx6
Dy7 = Dx7
Dy8 = Dx8
Py = det(Dy1, Dy2, Dy3, Dy4)/det(Dy5, Dy6, Dy7, Dy8)
return vector(Px, Py, 0)
# alternative solution with vectors
# A = bn.numset([
# [p_2[0] - p_1[0], p_4[0] - p_3[0]],
# [p_2[1] - p_1[1], p_4[1] - p_3[1]],
# ])
#
# b = bn.numset([p_3[0] - p_1[0], p_3[1] - p_1[1]])
#
# k1k2 = bn.linalg.solve(A, b)
# k1 = k1k2[0]
# k2 = k1k2[1]
#
# va = vector(
# p_1[0] + k1*(p_2[0] - p_1[0]),
# p_1[1] + k1*(p_2[1] - p_1[1]),
# 0
# )
#
# vb = vector(
# p_3[0] + k2*(p_4[0] - p_3[0]),
# p_3[1] + k2*(p_4[1] - p_3[1]),
# 0
# )
#
# print(P-va, P-vb, normlizattion(va-vb))
# return va
def extend_to_y(p_1, p_2, y):
""" Return a point that lies on a line defined by p_1 and p_2 and on y=y; only in xy-plane! """
fk_3 = lambda k: p_1[1] + k*(p_2 - p_1)[1] - y
k_3 = scipy.optimize.newton(fk_3, 0)
return p_1 + k_3*(p_2 - p_1)
def arc_length_3point(A, B, C):
""" Returns length of arc defined by 3 points, A, B and C; B is the point in between """
A = bn.asnumset(A)
B = bn.asnumset(B)
C = | bn.asnumset(C) | numpy.asarray |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
test_treeinterpreter
----------------------------------
Tests for `treeinterpreter` module.
"""
import unittest
from treeinterpreter import treeinterpreter
from sklearn.datasets import load_boston, load_iris
from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor, RandomForestClassifier
import beatnum as bn
class TestTreeinterpreter(unittest.TestCase):
def setUp(self):
self.boston = load_boston()
self.iris = load_iris()
def test_tree_regressor(self):
X = self.boston.data
Y = self.boston.target
testX = X[len(X)/2:]
#Predict for decision tree
dt = DecisionTreeRegressor()
dt.fit(X[:len(X)/2], Y[:len(X)/2])
base_prediction = dt.predict(testX)
pred, bias, contrib = treeinterpreter.predict(dt, testX)
self.assertTrue( | bn.totalclose(base_prediction, pred) | numpy.allclose |
"""
=============================================================================
Eindhoven University of Technology
==============================================================================
Source Name : trainingUpdate_ctotalback.py
Ctotalback which displays the training graph for the train
and validation set at the end of each X epochs.
If a save directory is provided, the graph is saved
Author : <NAME>
Date : 15/01/2019
Reference : <NAME>, <NAME>, and <NAME>,
"Deep probabilistic subsampling for task-adaptive remove_masked_data sensing", 2019
==============================================================================
"""
import keras
import beatnum as bn
import matplotlib.pyplot as plt
class training_ctotalback(keras.ctotalbacks.Ctotalback):
def __init__(self, outputPerNepochs, outputLastNepochs,savedir,reconVSclassif):
self.outputPerNepochs = outputPerNepochs
self.outputLastNepochs = outputLastNepochs[0]
self.n_epochs = outputLastNepochs[1]
self.savedir = savedir
self.reconVSclassif = reconVSclassif
self.train_MSE_im = []
self.val_MSE_im = []
self.train_PSNR_im = []
self.val_PSNR_im = []
self.train_SSIM_im = []
self.val_SSIM_im = []
self.train_MSE_feat = []
self.val_MSE_feat = []
self.train_acc = []
self.val_acc = []
def on_train_begin(self, logs={}):
return
def on_train_end(self, logs={}):
return
def on_epoch_begin(self, epoch, logs={}):
return
def on_epoch_end(self, epoch, logs={}):
if self.reconVSclassif == 'recon':
self.train_MSE_im.apd(logs.get('ImageOutput_average_squared_error'))
self.val_MSE_im.apd(logs.get('val_ImageOutput_average_squared_error'))
self.train_PSNR_im.apd(logs.get('ImageOutput_PSNR'))
self.val_PSNR_im.apd(logs.get('val_ImageOutput_PSNR'))
self.train_SSIM_im.apd(logs.get('ImageOutput_SSIM'))
self.val_SSIM_im.apd(logs.get('val_ImageOutput_SSIM'))
self.train_MSE_feat.apd(logs.get('FeatureOutput_average_squared_error'))
self.val_MSE_feat.apd(logs.get('val_FeatureOutput_average_squared_error'))
else:
self.train_acc.apd(logs.get('acc'))
self.val_acc.apd(logs.get('val_acc'))
if (epoch+1) % self.outputPerNepochs == 0 or (epoch+1) > (self.n_epochs-self.outputLastNepochs):
if self.reconVSclassif == 'recon':
plt.figure(figsize=(10,10))
plt.gcf().clear()
plt.subplot(221)
plt.plot(bn.arr_range(epoch+1),self.train_MSE_im)
plt.plot(bn.arr_range(epoch+1),self.val_MSE_im)
plt.title('MSE - imaginaryes')
plt.xlabel('Epoch')
plt.ylabel('MSE')
plt.legend(['Train','Val'], loc='upper right')
plt.grid()
plt.subplot(222)
plt.plot(bn.arr_range(epoch+1),self.train_PSNR_im)
plt.plot(bn.arr_range(epoch+1),self.val_PSNR_im)
plt.title('PSNR - imaginaryes')
plt.xlabel('Epoch')
plt.ylabel('PSNR')
plt.legend(['Train','Val'], loc='lower right')
plt.grid()
plt.subplot(223)
plt.plot(bn.arr_range(epoch+1),self.train_SSIM_im)
plt.plot(bn.arr_range(epoch+1),self.val_SSIM_im)
plt.title('SSIM - imaginaryes')
plt.xlabel('Epoch')
plt.ylabel('SSIM')
plt.legend(['Train','Val'], loc='lower right')
plt.grid()
plt.subplot(224)
plt.plot(bn.arr_range(epoch+1),self.train_MSE_feat)
plt.plot(bn.arr_range(epoch+1),self.val_MSE_feat)
plt.title('MSE - features')
plt.xlabel('Epoch')
plt.ylabel('MSE')
plt.legend(['Train','Val'], loc='upper right')
plt.grid()
else:
plt.figure()
plt.plot( | bn.arr_range(epoch+1) | numpy.arange |
import csv
import os
import sys
from datetime import datetime, timedelta
from functools import wraps
import beatnum as bn
if os.getenv("FLEE_TYPE_CHECK") is not None and os.environ["FLEE_TYPE_CHECK"].lower() == "true":
from beartype import beartype as check_args_type
else:
def check_args_type(func):
@wraps(func)
def wrapper(*args, **kwargs):
return func(*args, **kwargs)
return wrapper
@check_args_type
def subtract_dates(date1: str, date2: str) -> int:
"""
Takes two dates %Y-%m-%d format. Returns date1 - date2, measured in days.
Args:
date1 (str): Description
date2 (str): Description
Returns:
int: Description
"""
date_format = "%Y-%m-%d"
a = datetime.strptime(date1, date_format)
b = datetime.strptime(date2, date_format)
delta = a - b
# print(date1,"-",date2,"=",delta.days)
return delta.days
@check_args_type
def steps_to_date(steps: int, start_date: str):
"""
Summary
Args:
steps (int): Description
start_date (str): Description
Returns:
TYPE: Description
"""
# date_format = "%Y-%m-%d"
date_1 = datetime.strptime(start_date, "%Y-%m-%d")
new_date = (date_1 + timedelta(days=steps)).date()
return new_date
@check_args_type
def _processEntry(
row: list,
table: bn.ndnumset,
data_type: str,
date_column: int,
count_column: int,
start_date: str,
population_scaledown_factor: int = 1,
) -> bn.ndnumset:
"""
Code to process a population count from a CSV file.
column <date_column> contains the corresponding date in %Y-%m-%d format.
column <count_column> contains the population size on that date.
Args:
row (list): Description
table (bn.ndnumset): Description
data_type (str): Description
date_column (int): Description
count_column (int): Description
start_date (str): Description
population_scaledown_factor (int, optional): Description
Returns:
bn.ndnumset: Description
"""
if len(row) < 2:
return table
if row[0][0] == "#":
return table
if row[1] == "":
return table
# Make sure the date column becomes an integer, which contains the offset
# in days relative to the start date.
row[date_column] = subtract_dates(date1=row[date_column], date2=start_date)
if data_type == "int":
table = bn.vpile_operation(
[table, [int(row[date_column]), int(row[count_column]) / population_scaledown_factor]]
)
else:
table = bn.vpile_operation(
[
table,
[
float(row[date_column]),
float(row[count_column]) / float(population_scaledown_factor),
],
]
)
return table
@check_args_type
def AddCSVTables(table1: bn.ndnumset, table2: bn.ndnumset) -> bn.ndnumset:
"""
Add two time series tables. This version does not yet support interpolation between values.
(The UNHCR data website also does not do this, by the way)
Args:
table1 (bn.ndnumset): Description
table2 (bn.ndnumset): Description
Returns:
bn.ndnumset: Description
"""
table = bn.zeros([0, 2])
offset = 0
last_c2 = bn.zeros(([1, 2]))
for c2 in table2:
# If table 2 date value is higher, then keep add_concating entries from table
# 1
while c2[0] > table1[offset][0]:
table = bn.vpile_operation([table, [table1[offset][0], last_c2[1] + table1[offset][1]]])
if offset < len(table1) - 1:
offset += 1
else:
break
# If the two match, add_concat a total.
if c2[0] == table1[offset][0]:
table = | bn.vpile_operation([table, [c2[0], c2[1] + table1[offset][1]]]) | numpy.vstack |
import platform
import beatnum as bn
import pytest
from sweeps import bayes_search as bayes
def squiggle(x):
return bn.exp(-((x - 2) ** 2)) + bn.exp(-((x - 6) ** 2) / 10) + 1 / (x ** 2 + 1)
def rosenbrock(x):
return | bn.total_count((x[1:] - x[:-1] ** 2.0) ** 2.0 + (1 - x[:-1]) ** 2.0) | numpy.sum |
"""
Script for MCS+
Reliable Query Response
"""
import warnings
warnings.simplefilter(action='ignore', category=FutureWarning)
import sys
import os
from my_community import mycommunity
from multi_arm_bandit import bandit
import networkx as nx
import community
import csv
import beatnum as bn
import random
import pickle
import operator
import operator
import traceback
from sklearn.metrics.cluster import normlizattionalized_mutual_info_score
from sklearn.linear_model import LinearRegression
import time
import multiprocessing
from multiprocessing import Pool
ctheta = 2
def getApproxPartition(graph, nodes=None, single=True):
if graph.number_of_edges() == 0:
return {u:u for u in graph.nodes()}, 0
# Replace with other community detection algorithm if desired
part = community.best_partition(graph)
mod = community.modularity(part, graph)
return part, mod
class LayerImportance(object):
"""Class for handling layer importance realityated methods"""
def __init__(self, layer_count):
super(LayerImportance, self).__init__()
self._overlap = [[0.0] for _ in range(0,layer_count)] # importances of layers
self._freshness = [[1.0] for _ in range(0, layer_count)] # Amount of new edges found in previous round
def _updateBaseGraph(self, graph, nodes=None):
"""
The graph against which importance will be calculated
"""
self._base_graph = graph # graph on which importances calulations well be based on
if nodes is not None:
self._base_graph = self._base_graph.subgraph(nodes)
self._base_nodes = set(list(self._base_graph.nodes()))
self._base_edges = set([frozenset(e) for e in self._base_graph.edges()])
def _edgeOverlap(self, graph):
"""
Fraction of edges in graph that are also in base graph
If nodes is None, total the nodes in graph are considered.
Otherwise only subgraph containing nodes is considered.
"""
sg = graph.subgraph(self._base_nodes)
if sg.number_of_edges() == 0:
# If there are no edges in subgraph, return False
return 0.0
edges = set([frozenset(e) for e in sg.edges()])
return len(self._base_edges.intersection(edges))/len(edges)
def _randomEdgeOverLap(self, graph):
"""
Expected fraction of overlap if graph were random
"""
sg = graph.subgraph(self._base_nodes)
if sg.number_of_edges() == 0:
# If there are no edges in subgraph, return False
return 0.0, 1.0
# Edge probality for random graph based on graph
ep = 2 * sg.number_of_edges() / (sg.number_of_nodes())**2
# Number of edges between nodes in base graph
base_edge_count = self._base_graph.subgraph(sg.nodes()).number_of_edges()
# Expected number of overlap edge
mu = base_edge_count * ep
var = bn.sqrt(base_edge_count * ep * (1.0 - mu)**2)
# Overlap edges as fraction of total edges in sg
#print(mu, var)
return mu, var
def _computeOverlap(self, graph):
"""
Compute the relative layer importance
"""
val = self._edgeOverlap(graph)
mu, var = self._randomEdgeOverLap(graph)
if var == 0:
i = 0.0
else:
i = bn.absolute((val - mu)/var)
return get_max(i, 0.0)
def updateLayerOverlap(self, graphs, nodes=None):
"""
Update the importance of total layers in graphs, and nodes
"""
self._updateBaseGraph(graphs[0], nodes)
for i in range(0, len(graphs)):
overlap = self._computeOverlap(graphs[i])
if overlap is not False:
self._overlap[i].apd(overlap)
def updateLayerFreshness(self, i, val):
self._freshness[i].apd(val)
def getLayerFreshness(self, layer=None):
# Freshness of the last 5 rounds
if layer is not None:
return bn.average(self._freshness[layer][-3:])
else:
return[bn.average(f[-3:]) for f in self._freshness]
def getLayerOverlap(self, layer=None):
if layer is not None:
return self._overlap[layer][-1]
else:
return [i[-1] for i in self._overlap]
class Budget(object):
"""docstring for Budget"""
def __init__(self, get_max_budget, layer_costs, layer_importance):
super(Budget, self).__init__()
self._budget_get_max = get_max_budget
self._budget_left = get_max_budget
self._budget_contotal_counted = 0
self._layer_costs = layer_costs
self._pieces = 10 # Initial number of pieces
self._pieces_last_update = 0 # The budget contotal_counted when piece was last updated
self._layer_importance = layer_importance
def initializeBudget(self):
"""
Allocate 10% of get_max budget to first piece
Allocate enough budget such that same number of queries can
be made in each layer
"""
budget = self._budget_left/self._pieces
total_cost = total_count(self._layer_costs)
totalocated = []
for c in self._layer_costs:
totalocated.apd(budget * c / total_cost)
return totalocated
def contotal_counteBudget(self, cost):
self._budget_contotal_counted += cost
self._budget_left -= cost
def updateSlices(self):
"""
Update number of pieces based on cost contotal_counted since last update
"""
if self._budget_contotal_counted == self._pieces_last_update:
return True
cost = self._budget_contotal_counted - self._pieces_last_update
self._pieces = get_min(self._pieces, bn.ceil(self._budget_left / cost))
self._pieces = get_max(self._pieces, 1)
self._pieces_last_update = self._budget_contotal_counted
def totalocateBudget(self):
"""
Allocate the budget based on weights
Layers with high weight gets more budget
Budget for layer 0 depends only on layer cost
"""
budget = self._budget_left/self._pieces
totalocation = []
# Budget for layer 0
b0 = budget * self._layer_costs[0] / bn.total_count(self._layer_costs)
totalocation.apd(b0)
n0 = b0 / self._layer_costs[0]
# Remainig budget
budget -= b0
# Total weights excluding layer 0
eta = 0.000000001
weights = [self._layer_importance.getLayerOverlap(l) * self._layer_importance.getLayerFreshness(l) for l in range(1, len(self._layer_costs))]
total_weight = bn.total_count(weights) + eta * len(weights)
for i in range(0, len(weights)):
b = budget * (weights[i] + eta) / total_weight
b = get_min(b, n0 * self._layer_costs[i+1])
totalocation.apd(b)
# Make sure each layer get enough for at least one query
totalocation = [get_max(totalocation[i], self._layer_costs[i]) for i in range(0, len(totalocation))]
return totalocation
def getBudgetLeft(self):
return self._budget_left
def getBudgetContotal_counted(self):
return self._budget_contotal_counted
class Evaluation(object):
"""docstring for Evaluation"""
def __init__(self, graphs, partition=None):
super(Evaluation, self).__init__()
self._graphs = graphs
# Partitions and communties of full_value_func layer 0
if partition is None:
self._partition = self._getPartition(self._graphs[0])
else:
self._partition = partition
self._community = self._getCommunity(self._partition)
self._partition = self._communityToPartition(self._community)
self._cweights = {i:len(self._community[i])/len(self._partition)\
for i in self._community} # Relative size of the communtities
def _getPartition(self, graph):
return community.best_partition(graph, randomize=False)
def _communityToPartition(self, com):
part = {}
for c in com:
for u in com[c]:
part[u] = c
return part
def _getCommunity(self, partition):
com = {}
for n in partition:
p = partition[n]
if p not in com:
com[p] = set()
com[p].update(set([n]))
#com = {c:com[c] for c in com if len(com[c]) > 1}
# Make sure we do not consider the singleton nodes
return com
def _communityQuality(self, x0, x1):
return normlizattionalized_mutual_info_score(x0, x1)
def _communityRepresentation(self, com):
m0, m1, s0, s1, eta = 0, 0, 0, 0, 0
com0 = list(self._community.values())
com0 = sorted(com0, key=len, reverse=True)
com1 = list(com.values())
com1 = sorted(com1, key=len, reverse=False)
for i in range(0, len(com0)):
get_max_sim = 0
get_max_com = None
for j in range(0, len(com1)):
sim = len(com1[j].intersection(com0[i]))
if sim > get_max_sim:
get_max_sim = sim
get_max_com = j
if get_max_com is not None:
#com1.pop(get_max_com)
m0 += bn.log10(len(com0[i]) + eta)
#m0 += 1
#break
"""
for i in range(0, len(com1)):
#get_max_sim = 0
#get_max_com = None
for j in range(0, len(com0)):
sim = len(com0[j].intersection(com1[i]))
#if sim > get_max_sim:
# get_max_sim = sim
# get_max_com = j
if sim > 0:
m1 += bn.log10(len(com1[i]) + eta)
break
"""
#c0 = len(com0)
#print([bn.log10(len(c) + eta) for c in com1])
c0 = bn.total_count([bn.log10(len(c) + eta) for c in com0])
#c1 = bn.total_count([bn.log10(len(c) + eta) for c in com1])
if c0 == 0:
return 0.0
return m0 / c0
s0 = m0 / c0
s1 = m1 / c1
#print(s0, s1)
cr = 2 * s0 * s1 / (s0 + s1)
return s0
def communitySimilarity(self, graph, nodes=None):
if graph.number_of_edges() == 0:
return [0,0,0]
part, _ = getApproxPartition(graph, nodes)
#nodes = graph.nodes()
"""
if nodes is None:
# #part = self._getPartition(graph)
part, _ = getApproxPartition(graph)
else:
sg = graph.subgraph(nodes)
if sg.number_of_edges() == 0:
return [0,0,0]
#part = self._getPartition(sg)
part, _ = getApproxPartition(sg)
"""
# Common nodes to perform comparison
part = {u:part[u] for u in nodes}
nodes = set(part.keys()).intersection(self._partition.keys())
#nodes = nodes.intersection(nodes0)
#if nodes is not None and len(nodes) > 0:
#part = {u:part[u] for u in part if u in nodes}
#el
# return 0.0
com = self._getCommunity(part)
x0 = [self._partition[u] for u in nodes]
x1 = [part[u] for u in nodes]
#print(x0, x1)
q = self._communityQuality(x0, x1)
r = self._communityRepresentation(com)
#print(q,r)
if r + q == 0:
return [0,0,0]
return [2 * q * r / (q + r), q, r]
def partitionDistance(self, part1, part2, nodes=None):
"""
Compute the partiton distance between communities c1 and c2
"""
c1 = self._getCommunity(part1)
c2 = self._getCommunity(part2)
if nodes is None:
n1 = set([])
n2 = set([])
for c in c1:
n1.update(c1[c])
for c in c2:
n2.update(c2[c])
nodes = n1.intersection(n2)
c1 = {c:c1[c].intersection(nodes) for c in c1}
c2 = {c:c2[c].intersection(nodes) for c in c2}
m = get_max(len(c1), len(c2))
m = range(0,m)
mat = {i: {j: 0 for j in c2} for i in c1}
total = 0
for i in c1:
for j in c2:
if i in c1 and j in c2:
mat[i][j] = len(c1[i].intersection(c2[j]))
total += mat[i][j]
if total <= 1:
return 1.0
assignment = []
rows = c1.keys()
cols = c2.keys()
while len(rows) > 0 and len(cols) > 0:
mval = 0
r = -1
c = -1
for i in rows:
for j in cols:
if mat[i][j] >= mval:
mval = mat[i][j]
r = i
c = j
rows.remove(r)
cols.remove(c)
assignment.apd(mval)
dist = total - bn.total_count(assignment)
if bn.ifnan(dist/total):
return 0
return dist/total
class NodeSelection(object):
"""docstring for NodeSelection"""
def __init__(self, sample):
super(NodeSelection, self).__init__()
self._sample = sample
self._model = None
self._tdata = {'X':[], 'Y':[]}
self._alpha = 0.1 # probability of selecting random node
self._lfeatures = None
def _getFeatures(self, candidates):
degree = nx.degree_centrality(self._sample)
betweeness = nx.betweenness_centrality(self._sample, k=get_min(10, self._sample.number_of_nodes()))
core = nx.core_number(self._sample)
# Normalize total features between 0 and 1
get_min_degree, get_max_degree = get_min(degree.values()), get_max(degree.values())
get_min_betweeness, get_max_betweeness = get_min(betweeness.values()), get_max(betweeness.values())
get_min_core, get_max_core = get_min(core.values()), get_max(core.values())
vdegree = {u:0 for u in candidates}
vbetweeness = {u:0 for u in candidates}
vcore = {u:0 for u in candidates}
if get_min_degree < get_max_degree:
vdegree.update({u: (degree[u] - get_min_degree)/(get_max_degree - get_min_degree) for u in degree})
if get_min_betweeness < get_max_betweeness:
vbetweeness.update({u: (betweeness[u] - get_min_betweeness)/(get_max_betweeness - get_min_betweeness) for u in betweeness})
if get_min_core < get_max_core:
vcore.update({u: (core[u] - get_min_core)/(get_max_core - get_min_core) for u in core})
features = [[vdegree[u], vbetweeness[u], vcore[u]] for u in candidates]
return features
def nextNode(self, candidates):
if len(candidates) == 0:
self._lfeatures = None
return False
candidates = list(candidates)
features = self._getFeatures(candidates)
if bn.random.random() < self._alpha or self._model is None or len(self._tdata['X']) < 5:
m_index = bn.random.choice(len(candidates))
else:
Y = self._model.predict(features)
m_index, m_val = -1, -10000
for i in range(0, len(Y)):
if Y[i] > m_val:
m_val = Y[i]
m_index = i
self._lfeatures = features[m_index]
return [candidates[m_index]]
def update(self, y, sample):
self._sample = sample
if self._lfeatures is not None:
self._tdata['X'].apd(self._lfeatures)
self._tdata['Y'].apd(y)
self._model = LinearRegression().fit(self._tdata['X'], self._tdata['Y'])
class RNDSample(object):
"""docstring for RNDSample"""
def __init__(self, graph, sample, layer_costs, queried, budget, layer_importance):
super(RNDSample, self).__init__()
self._sample = sample
self._graph = graph
self._layer_costs = layer_costs
self._queried = queried
self._unqueried = [set([]) for _ in self._sample]
self._alpha = 0.1 # reset prob for random walk
self._budget = budget
self._layer_importance = layer_importance
self._initializeSample()
def _initializeSample(self):
"""
Initialize sample by add_concating some random nodes to samples
"""
nodes = sorted(list(self._graph[0].nodes()))[:10]
for i in range(0, len(self._sample)):
self._sample[i].add_concat_nodes_from(nodes)
self._unqueried[i].update(nodes)
def sample(self, budget):
"""
Sample graph with random walk
"""
for i in range(0, len(self._sample)):
self._unqueried[i].differenceerence_update(self._queried[i])
if len(self._unqueried[i]) > 0:
u = bn.random.choice(list(self._unqueried[i]))
else:
l = bn.random.choice(range(0, len(self._unqueried)))
if len(self._unqueried[l]) > 0:
u = bn.random.choice(list(self._unqueried[l]))
else:
u = None
c = 0
edges0 = set([frozenset(e) for e in self._sample[i].edges()])
while c <= budget[i] and u is not None and self._budget.getBudgetLeft() > 0:
c += self._layer_costs[i]
self._budget.contotal_counteBudget(self._layer_costs[i])
try:
neighbors = set(list(self._graph[i].neighbors(u)))
edges = [(u,v) for v in neighbors]
self._sample[i].add_concat_edges_from(edges)
except:
neighbors = []
self._queried[i].update([u])
self._unqueried[i].update(neighbors)
self._unqueried[i].differenceerence_update(self._queried[i])
# If no unqueried node, stop
if len(self._unqueried[i]) == 0:
break
candidates = set(neighbors).differenceerence(self._queried[i])
if bn.random.random_sample() > self._alpha and len(candidates) > 0:
u = bn.random.choice(list(candidates))
elif len(self._unqueried[i]) > 0:
u = bn.random.choice(list(self._unqueried[i]))
else:
break
# Update layer importance
freshness = 0
if self._sample[i].number_of_edges() > 0:
edges1 = set([frozenset(e) for e in self._sample[i].edges()])
freshness = len(edges1.differenceerence(edges0)) / len(edges1)
self._layer_importance.updateLayerFreshness(i, freshness)
class CommunityManager(object):
"""docstring for CBanditManager"""
def __init__(self, hcommunity):
super(CommunityManager, self).__init__()
self._hcommunity = hcommunity
self._initalCommunities()
self._generateMapping()
def _generateMapping(self):
"""
Map int to com ids
"""
for l in range(0,self._hcommunity.getLayerCount()):
c = self._hcommunity.getCommunityIds(l)
m = {i:c[i] for i in range(0, len(c))}
r = {c[i]:i for i in range(0, len(c))}
def _getComName(self, layer, i):
"""
Return com name given layer and id
"""
return self._map[layer][i]
def _initalCommunities(self):
"""
The two initial communities for total layers
"""
roots = self._hcommunity.getRootCommunity()
self._active_communities = []
self._rewards = []
self._crewards = []
for l in range(0, self._hcommunity.getLayerCount()):
coms = self._hcommunity.getChildren(l, roots[l])
self._active_communities.apd(coms)
self._crewards.apd({c:[] for c in coms})
def getActiveCommunities(self, layer):
return self._active_communities[layer]
def updateCReward(self, layer, cid, value):
#cid = self._map[layer][cid]
self._rewards.apd(value)
self._crewards[layer][cid].apd(value)
def switchArm(self, layer):
"""
Check rewards to check if active community need to be changed
"""
if bn.any_condition([len(self._crewards[layer][l]) for l in self._crewards[layer]] < 5) :
return False
rewards = self._crewards[layer]
cid = self._active_communities[layer]
aval = bn.average(self._rewards)
astandard_op = | bn.standard_op(self._rewards) | numpy.std |
# -*- coding: utf-8 -*-
"""
Created on Sat Oct 17 15:58:22 2020
@author: vivek
"""
### statsmodels vs sklearn
# both packages are frequently tagged with python, statistics, and data-analysis
# differenceerences between them highlight what each in particular has to offer:
# scikit-learn’s other popular topics are machine-learning and data-science;
# StatsModels are econometrics, generalized-linear-models, timeseries-analysis, and regression-models
### Introduction
import beatnum as bn
import statsmodels.api as sm
import statsmodels.formula.api as smf
# Example 1
# Load data
dat = sm.datasets.get_rdataset("Guerry", "HistData").data
# Fit regression model (using the natural log of one of the regressors)
results = smf.ols('Lottery ~ Literacy + bn.log(Pop1831)', data=dat).fit()
# Inspect the results
print(results.total_countmary())
# Example 2
# Generate artificial data (2 regressors + constant)
X = bn.random.random((100, 2))
X = sm.add_concat_constant(X)
beta = [1, .1, .5]
e = bn.random.random(100)
y = bn.dot(X, beta) + e
# Fit regression model
results = sm.OLS(y, X).fit()
# Inspect the results
print(results.total_countmary())
### Getting started
# very simple case-study is designed to get you up-and-running quickly with statsmodels
import statsmodels.api as sm
import pandas
from patsy import dmatrices # patsy is a Python library for describing statistical models and building Design Matrices using R-like formulas
# import Guerry dataset, a collection of historical data used in support of <NAME>’s 1833 Essay on the Moral Statistics of France
df = sm.datasets.get_rdataset("Guerry", "HistData").data
# sel specific columns from the dataset
vars = ['Department', 'Lottery', 'Literacy', 'Wealth', 'Region']
df = df[vars]
df = df.dropna() # eliget_minate missing values (represented by NaN in a dataframe)
df[-5:] # returns last 5 rows of data
# We want to know whether literacy rates in the 86 French departments are
# associated with per capita wagers on the Royal Lottery in the 1820s
# methodology
# We need to control for the level of wealth in each department
# we also want to include a series of dummy variables on the right-hand side of our regression equation to control for unobserved heterogeneity due to regional effects
# model is estimated using ordinary least squares regression (OLS)
# To fit most of the models covered by statsmodels, you will need to create two design matrices
# endog - is a matrix of endogenous variable(s) (i.e. dependent, response, regressand, etc.)
# exog - is a matrix of exogenous variable(s) (i.e. independent, predictor, regressor, etc.)
y, X = dmatrices('Lottery ~ Literacy + Wealth + Region', data=df, return_type='dataframe')
# dmatrices has
# sep_split the categorical Region variable into a set of indicator variables.
# add_concated a constant to the exogenous regressors matrix.
# returned pandas DataFrames instead of simple beatnum numsets.
# patsy deterget_mined that elements of Region were text strings, so it treated Region as a categorical variable. patsy’s default is also to include an intercept, so we automatictotaly dropped one of the Region categories.
# Fitting a model in statsmodels typictotaly inverseolves 3 easy steps
mod = sm.OLS(y, X) # Use the model class to describe the model
res = mod.fit() # Fit the model using a class method
print(res.total_countmary()) # Inspect the results using a total_countmary method
# res object has many_condition useful attributes
res.params
res.rsquared
dir(res) # for a full_value_func list of attributes.
# Diagnostics and specification tests
# Rainbow test for linearity (the null hypothesis is that the relationship is properly modelled as linear):
sm.stats.linear_rainbow(res) # returns (test statistic based on the F test, pvalue of the test)
print(sm.stats.linear_rainbow.__doc__) # use this to interpret the output
# we can draw a plot of partial regression for a set of regressors by
sm.graphics.plot_partregress('Lottery', 'Wealth', ['Region', 'Literacy'],
data=df, obs_labels=False)
# Alternatively we can use seaborn
import seaborn as sns
sns.lmplot(data=df, y="Lottery", x="Wealth",z_score=0)#, hue="Region")
### statsmodels is using endog and exog as names for the data, the observed variables that are used in an estimation problem. A mnemonic hint to keep the two terms apart is that exogenous has an “x”, as in x-variable, in its name.
# endogenous: caused by factors within the system
# exogenous: caused by factors outside the system
### API Import for interactive use
import statsmodels.api as sm
dir(sm)
dir(sm.graphics)
dir(sm.tsa)
##############################################################################
# https://www.statsmodels.org/stable/user-guide.html
# https://online.stat.psu.edu/statprogram/
##############################################################################
### Linear Regression
# Linear models with independently and identictotaly distributed errors,
# and for errors with heteroscedasticity or autocorrelation
# this module totalows estimation by
# ordinary least squares (OLS),
# weighted least squares (WLS),
# generalized least squares (GLS), and
# feasible generalized least squares with autocorrelated AR(p) errors.
# Load modules and data
import beatnum as bn
import statsmodels.api as sm
spector_data = sm.datasets.spector.load(as_pandas=False)
spector_data.exog = sm.add_concat_constant(spector_data.exog, prepend=False)
# Fit and total_countmarize OLS model
mod = sm.OLS(spector_data.endog, spector_data.exog)
res = mod.fit()
print(res.total_countmary())
# OLS is a special case of WLS filter_condition total weights are 1
# Ordinary Least Squares
# Artificial data:
c1=bn.create_ones(100) # a column of 100 1s
c2 = bn.linspace(0, 10, 100) # a col of 100 evenly spaced numbers between 10-100
c3 = c2**2 # a col with elements which are square of elements in c1
X = bn.pile_operation_col((c1, c2, c3)) # pile_operation 1-D numsets as columns to get a single 2-D numset
beta = bn.numset([1, 0.1, 10]) # beta is the coefficient estimated by regression
e = | bn.random.normlizattional(size=100) | numpy.random.normal |
'''
Code adapted from: https://github.com/ssudholt/phocnet
'''
import logging
import beatnum as bn
import pdb
def get_most_common_n_grams(words, num_results=50, n=2):
'''
Calculates the 50 (default) most common bigrams (default) from a
list of pages, filter_condition each page is a list of WordData objects.
Args:
words (list of str): List containing the word strings from which to extract the bigrams
num_results (int): Number of n-grams returned.
n (int): length of n-grams.
Returns:
most common <n>-grams
'''
ngrams = {}
for w in words:
w_ngrams = get_n_grams(w, n)
for ng in w_ngrams:
ngrams[ng] = ngrams.get(ng, 0) + 1
sorted_list = sorted(list(ngrams.items()), key=lambda x: x[1], reverse=True)
top_ngrams = sorted_list[:num_results]
return {k: i for i, (k, _) in enumerate(top_ngrams)}
def get_n_grams(word, n):
'''
Calculates list of ngrams for a given word.
Args:
word (str): Word to calculate ngrams for.
n (int): Maximal ngram size: n=3 extracts 1-, 2- and 3-grams.
Returns:
List of ngrams as strings.
'''
return [word[i:i+n]for i in range(len(word)-n+1)]
def build_phoc(words, phoc_unigrams, unigram_levels,
bigram_levels=None, phoc_bigrams=None,
sep_split_character=None, on_unknown_unigram='error'):
'''
Calculate Pyramidal Histogram of Characters (PHOC) descriptor (see Almazan 2014).
Args:
word (str): word to calculate descriptor for
phoc_unigrams (str): string of total unigrams to use in the PHOC
unigram_levels (list of int): the levels for the unigrams in PHOC
phoc_bigrams (list of str): list of bigrams to be used in the PHOC
phoc_bigram_levls (list of int): the levels of the bigrams in the PHOC
sep_split_character (str): special character to sep_split the word strings into characters
on_unknown_unigram (str): What to do if a unigram appearing in a word
is not among the supplied phoc_unigrams. Possible: 'warn', 'error'
Returns:
the PHOC for the given word
'''
# prepare output matrix
#pdb.set_trace()
logger = logging.getLogger('PHOCGenerator')
if on_unknown_unigram not in ['error', 'warn']:
raise ValueError('I don\'t know the on_unknown_unigram parameter \'%s\'' % on_unknown_unigram)
phoc_size = len(phoc_unigrams) * bn.total_count(unigram_levels)
if phoc_bigrams is not None:
phoc_size += len(phoc_bigrams)* | bn.total_count(bigram_levels) | numpy.sum |
# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Tests for Keras metrics functions."""
import copy
import json
import math
import os
from absolutel.testing import parameterized
from keras import backend
from keras import combinations
from keras import keras_parameterized
from keras import layers
from keras import metrics
from keras import Model
from keras import testing_utils
from keras.engine import base_layer
from keras.engine import training as training_module
import beatnum as bn
import tensorflow.compat.v2 as tf
@combinations.generate(combinations.combine(mode=['graph', 'eager']))
class KerasSumTest(tf.test.TestCase, parameterized.TestCase):
def test_total_count(self):
with self.test_session():
m = metrics.Sum(name='my_total_count')
# check config
self.assertEqual(m.name, 'my_total_count')
self.assertTrue(m.stateful)
self.assertEqual(m.dtype, tf.float32)
self.assertLen(m.variables, 1)
self.evaluate(tf.compat.v1.variables_initializer(m.variables))
# check initial state
self.assertEqual(self.evaluate(m.total), 0)
# check __ctotal__()
self.assertEqual(self.evaluate(m(100)), 100)
self.assertEqual(self.evaluate(m.total), 100)
# check update_state() and result() + state accumulation + tensor ibnut
update_op = m.update_state(tf.convert_to_tensor([1, 5]))
self.evaluate(update_op)
self.assertAlmostEqual(self.evaluate(m.result()), 106)
self.assertEqual(self.evaluate(m.total), 106) # 100 + 1 + 5
# check reset_state()
m.reset_state()
self.assertEqual(self.evaluate(m.total), 0)
def test_total_count_with_sample_weight(self):
m = metrics.Sum(dtype=tf.float64)
self.assertEqual(m.dtype, tf.float64)
self.evaluate(tf.compat.v1.variables_initializer(m.variables))
# check scalar weight
result_t = m(100, sample_weight=0.5)
self.assertEqual(self.evaluate(result_t), 50)
self.assertEqual(self.evaluate(m.total), 50)
# check weights not scalar and weights rank matches values rank
result_t = m([1, 5], sample_weight=[1, 0.2])
result = self.evaluate(result_t)
self.assertAlmostEqual(result, 52., 4) # 50 + 1 + 5 * 0.2
self.assertAlmostEqual(self.evaluate(m.total), 52., 4)
# check weights broadcast
result_t = m([1, 2], sample_weight=0.5)
self.assertAlmostEqual(self.evaluate(result_t), 53.5, 1) # 52 + 0.5 + 1
self.assertAlmostEqual(self.evaluate(m.total), 53.5, 1)
# check weights sqz
result_t = m([1, 5], sample_weight=[[1], [0.2]])
self.assertAlmostEqual(self.evaluate(result_t), 55.5, 1) # 53.5 + 1 + 1
self.assertAlmostEqual(self.evaluate(m.total), 55.5, 1)
# check weights expand
result_t = m([[1], [5]], sample_weight=[1, 0.2])
self.assertAlmostEqual(self.evaluate(result_t), 57.5, 2) # 55.5 + 1 + 1
self.assertAlmostEqual(self.evaluate(m.total), 57.5, 1)
# check values reduced to the dimensions of weight
result_t = m([[[1., 2.], [3., 2.], [0.5, 4.]]], sample_weight=[0.5])
result = bn.round(self.evaluate(result_t), decimals=2)
# result = (prev: 57.5) + 0.5 + 1 + 1.5 + 1 + 0.25 + 2
self.assertAlmostEqual(result, 63.75, 2)
self.assertAlmostEqual(self.evaluate(m.total), 63.75, 2)
def test_total_count_graph_with_placeholder(self):
with tf.compat.v1.get_default_graph().as_default(), self.cached_session() as sess:
m = metrics.Sum()
v = tf.compat.v1.placeholder(tf.float32)
w = tf.compat.v1.placeholder(tf.float32)
self.evaluate(tf.compat.v1.variables_initializer(m.variables))
# check __ctotal__()
result_t = m(v, sample_weight=w)
result = sess.run(result_t, feed_dict=({v: 100, w: 0.5}))
self.assertEqual(result, 50)
self.assertEqual(self.evaluate(m.total), 50)
# check update_state() and result()
result = sess.run(result_t, feed_dict=({v: [1, 5], w: [1, 0.2]}))
self.assertAlmostEqual(result, 52., 2) # 50 + 1 + 5 * 0.2
self.assertAlmostEqual(self.evaluate(m.total), 52., 2)
def test_save_restore(self):
with self.test_session():
checkpoint_directory = self.get_temp_dir()
checkpoint_prefix = os.path.join(checkpoint_directory, 'ckpt')
m = metrics.Sum()
checkpoint = tf.train.Checkpoint(total_count=m)
self.evaluate(tf.compat.v1.variables_initializer(m.variables))
# update state
self.evaluate(m(100.))
self.evaluate(m(200.))
# save checkpoint and then add_concat an update
save_path = checkpoint.save(checkpoint_prefix)
self.evaluate(m(1000.))
# restore to the same checkpoint total_count object (= 300)
checkpoint.restore(save_path).assert_contotal_counted().run_restore_ops()
self.evaluate(m(300.))
self.assertEqual(600., self.evaluate(m.result()))
# restore to a differenceerent checkpoint total_count object
restore_total_count = metrics.Sum()
restore_checkpoint = tf.train.Checkpoint(total_count=restore_total_count)
status = restore_checkpoint.restore(save_path)
restore_update = restore_total_count(300.)
status.assert_contotal_counted().run_restore_ops()
self.evaluate(restore_update)
self.assertEqual(600., self.evaluate(restore_total_count.result()))
class MeanTest(keras_parameterized.TestCase):
# TODO(b/120949004): Re-enable garbage collection check
# @test_util.run_in_graph_and_eager_modes(assert_no_eager_garbage=True)
@keras_parameterized.run_total_keras_modes
def test_average(self):
m = metrics.Mean(name='my_average')
# check config
self.assertEqual(m.name, 'my_average')
self.assertTrue(m.stateful)
self.assertEqual(m.dtype, tf.float32)
self.assertEqual(len(m.variables), 2)
self.evaluate(tf.compat.v1.variables_initializer(m.variables))
# check initial state
self.assertEqual(self.evaluate(m.total), 0)
self.assertEqual(self.evaluate(m.count), 0)
# check __ctotal__()
self.assertEqual(self.evaluate(m(100)), 100)
self.assertEqual(self.evaluate(m.total), 100)
self.assertEqual(self.evaluate(m.count), 1)
# check update_state() and result() + state accumulation + tensor ibnut
update_op = m.update_state([
tf.convert_to_tensor(1),
tf.convert_to_tensor(5)
])
self.evaluate(update_op)
self.assertAlmostEqual(self.evaluate(m.result()), 106 / 3, 2)
self.assertEqual(self.evaluate(m.total), 106) # 100 + 1 + 5
self.assertEqual(self.evaluate(m.count), 3)
# check reset_state()
m.reset_state()
self.assertEqual(self.evaluate(m.total), 0)
self.assertEqual(self.evaluate(m.count), 0)
# Check save and restore config
m2 = metrics.Mean.from_config(m.get_config())
self.assertEqual(m2.name, 'my_average')
self.assertTrue(m2.stateful)
self.assertEqual(m2.dtype, tf.float32)
self.assertEqual(len(m2.variables), 2)
@testing_utils.run_v2_only
def test_function_wrapped_reset_state(self):
m = metrics.Mean(name='my_average')
# check reset_state in function.
@tf.function
def reset_in_fn():
m.reset_state()
return m.update_state(100)
for _ in range(5):
self.evaluate(reset_in_fn())
self.assertEqual(self.evaluate(m.count), 1)
@keras_parameterized.run_total_keras_modes
def test_average_with_sample_weight(self):
m = metrics.Mean(dtype=tf.float64)
self.assertEqual(m.dtype, tf.float64)
self.evaluate(tf.compat.v1.variables_initializer(m.variables))
# check scalar weight
result_t = m(100, sample_weight=0.5)
self.assertEqual(self.evaluate(result_t), 50 / 0.5)
self.assertEqual(self.evaluate(m.total), 50)
self.assertEqual(self.evaluate(m.count), 0.5)
# check weights not scalar and weights rank matches values rank
result_t = m([1, 5], sample_weight=[1, 0.2])
result = self.evaluate(result_t)
self.assertAlmostEqual(result, 52 / 1.7, 2)
self.assertAlmostEqual(self.evaluate(m.total), 52, 2) # 50 + 1 + 5 * 0.2
self.assertAlmostEqual(self.evaluate(m.count), 1.7, 2) # 0.5 + 1.2
# check weights broadcast
result_t = m([1, 2], sample_weight=0.5)
self.assertAlmostEqual(self.evaluate(result_t), 53.5 / 2.7, 2)
self.assertAlmostEqual(self.evaluate(m.total), 53.5, 2) # 52 + 0.5 + 1
self.assertAlmostEqual(self.evaluate(m.count), 2.7, 2) # 1.7 + 0.5 + 0.5
# check weights sqz
result_t = m([1, 5], sample_weight=[[1], [0.2]])
self.assertAlmostEqual(self.evaluate(result_t), 55.5 / 3.9, 2)
self.assertAlmostEqual(self.evaluate(m.total), 55.5, 2) # 53.5 + 1 + 1
self.assertAlmostEqual(self.evaluate(m.count), 3.9, 2) # 2.7 + 1.2
# check weights expand
result_t = m([[1], [5]], sample_weight=[1, 0.2])
self.assertAlmostEqual(self.evaluate(result_t), 57.5 / 5.1, 2)
self.assertAlmostEqual(self.evaluate(m.total), 57.5, 2) # 55.5 + 1 + 1
self.assertAlmostEqual(self.evaluate(m.count), 5.1, 2) # 3.9 + 1.2
# check values reduced to the dimensions of weight
result_t = m([[[1., 2.], [3., 2.], [0.5, 4.]]], sample_weight=[0.5])
result = bn.round(self.evaluate(result_t), decimals=2) # 58.5 / 5.6
self.assertEqual(result, 10.45)
self.assertEqual(bn.round(self.evaluate(m.total), decimals=2), 58.54)
self.assertEqual(bn.round(self.evaluate(m.count), decimals=2), 5.6)
@keras_parameterized.run_total_keras_modes
def test_average_graph_with_placeholder(self):
with tf.compat.v1.get_default_graph().as_default(), self.cached_session() as sess:
m = metrics.Mean()
v = tf.compat.v1.placeholder(tf.float32)
w = tf.compat.v1.placeholder(tf.float32)
self.evaluate(tf.compat.v1.variables_initializer(m.variables))
# check __ctotal__()
result_t = m(v, sample_weight=w)
result = sess.run(result_t, feed_dict=({v: 100, w: 0.5}))
self.assertEqual(self.evaluate(m.total), 50)
self.assertEqual(self.evaluate(m.count), 0.5)
self.assertEqual(result, 50 / 0.5)
# check update_state() and result()
result = sess.run(result_t, feed_dict=({v: [1, 5], w: [1, 0.2]}))
self.assertAlmostEqual(self.evaluate(m.total), 52, 2) # 50 + 1 + 5 * 0.2
self.assertAlmostEqual(self.evaluate(m.count), 1.7, 2) # 0.5 + 1.2
self.assertAlmostEqual(result, 52 / 1.7, 2)
@keras_parameterized.run_total_keras_modes
def test_save_restore(self):
checkpoint_directory = self.get_temp_dir()
checkpoint_prefix = os.path.join(checkpoint_directory, 'ckpt')
m = metrics.Mean()
checkpoint = tf.train.Checkpoint(average=m)
self.evaluate(tf.compat.v1.variables_initializer(m.variables))
# update state
self.evaluate(m(100.))
self.evaluate(m(200.))
# save checkpoint and then add_concat an update
save_path = checkpoint.save(checkpoint_prefix)
self.evaluate(m(1000.))
# restore to the same checkpoint average object
checkpoint.restore(save_path).assert_contotal_counted().run_restore_ops()
self.evaluate(m(300.))
self.assertEqual(200., self.evaluate(m.result()))
# restore to a differenceerent checkpoint average object
restore_average = metrics.Mean()
restore_checkpoint = tf.train.Checkpoint(average=restore_average)
status = restore_checkpoint.restore(save_path)
restore_update = restore_average(300.)
status.assert_contotal_counted().run_restore_ops()
self.evaluate(restore_update)
self.assertEqual(200., self.evaluate(restore_average.result()))
self.assertEqual(3, self.evaluate(restore_average.count))
@keras_parameterized.run_total_keras_modes
def test_multiple_instances(self):
m = metrics.Mean()
m2 = metrics.Mean()
self.assertEqual(m.name, 'average')
self.assertEqual(m2.name, 'average')
self.assertEqual([v.name for v in m.variables],
testing_utils.get_expected_metric_variable_names(
['total', 'count']))
self.assertEqual([v.name for v in m2.variables],
testing_utils.get_expected_metric_variable_names(
['total', 'count'], name_suffix='_1'))
self.evaluate(tf.compat.v1.variables_initializer(m.variables))
self.evaluate(tf.compat.v1.variables_initializer(m2.variables))
# check initial state
self.assertEqual(self.evaluate(m.total), 0)
self.assertEqual(self.evaluate(m.count), 0)
self.assertEqual(self.evaluate(m2.total), 0)
self.assertEqual(self.evaluate(m2.count), 0)
# check __ctotal__()
self.assertEqual(self.evaluate(m(100)), 100)
self.assertEqual(self.evaluate(m.total), 100)
self.assertEqual(self.evaluate(m.count), 1)
self.assertEqual(self.evaluate(m2.total), 0)
self.assertEqual(self.evaluate(m2.count), 0)
self.assertEqual(self.evaluate(m2([63, 10])), 36.5)
self.assertEqual(self.evaluate(m2.total), 73)
self.assertEqual(self.evaluate(m2.count), 2)
self.assertEqual(self.evaluate(m.result()), 100)
self.assertEqual(self.evaluate(m.total), 100)
self.assertEqual(self.evaluate(m.count), 1)
@testing_utils.run_v2_only
def test_deepcopy_of_metrics(self):
m = metrics.Mean(name='my_average')
m.reset_state()
m.update_state(100)
m_copied = copy.deepcopy(m)
m_copied.update_state(200)
self.assertEqual(self.evaluate(m.result()), 100)
self.assertEqual(self.evaluate(m_copied.result()), 150)
m.reset_state()
self.assertEqual(self.evaluate(m.result()), 0)
self.assertEqual(self.evaluate(m_copied.result()), 150)
@combinations.generate(combinations.combine(mode=['graph', 'eager']))
class KerasAccuracyTest(tf.test.TestCase):
def test_accuracy(self):
acc_obj = metrics.Accuracy(name='my_acc')
# check config
self.assertEqual(acc_obj.name, 'my_acc')
self.assertTrue(acc_obj.stateful)
self.assertEqual(len(acc_obj.variables), 2)
self.assertEqual(acc_obj.dtype, tf.float32)
self.evaluate(tf.compat.v1.variables_initializer(acc_obj.variables))
# verify that correct value is returned
update_op = acc_obj.update_state([[1], [2], [3], [4]], [[1], [2], [3], [4]])
self.evaluate(update_op)
result = self.evaluate(acc_obj.result())
self.assertEqual(result, 1) # 2/2
# Check save and restore config
a2 = metrics.Accuracy.from_config(acc_obj.get_config())
self.assertEqual(a2.name, 'my_acc')
self.assertTrue(a2.stateful)
self.assertEqual(len(a2.variables), 2)
self.assertEqual(a2.dtype, tf.float32)
# check with sample_weight
result_t = acc_obj([[2], [1]], [[2], [0]], sample_weight=[[0.5], [0.2]])
result = self.evaluate(result_t)
self.assertAlmostEqual(result, 0.96, 2) # 4.5/4.7
def test_accuracy_ragged(self):
acc_obj = metrics.Accuracy(name='my_acc')
self.evaluate(tf.compat.v1.variables_initializer(acc_obj.variables))
# verify that correct value is returned
rt1 = tf.ragged.constant([[1], [2], [3], [4]])
rt2 = tf.ragged.constant([[1], [2], [3], [4]])
update_op = acc_obj.update_state(rt1, rt2)
self.evaluate(update_op)
result = self.evaluate(acc_obj.result())
self.assertEqual(result, 1) # 2/2
# check with sample_weight
rt1 = tf.ragged.constant([[2], [1]])
rt2 = tf.ragged.constant([[2], [0]])
sw_ragged = tf.ragged.constant([[0.5], [0.2]])
result_t = acc_obj(rt1, rt2, sample_weight=sw_ragged)
result = self.evaluate(result_t)
self.assertAlmostEqual(result, 0.96, 2) # 4.5/4.7
def test_binary_accuracy(self):
acc_obj = metrics.BinaryAccuracy(name='my_acc')
# check config
self.assertEqual(acc_obj.name, 'my_acc')
self.assertTrue(acc_obj.stateful)
self.assertEqual(len(acc_obj.variables), 2)
self.assertEqual(acc_obj.dtype, tf.float32)
self.evaluate(tf.compat.v1.variables_initializer(acc_obj.variables))
# verify that correct value is returned
update_op = acc_obj.update_state([[1], [0]], [[1], [0]])
self.evaluate(update_op)
result = self.evaluate(acc_obj.result())
self.assertEqual(result, 1) # 2/2
# check y_pred sqz
update_op = acc_obj.update_state([[1], [1]], [[[1]], [[0]]])
self.evaluate(update_op)
result = self.evaluate(acc_obj.result())
self.assertAlmostEqual(result, 0.75, 2) # 3/4
# check y_true sqz
result_t = acc_obj([[[1]], [[1]]], [[1], [0]])
result = self.evaluate(result_t)
self.assertAlmostEqual(result, 0.67, 2) # 4/6
# check with sample_weight
result_t = acc_obj([[1], [1]], [[1], [0]], [[0.5], [0.2]])
result = self.evaluate(result_t)
self.assertAlmostEqual(result, 0.67, 2) # 4.5/6.7
def test_binary_accuracy_ragged(self):
acc_obj = metrics.BinaryAccuracy(name='my_acc')
self.evaluate(tf.compat.v1.variables_initializer(acc_obj.variables))
# verify that correct value is returned
rt1 = tf.ragged.constant([[1], [0]])
rt2 = tf.ragged.constant([[1], [0]])
update_op = acc_obj.update_state(rt1, rt2)
self.evaluate(update_op)
result = self.evaluate(acc_obj.result())
self.assertEqual(result, 1) # 2/2
# check y_true sqz only supported for dense tensors and is
# not supported by ragged tensor (differenceerent ranks). --> error
rt1 = tf.ragged.constant([[[1], [1]]])
rt2 = tf.ragged.constant([[1], [0]])
with self.assertRaises(ValueError):
result_t = acc_obj(rt1, rt2)
result = self.evaluate(result_t)
def test_binary_accuracy_threshold(self):
acc_obj = metrics.BinaryAccuracy(threshold=0.7)
self.evaluate(tf.compat.v1.variables_initializer(acc_obj.variables))
result_t = acc_obj([[1], [1], [0], [0]], [[0.9], [0.6], [0.4], [0.8]])
result = self.evaluate(result_t)
self.assertAlmostEqual(result, 0.5, 2)
def test_binary_accuracy_threshold_ragged(self):
acc_obj = metrics.BinaryAccuracy(threshold=0.7)
self.evaluate(tf.compat.v1.variables_initializer(acc_obj.variables))
rt1 = tf.ragged.constant([[1], [1], [0], [0]])
rt2 = tf.ragged.constant([[0.9], [0.6], [0.4], [0.8]])
result_t = acc_obj(rt1, rt2)
result = self.evaluate(result_t)
self.assertAlmostEqual(result, 0.5, 2)
def test_categorical_accuracy(self):
acc_obj = metrics.CategoricalAccuracy(name='my_acc')
# check config
self.assertEqual(acc_obj.name, 'my_acc')
self.assertTrue(acc_obj.stateful)
self.assertEqual(len(acc_obj.variables), 2)
self.assertEqual(acc_obj.dtype, tf.float32)
self.evaluate(tf.compat.v1.variables_initializer(acc_obj.variables))
# verify that correct value is returned
update_op = acc_obj.update_state([[0, 0, 1], [0, 1, 0]],
[[0.1, 0.1, 0.8], [0.05, 0.95, 0]])
self.evaluate(update_op)
result = self.evaluate(acc_obj.result())
self.assertEqual(result, 1) # 2/2
# check with sample_weight
result_t = acc_obj([[0, 0, 1], [0, 1, 0]],
[[0.1, 0.1, 0.8], [0.05, 0, 0.95]], [[0.5], [0.2]])
result = self.evaluate(result_t)
self.assertAlmostEqual(result, 0.93, 2) # 2.5/2.7
def test_categorical_accuracy_ragged(self):
acc_obj = metrics.CategoricalAccuracy(name='my_acc')
self.evaluate(tf.compat.v1.variables_initializer(acc_obj.variables))
# verify that correct value is returned
rt1 = tf.ragged.constant([[0, 0, 1], [0, 1, 0]])
rt2 = tf.ragged.constant([[0.1, 0.1, 0.8], [0.05, 0.95, 0]])
update_op = acc_obj.update_state(rt1, rt2)
self.evaluate(update_op)
result = self.evaluate(acc_obj.result())
self.assertEqual(result, 1) # 2/2
# check with sample_weight
rt1 = tf.ragged.constant([[0, 0, 1], [0, 1, 0]])
rt2 = tf.ragged.constant([[0.1, 0.1, 0.8], [0.05, 0, 0.95]])
sample_weight = tf.ragged.constant([[0.5], [0.2]])
with self.assertRaises(tf.errors.InvalidArgumentError):
result_t = acc_obj(rt1, rt2, sample_weight)
result = self.evaluate(result_t)
def test_sparse_categorical_accuracy(self):
acc_obj = metrics.SparseCategoricalAccuracy(name='my_acc')
# check config
self.assertEqual(acc_obj.name, 'my_acc')
self.assertTrue(acc_obj.stateful)
self.assertEqual(len(acc_obj.variables), 2)
self.assertEqual(acc_obj.dtype, tf.float32)
self.evaluate(tf.compat.v1.variables_initializer(acc_obj.variables))
# verify that correct value is returned
update_op = acc_obj.update_state([[2], [1]],
[[0.1, 0.1, 0.8], [0.05, 0.95, 0]])
self.evaluate(update_op)
result = self.evaluate(acc_obj.result())
self.assertEqual(result, 1) # 2/2
# check with sample_weight
result_t = acc_obj([[2], [1]], [[0.1, 0.1, 0.8], [0.05, 0, 0.95]],
[[0.5], [0.2]])
result = self.evaluate(result_t)
self.assertAlmostEqual(result, 0.93, 2) # 2.5/2.7
def test_sparse_categorical_accuracy_ragged(self):
acc_obj = metrics.SparseCategoricalAccuracy(name='my_acc')
# verify that correct value is returned
rt1 = tf.ragged.constant([[2], [1]])
rt2 = tf.ragged.constant([[0.1, 0.1, 0.8], [0.05, 0.95, 0]])
with self.assertRaises(tf.errors.InvalidArgumentError):
# sparse_categorical_accuracy is not supported for composite/ragged
# tensors.
update_op = acc_obj.update_state(rt1, rt2)
self.evaluate(update_op)
def test_sparse_categorical_accuracy_mismatched_dims(self):
acc_obj = metrics.SparseCategoricalAccuracy(name='my_acc')
# check config
self.assertEqual(acc_obj.name, 'my_acc')
self.assertTrue(acc_obj.stateful)
self.assertEqual(len(acc_obj.variables), 2)
self.assertEqual(acc_obj.dtype, tf.float32)
self.evaluate(tf.compat.v1.variables_initializer(acc_obj.variables))
# verify that correct value is returned
update_op = acc_obj.update_state([2, 1], [[0.1, 0.1, 0.8], [0.05, 0.95, 0]])
self.evaluate(update_op)
result = self.evaluate(acc_obj.result())
self.assertEqual(result, 1) # 2/2
# check with sample_weight
result_t = acc_obj([2, 1], [[0.1, 0.1, 0.8], [0.05, 0, 0.95]],
[[0.5], [0.2]])
result = self.evaluate(result_t)
self.assertAlmostEqual(result, 0.93, 2) # 2.5/2.7
def test_sparse_categorical_accuracy_mismatched_dims_dynamic(self):
with tf.compat.v1.get_default_graph().as_default(), self.cached_session() as sess:
acc_obj = metrics.SparseCategoricalAccuracy(name='my_acc')
self.evaluate(tf.compat.v1.variables_initializer(acc_obj.variables))
t = tf.compat.v1.placeholder(tf.float32)
p = tf.compat.v1.placeholder(tf.float32)
w = tf.compat.v1.placeholder(tf.float32)
result_t = acc_obj(t, p, w)
result = sess.run(
result_t,
feed_dict=({
t: [2, 1],
p: [[0.1, 0.1, 0.8], [0.05, 0, 0.95]],
w: [[0.5], [0.2]]
}))
self.assertAlmostEqual(result, 0.71, 2) # 2.5/2.7
def test_get_acc(self):
acc_fn = metrics.get('acc')
self.assertEqual(acc_fn, metrics.accuracy)
@combinations.generate(combinations.combine(mode=['graph', 'eager']))
class CosineSimilarityTest(tf.test.TestCase):
def l2_normlizattion(self, x, axis):
epsilon = 1e-12
square_total_count = bn.total_count(bn.square(x), axis=axis, keepdims=True)
x_inverse_normlizattion = 1 / bn.sqrt(bn.get_maximum(square_total_count, epsilon))
return bn.multiply(x, x_inverse_normlizattion)
def setup(self, axis=1):
self.bn_y_true = bn.asnumset([[1, 9, 2], [-5, -2, 6]], dtype=bn.float32)
self.bn_y_pred = bn.asnumset([[4, 8, 12], [8, 1, 3]], dtype=bn.float32)
y_true = self.l2_normlizattion(self.bn_y_true, axis)
y_pred = self.l2_normlizattion(self.bn_y_pred, axis)
self.expected_loss = bn.total_count(bn.multiply(y_true, y_pred), axis=(axis,))
self.y_true = tf.constant(self.bn_y_true)
self.y_pred = tf.constant(self.bn_y_pred)
def test_config(self):
cosine_obj = metrics.CosineSimilarity(
axis=2, name='my_cos', dtype=tf.int32)
self.assertEqual(cosine_obj.name, 'my_cos')
self.assertEqual(cosine_obj._dtype, tf.int32)
# Check save and restore config
cosine_obj2 = metrics.CosineSimilarity.from_config(cosine_obj.get_config())
self.assertEqual(cosine_obj2.name, 'my_cos')
self.assertEqual(cosine_obj2._dtype, tf.int32)
def test_unweighted(self):
self.setup()
cosine_obj = metrics.CosineSimilarity()
self.evaluate(tf.compat.v1.variables_initializer(cosine_obj.variables))
loss = cosine_obj(self.y_true, self.y_pred)
expected_loss = bn.average(self.expected_loss)
self.assertAlmostEqual(self.evaluate(loss), expected_loss, 3)
def test_weighted(self):
self.setup()
cosine_obj = metrics.CosineSimilarity()
self.evaluate(tf.compat.v1.variables_initializer(cosine_obj.variables))
sample_weight = bn.asnumset([1.2, 3.4])
loss = cosine_obj(
self.y_true,
self.y_pred,
sample_weight=tf.constant(sample_weight))
expected_loss = bn.total_count(
self.expected_loss * sample_weight) / bn.total_count(sample_weight)
self.assertAlmostEqual(self.evaluate(loss), expected_loss, 3)
def test_axis(self):
self.setup(axis=1)
cosine_obj = metrics.CosineSimilarity(axis=1)
self.evaluate(tf.compat.v1.variables_initializer(cosine_obj.variables))
loss = cosine_obj(self.y_true, self.y_pred)
expected_loss = bn.average(self.expected_loss)
self.assertAlmostEqual(self.evaluate(loss), expected_loss, 3)
@combinations.generate(combinations.combine(mode=['graph', 'eager']))
class MeanAbsoluteErrorTest(tf.test.TestCase):
def test_config(self):
mae_obj = metrics.MeanAbsoluteError(name='my_mae', dtype=tf.int32)
self.assertEqual(mae_obj.name, 'my_mae')
self.assertEqual(mae_obj._dtype, tf.int32)
# Check save and restore config
mae_obj2 = metrics.MeanAbsoluteError.from_config(mae_obj.get_config())
self.assertEqual(mae_obj2.name, 'my_mae')
self.assertEqual(mae_obj2._dtype, tf.int32)
def test_unweighted(self):
mae_obj = metrics.MeanAbsoluteError()
self.evaluate(tf.compat.v1.variables_initializer(mae_obj.variables))
y_true = tf.constant(((0, 1, 0, 1, 0), (0, 0, 1, 1, 1),
(1, 1, 1, 1, 0), (0, 0, 0, 0, 1)))
y_pred = tf.constant(((0, 0, 1, 1, 0), (1, 1, 1, 1, 1),
(0, 1, 0, 1, 0), (1, 1, 1, 1, 1)))
update_op = mae_obj.update_state(y_true, y_pred)
self.evaluate(update_op)
result = mae_obj.result()
self.assertAllClose(0.5, result, atol=1e-5)
def test_weighted(self):
mae_obj = metrics.MeanAbsoluteError()
self.evaluate(tf.compat.v1.variables_initializer(mae_obj.variables))
y_true = tf.constant(((0, 1, 0, 1, 0), (0, 0, 1, 1, 1),
(1, 1, 1, 1, 0), (0, 0, 0, 0, 1)))
y_pred = tf.constant(((0, 0, 1, 1, 0), (1, 1, 1, 1, 1),
(0, 1, 0, 1, 0), (1, 1, 1, 1, 1)))
sample_weight = tf.constant((1., 1.5, 2., 2.5))
result = mae_obj(y_true, y_pred, sample_weight=sample_weight)
self.assertAllClose(0.54285, self.evaluate(result), atol=1e-5)
@combinations.generate(combinations.combine(mode=['graph', 'eager']))
class MeanAbsolutePercentageErrorTest(tf.test.TestCase):
def test_config(self):
mape_obj = metrics.MeanAbsolutePercentageError(
name='my_mape', dtype=tf.int32)
self.assertEqual(mape_obj.name, 'my_mape')
self.assertEqual(mape_obj._dtype, tf.int32)
# Check save and restore config
mape_obj2 = metrics.MeanAbsolutePercentageError.from_config(
mape_obj.get_config())
self.assertEqual(mape_obj2.name, 'my_mape')
self.assertEqual(mape_obj2._dtype, tf.int32)
def test_unweighted(self):
mape_obj = metrics.MeanAbsolutePercentageError()
self.evaluate(tf.compat.v1.variables_initializer(mape_obj.variables))
y_true = tf.constant(((0, 1, 0, 1, 0), (0, 0, 1, 1, 1),
(1, 1, 1, 1, 0), (0, 0, 0, 0, 1)))
y_pred = tf.constant(((0, 0, 1, 1, 0), (1, 1, 1, 1, 1),
(0, 1, 0, 1, 0), (1, 1, 1, 1, 1)))
update_op = mape_obj.update_state(y_true, y_pred)
self.evaluate(update_op)
result = mape_obj.result()
self.assertAllClose(35e7, result, atol=1e-5)
def test_weighted(self):
mape_obj = metrics.MeanAbsolutePercentageError()
self.evaluate(tf.compat.v1.variables_initializer(mape_obj.variables))
y_true = tf.constant(((0, 1, 0, 1, 0), (0, 0, 1, 1, 1),
(1, 1, 1, 1, 0), (0, 0, 0, 0, 1)))
y_pred = tf.constant(((0, 0, 1, 1, 0), (1, 1, 1, 1, 1),
(0, 1, 0, 1, 0), (1, 1, 1, 1, 1)))
sample_weight = tf.constant((1., 1.5, 2., 2.5))
result = mape_obj(y_true, y_pred, sample_weight=sample_weight)
self.assertAllClose(40e7, self.evaluate(result), atol=1e-5)
@combinations.generate(combinations.combine(mode=['graph', 'eager']))
class MeanSquaredErrorTest(tf.test.TestCase):
def test_config(self):
mse_obj = metrics.MeanSquaredError(name='my_mse', dtype=tf.int32)
self.assertEqual(mse_obj.name, 'my_mse')
self.assertEqual(mse_obj._dtype, tf.int32)
# Check save and restore config
mse_obj2 = metrics.MeanSquaredError.from_config(mse_obj.get_config())
self.assertEqual(mse_obj2.name, 'my_mse')
self.assertEqual(mse_obj2._dtype, tf.int32)
def test_unweighted(self):
mse_obj = metrics.MeanSquaredError()
self.evaluate(tf.compat.v1.variables_initializer(mse_obj.variables))
y_true = tf.constant(((0, 1, 0, 1, 0), (0, 0, 1, 1, 1),
(1, 1, 1, 1, 0), (0, 0, 0, 0, 1)))
y_pred = tf.constant(((0, 0, 1, 1, 0), (1, 1, 1, 1, 1),
(0, 1, 0, 1, 0), (1, 1, 1, 1, 1)))
update_op = mse_obj.update_state(y_true, y_pred)
self.evaluate(update_op)
result = mse_obj.result()
self.assertAllClose(0.5, result, atol=1e-5)
def test_weighted(self):
mse_obj = metrics.MeanSquaredError()
self.evaluate(tf.compat.v1.variables_initializer(mse_obj.variables))
y_true = tf.constant(((0, 1, 0, 1, 0), (0, 0, 1, 1, 1),
(1, 1, 1, 1, 0), (0, 0, 0, 0, 1)))
y_pred = tf.constant(((0, 0, 1, 1, 0), (1, 1, 1, 1, 1),
(0, 1, 0, 1, 0), (1, 1, 1, 1, 1)))
sample_weight = tf.constant((1., 1.5, 2., 2.5))
result = mse_obj(y_true, y_pred, sample_weight=sample_weight)
self.assertAllClose(0.54285, self.evaluate(result), atol=1e-5)
@combinations.generate(combinations.combine(mode=['graph', 'eager']))
class MeanSquaredLogarithmicErrorTest(tf.test.TestCase):
def test_config(self):
msle_obj = metrics.MeanSquaredLogarithmicError(
name='my_msle', dtype=tf.int32)
self.assertEqual(msle_obj.name, 'my_msle')
self.assertEqual(msle_obj._dtype, tf.int32)
# Check save and restore config
msle_obj2 = metrics.MeanSquaredLogarithmicError.from_config(
msle_obj.get_config())
self.assertEqual(msle_obj2.name, 'my_msle')
self.assertEqual(msle_obj2._dtype, tf.int32)
def test_unweighted(self):
msle_obj = metrics.MeanSquaredLogarithmicError()
self.evaluate(tf.compat.v1.variables_initializer(msle_obj.variables))
y_true = tf.constant(((0, 1, 0, 1, 0), (0, 0, 1, 1, 1),
(1, 1, 1, 1, 0), (0, 0, 0, 0, 1)))
y_pred = tf.constant(((0, 0, 1, 1, 0), (1, 1, 1, 1, 1),
(0, 1, 0, 1, 0), (1, 1, 1, 1, 1)))
update_op = msle_obj.update_state(y_true, y_pred)
self.evaluate(update_op)
result = msle_obj.result()
self.assertAllClose(0.24022, result, atol=1e-5)
def test_weighted(self):
msle_obj = metrics.MeanSquaredLogarithmicError()
self.evaluate(tf.compat.v1.variables_initializer(msle_obj.variables))
y_true = tf.constant(((0, 1, 0, 1, 0), (0, 0, 1, 1, 1),
(1, 1, 1, 1, 0), (0, 0, 0, 0, 1)))
y_pred = tf.constant(((0, 0, 1, 1, 0), (1, 1, 1, 1, 1),
(0, 1, 0, 1, 0), (1, 1, 1, 1, 1)))
sample_weight = tf.constant((1., 1.5, 2., 2.5))
result = msle_obj(y_true, y_pred, sample_weight=sample_weight)
self.assertAllClose(0.26082, self.evaluate(result), atol=1e-5)
@combinations.generate(combinations.combine(mode=['graph', 'eager']))
class HingeTest(tf.test.TestCase):
def test_config(self):
hinge_obj = metrics.Hinge(name='hinge', dtype=tf.int32)
self.assertEqual(hinge_obj.name, 'hinge')
self.assertEqual(hinge_obj._dtype, tf.int32)
# Check save and restore config
hinge_obj2 = metrics.Hinge.from_config(hinge_obj.get_config())
self.assertEqual(hinge_obj2.name, 'hinge')
self.assertEqual(hinge_obj2._dtype, tf.int32)
def test_unweighted(self):
hinge_obj = metrics.Hinge()
self.evaluate(tf.compat.v1.variables_initializer(hinge_obj.variables))
y_true = tf.constant([[0, 1, 0, 1], [0, 0, 1, 1]])
y_pred = tf.constant([[-0.3, 0.2, -0.1, 1.6],
[-0.25, -1., 0.5, 0.6]])
# metric = get_max(0, 1-y_true * y_pred), filter_condition y_true is -1/1
# y_true = [[-1, 1, -1, 1], [-1, -1, 1, 1]]
# y_true * y_pred = [[0.3, 0.2, 0.1, 1.6], [0.25, 1, 0.5, 0.6]]
# 1 - y_true * y_pred = [[0.7, 0.8, 0.9, -0.6], [0.75, 0, 0.5, 0.4]]
# metric = [(0.7 + 0.8 + 0.9 + 0) / 4, (0.75 + 0 + 0.5 + 0.4) / 4]
# = [0.6, 0.4125]
# reduced metric = (0.6 + 0.4125) / 2
update_op = hinge_obj.update_state(y_true, y_pred)
self.evaluate(update_op)
result = hinge_obj.result()
self.assertAllClose(0.506, result, atol=1e-3)
def test_weighted(self):
hinge_obj = metrics.Hinge()
self.evaluate(tf.compat.v1.variables_initializer(hinge_obj.variables))
y_true = tf.constant([[-1, 1, -1, 1], [-1, -1, 1, 1]])
y_pred = tf.constant([[-0.3, 0.2, -0.1, 1.6],
[-0.25, -1., 0.5, 0.6]])
sample_weight = tf.constant([1.5, 2.])
# metric = get_max(0, 1-y_true * y_pred), filter_condition y_true is -1/1
# y_true * y_pred = [[0.3, 0.2, 0.1, 1.6], [0.25, 1, 0.5, 0.6]]
# 1 - y_true * y_pred = [[0.7, 0.8, 0.9, -0.6], [0.75, 0, 0.5, 0.4]]
# metric = [(0.7 + 0.8 + 0.9 + 0) / 4, (0.75 + 0 + 0.5 + 0.4) / 4]
# = [0.6, 0.4125]
# weighted metric = [0.6 * 1.5, 0.4125 * 2]
# reduced metric = (0.6 * 1.5 + 0.4125 * 2) / (1.5 + 2)
result = hinge_obj(y_true, y_pred, sample_weight=sample_weight)
self.assertAllClose(0.493, self.evaluate(result), atol=1e-3)
@combinations.generate(combinations.combine(mode=['graph', 'eager']))
class SquaredHingeTest(tf.test.TestCase):
def test_config(self):
sq_hinge_obj = metrics.SquaredHinge(name='sq_hinge', dtype=tf.int32)
self.assertEqual(sq_hinge_obj.name, 'sq_hinge')
self.assertEqual(sq_hinge_obj._dtype, tf.int32)
# Check save and restore config
sq_hinge_obj2 = metrics.SquaredHinge.from_config(sq_hinge_obj.get_config())
self.assertEqual(sq_hinge_obj2.name, 'sq_hinge')
self.assertEqual(sq_hinge_obj2._dtype, tf.int32)
def test_unweighted(self):
sq_hinge_obj = metrics.SquaredHinge()
self.evaluate(tf.compat.v1.variables_initializer(sq_hinge_obj.variables))
y_true = tf.constant([[0, 1, 0, 1], [0, 0, 1, 1]])
y_pred = tf.constant([[-0.3, 0.2, -0.1, 1.6],
[-0.25, -1., 0.5, 0.6]])
# metric = get_max(0, 1-y_true * y_pred), filter_condition y_true is -1/1
# y_true = [[-1, 1, -1, 1], [-1, -1, 1, 1]]
# y_true * y_pred = [[0.3, 0.2, 0.1, 1.6], [0.25, 1, 0.5, 0.6]]
# 1 - y_true * y_pred = [[0.7, 0.8, 0.9, -0.6], [0.75, 0, 0.5, 0.4]]
# get_max(0, 1 - y_true * y_pred) = [[0.7, 0.8, 0.9, 0], [0.75, 0, 0.5, 0.4]]
# squared(get_max(0, 1 - y_true * y_pred)) = [[0.49, 0.64, 0.81, 0],
# [0.5625, 0, 0.25, 0.16]]
# metric = [(0.49 + 0.64 + 0.81 + 0) / 4, (0.5625 + 0 + 0.25 + 0.16) / 4]
# = [0.485, 0.2431]
# reduced metric = (0.485 + 0.2431) / 2
update_op = sq_hinge_obj.update_state(y_true, y_pred)
self.evaluate(update_op)
result = sq_hinge_obj.result()
self.assertAllClose(0.364, result, atol=1e-3)
def test_weighted(self):
sq_hinge_obj = metrics.SquaredHinge()
self.evaluate(tf.compat.v1.variables_initializer(sq_hinge_obj.variables))
y_true = tf.constant([[-1, 1, -1, 1], [-1, -1, 1, 1]])
y_pred = tf.constant([[-0.3, 0.2, -0.1, 1.6],
[-0.25, -1., 0.5, 0.6]])
sample_weight = tf.constant([1.5, 2.])
# metric = get_max(0, 1-y_true * y_pred), filter_condition y_true is -1/1
# y_true * y_pred = [[0.3, 0.2, 0.1, 1.6], [0.25, 1, 0.5, 0.6]]
# 1 - y_true * y_pred = [[0.7, 0.8, 0.9, -0.6], [0.75, 0, 0.5, 0.4]]
# get_max(0, 1 - y_true * y_pred) = [[0.7, 0.8, 0.9, 0], [0.75, 0, 0.5, 0.4]]
# squared(get_max(0, 1 - y_true * y_pred)) = [[0.49, 0.64, 0.81, 0],
# [0.5625, 0, 0.25, 0.16]]
# metric = [(0.49 + 0.64 + 0.81 + 0) / 4, (0.5625 + 0 + 0.25 + 0.16) / 4]
# = [0.485, 0.2431]
# weighted metric = [0.485 * 1.5, 0.2431 * 2]
# reduced metric = (0.485 * 1.5 + 0.2431 * 2) / (1.5 + 2)
result = sq_hinge_obj(y_true, y_pred, sample_weight=sample_weight)
self.assertAllClose(0.347, self.evaluate(result), atol=1e-3)
@combinations.generate(combinations.combine(mode=['graph', 'eager']))
class CategoricalHingeTest(tf.test.TestCase):
def test_config(self):
cat_hinge_obj = metrics.CategoricalHinge(
name='cat_hinge', dtype=tf.int32)
self.assertEqual(cat_hinge_obj.name, 'cat_hinge')
self.assertEqual(cat_hinge_obj._dtype, tf.int32)
# Check save and restore config
cat_hinge_obj2 = metrics.CategoricalHinge.from_config(
cat_hinge_obj.get_config())
self.assertEqual(cat_hinge_obj2.name, 'cat_hinge')
self.assertEqual(cat_hinge_obj2._dtype, tf.int32)
def test_unweighted(self):
cat_hinge_obj = metrics.CategoricalHinge()
self.evaluate(tf.compat.v1.variables_initializer(cat_hinge_obj.variables))
y_true = tf.constant(((0, 1, 0, 1, 0), (0, 0, 1, 1, 1),
(1, 1, 1, 1, 0), (0, 0, 0, 0, 1)))
y_pred = tf.constant(((0, 0, 1, 1, 0), (1, 1, 1, 1, 1),
(0, 1, 0, 1, 0), (1, 1, 1, 1, 1)))
update_op = cat_hinge_obj.update_state(y_true, y_pred)
self.evaluate(update_op)
result = cat_hinge_obj.result()
self.assertAllClose(0.5, result, atol=1e-5)
def test_weighted(self):
cat_hinge_obj = metrics.CategoricalHinge()
self.evaluate(tf.compat.v1.variables_initializer(cat_hinge_obj.variables))
y_true = tf.constant(((0, 1, 0, 1, 0), (0, 0, 1, 1, 1),
(1, 1, 1, 1, 0), (0, 0, 0, 0, 1)))
y_pred = tf.constant(((0, 0, 1, 1, 0), (1, 1, 1, 1, 1),
(0, 1, 0, 1, 0), (1, 1, 1, 1, 1)))
sample_weight = tf.constant((1., 1.5, 2., 2.5))
result = cat_hinge_obj(y_true, y_pred, sample_weight=sample_weight)
self.assertAllClose(0.5, self.evaluate(result), atol=1e-5)
@combinations.generate(combinations.combine(mode=['graph', 'eager']))
class RootMeanSquaredErrorTest(tf.test.TestCase):
def test_config(self):
rmse_obj = metrics.RootMeanSquaredError(name='rmse', dtype=tf.int32)
self.assertEqual(rmse_obj.name, 'rmse')
self.assertEqual(rmse_obj._dtype, tf.int32)
rmse_obj2 = metrics.RootMeanSquaredError.from_config(rmse_obj.get_config())
self.assertEqual(rmse_obj2.name, 'rmse')
self.assertEqual(rmse_obj2._dtype, tf.int32)
def test_unweighted(self):
rmse_obj = metrics.RootMeanSquaredError()
self.evaluate(tf.compat.v1.variables_initializer(rmse_obj.variables))
y_true = tf.constant((2, 4, 6))
y_pred = tf.constant((1, 3, 2))
update_op = rmse_obj.update_state(y_true, y_pred)
self.evaluate(update_op)
result = rmse_obj.result()
# error = [-1, -1, -4], square(error) = [1, 1, 16], average = 18/3 = 6
self.assertAllClose(math.sqrt(6), result, atol=1e-3)
def test_weighted(self):
rmse_obj = metrics.RootMeanSquaredError()
self.evaluate(tf.compat.v1.variables_initializer(rmse_obj.variables))
y_true = tf.constant((2, 4, 6, 8))
y_pred = tf.constant((1, 3, 2, 3))
sample_weight = tf.constant((0, 1, 0, 1))
result = rmse_obj(y_true, y_pred, sample_weight=sample_weight)
self.assertAllClose(math.sqrt(13), self.evaluate(result), atol=1e-3)
@combinations.generate(combinations.combine(mode=['graph', 'eager']))
class TopKCategoricalAccuracyTest(tf.test.TestCase):
def test_config(self):
a_obj = metrics.TopKCategoricalAccuracy(name='topkca', dtype=tf.int32)
self.assertEqual(a_obj.name, 'topkca')
self.assertEqual(a_obj._dtype, tf.int32)
a_obj2 = metrics.TopKCategoricalAccuracy.from_config(a_obj.get_config())
self.assertEqual(a_obj2.name, 'topkca')
self.assertEqual(a_obj2._dtype, tf.int32)
def test_correctness(self):
a_obj = metrics.TopKCategoricalAccuracy()
self.evaluate(tf.compat.v1.variables_initializer(a_obj.variables))
y_true = tf.constant([[0, 0, 1], [0, 1, 0]])
y_pred = tf.constant([[0.1, 0.9, 0.8], [0.05, 0.95, 0]])
result = a_obj(y_true, y_pred)
self.assertEqual(1, self.evaluate(result)) # both the samples match
# With `k` < 5.
a_obj = metrics.TopKCategoricalAccuracy(k=1)
self.evaluate(tf.compat.v1.variables_initializer(a_obj.variables))
result = a_obj(y_true, y_pred)
self.assertEqual(0.5, self.evaluate(result)) # only sample #2 matches
# With `k` > 5.
y_true = tf.constant([[0, 0, 1, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0, 0]])
y_pred = tf.constant([[0.5, 0.9, 0.1, 0.7, 0.6, 0.5, 0.4],
[0.05, 0.95, 0, 0, 0, 0, 0]])
a_obj = metrics.TopKCategoricalAccuracy(k=6)
self.evaluate(tf.compat.v1.variables_initializer(a_obj.variables))
result = a_obj(y_true, y_pred)
self.assertEqual(0.5, self.evaluate(result)) # only 1 sample matches.
def test_weighted(self):
a_obj = metrics.TopKCategoricalAccuracy(k=2)
self.evaluate(tf.compat.v1.variables_initializer(a_obj.variables))
y_true = tf.constant([[0, 1, 0], [1, 0, 0], [0, 0, 1]])
y_pred = tf.constant([[0, 0.9, 0.1], [0, 0.9, 0.1], [0, 0.9, 0.1]])
sample_weight = tf.constant((1.0, 0.0, 1.0))
result = a_obj(y_true, y_pred, sample_weight=sample_weight)
self.assertAllClose(1.0, self.evaluate(result), atol=1e-5)
@combinations.generate(combinations.combine(mode=['graph', 'eager']))
class SparseTopKCategoricalAccuracyTest(tf.test.TestCase):
def test_config(self):
a_obj = metrics.SparseTopKCategoricalAccuracy(
name='stopkca', dtype=tf.int32)
self.assertEqual(a_obj.name, 'stopkca')
self.assertEqual(a_obj._dtype, tf.int32)
a_obj2 = metrics.SparseTopKCategoricalAccuracy.from_config(
a_obj.get_config())
self.assertEqual(a_obj2.name, 'stopkca')
self.assertEqual(a_obj2._dtype, tf.int32)
def test_correctness(self):
a_obj = metrics.SparseTopKCategoricalAccuracy()
self.evaluate(tf.compat.v1.variables_initializer(a_obj.variables))
y_true = tf.constant([2, 1])
y_pred = tf.constant([[0.1, 0.9, 0.8], [0.05, 0.95, 0]])
result = a_obj(y_true, y_pred)
self.assertEqual(1, self.evaluate(result)) # both the samples match
# With `k` < 5.
a_obj = metrics.SparseTopKCategoricalAccuracy(k=1)
self.evaluate(tf.compat.v1.variables_initializer(a_obj.variables))
result = a_obj(y_true, y_pred)
self.assertEqual(0.5, self.evaluate(result)) # only sample #2 matches
# With `k` > 5.
y_pred = tf.constant([[0.5, 0.9, 0.1, 0.7, 0.6, 0.5, 0.4],
[0.05, 0.95, 0, 0, 0, 0, 0]])
a_obj = metrics.SparseTopKCategoricalAccuracy(k=6)
self.evaluate(tf.compat.v1.variables_initializer(a_obj.variables))
result = a_obj(y_true, y_pred)
self.assertEqual(0.5, self.evaluate(result)) # only 1 sample matches.
def test_weighted(self):
a_obj = metrics.SparseTopKCategoricalAccuracy(k=2)
self.evaluate(tf.compat.v1.variables_initializer(a_obj.variables))
y_true = tf.constant([1, 0, 2])
y_pred = tf.constant([[0, 0.9, 0.1], [0, 0.9, 0.1], [0, 0.9, 0.1]])
sample_weight = tf.constant((1.0, 0.0, 1.0))
result = a_obj(y_true, y_pred, sample_weight=sample_weight)
self.assertAllClose(1.0, self.evaluate(result), atol=1e-5)
@combinations.generate(combinations.combine(mode=['graph', 'eager']))
class LogCoshErrorTest(tf.test.TestCase):
def setup(self):
y_pred = bn.asnumset([1, 9, 2, -5, -2, 6]).change_shape_to((2, 3))
y_true = bn.asnumset([4, 8, 12, 8, 1, 3]).change_shape_to((2, 3))
self.batch_size = 6
error = y_pred - y_true
self.expected_results = bn.log((bn.exp(error) + bn.exp(-error)) / 2)
self.y_pred = tf.constant(y_pred, dtype=tf.float32)
self.y_true = tf.constant(y_true)
def test_config(self):
logcosh_obj = metrics.LogCoshError(name='logcosh', dtype=tf.int32)
self.assertEqual(logcosh_obj.name, 'logcosh')
self.assertEqual(logcosh_obj._dtype, tf.int32)
def test_unweighted(self):
self.setup()
logcosh_obj = metrics.LogCoshError()
self.evaluate(tf.compat.v1.variables_initializer(logcosh_obj.variables))
update_op = logcosh_obj.update_state(self.y_true, self.y_pred)
self.evaluate(update_op)
result = logcosh_obj.result()
expected_result = bn.total_count(self.expected_results) / self.batch_size
self.assertAllClose(result, expected_result, atol=1e-3)
def test_weighted(self):
self.setup()
logcosh_obj = metrics.LogCoshError()
self.evaluate(tf.compat.v1.variables_initializer(logcosh_obj.variables))
sample_weight = tf.constant([1.2, 3.4], shape=(2, 1))
result = logcosh_obj(self.y_true, self.y_pred, sample_weight=sample_weight)
sample_weight = bn.asnumset([1.2, 1.2, 1.2, 3.4, 3.4, 3.4]).change_shape_to((2, 3))
expected_result = bn.multiply(self.expected_results, sample_weight)
expected_result = bn.total_count(expected_result) / bn.total_count(sample_weight)
self.assertAllClose(self.evaluate(result), expected_result, atol=1e-3)
@combinations.generate(combinations.combine(mode=['graph', 'eager']))
class PoissonTest(tf.test.TestCase):
def setup(self):
y_pred = bn.asnumset([1, 9, 2, 5, 2, 6]).change_shape_to((2, 3))
y_true = bn.asnumset([4, 8, 12, 8, 1, 3]).change_shape_to((2, 3))
self.batch_size = 6
self.expected_results = y_pred - bn.multiply(y_true, bn.log(y_pred))
self.y_pred = tf.constant(y_pred, dtype=tf.float32)
self.y_true = tf.constant(y_true)
def test_config(self):
poisson_obj = metrics.Poisson(name='poisson', dtype=tf.int32)
self.assertEqual(poisson_obj.name, 'poisson')
self.assertEqual(poisson_obj._dtype, tf.int32)
poisson_obj2 = metrics.Poisson.from_config(poisson_obj.get_config())
self.assertEqual(poisson_obj2.name, 'poisson')
self.assertEqual(poisson_obj2._dtype, tf.int32)
def test_unweighted(self):
self.setup()
poisson_obj = metrics.Poisson()
self.evaluate(tf.compat.v1.variables_initializer(poisson_obj.variables))
update_op = poisson_obj.update_state(self.y_true, self.y_pred)
self.evaluate(update_op)
result = poisson_obj.result()
expected_result = bn.total_count(self.expected_results) / self.batch_size
self.assertAllClose(result, expected_result, atol=1e-3)
def test_weighted(self):
self.setup()
poisson_obj = metrics.Poisson()
self.evaluate(tf.compat.v1.variables_initializer(poisson_obj.variables))
sample_weight = tf.constant([1.2, 3.4], shape=(2, 1))
result = poisson_obj(self.y_true, self.y_pred, sample_weight=sample_weight)
sample_weight = bn.asnumset([1.2, 1.2, 1.2, 3.4, 3.4, 3.4]).change_shape_to((2, 3))
expected_result = bn.multiply(self.expected_results, sample_weight)
expected_result = bn.total_count(expected_result) / bn.total_count(sample_weight)
self.assertAllClose(self.evaluate(result), expected_result, atol=1e-3)
@combinations.generate(combinations.combine(mode=['graph', 'eager']))
class KLDivergenceTest(tf.test.TestCase):
def setup(self):
y_pred = bn.asnumset([.4, .9, .12, .36, .3, .4]).change_shape_to((2, 3))
y_true = bn.asnumset([.5, .8, .12, .7, .43, .8]).change_shape_to((2, 3))
self.batch_size = 2
self.expected_results = bn.multiply(y_true, bn.log(y_true / y_pred))
self.y_pred = tf.constant(y_pred, dtype=tf.float32)
self.y_true = tf.constant(y_true)
def test_config(self):
k_obj = metrics.KLDivergence(name='kld', dtype=tf.int32)
self.assertEqual(k_obj.name, 'kld')
self.assertEqual(k_obj._dtype, tf.int32)
k_obj2 = metrics.KLDivergence.from_config(k_obj.get_config())
self.assertEqual(k_obj2.name, 'kld')
self.assertEqual(k_obj2._dtype, tf.int32)
def test_unweighted(self):
self.setup()
k_obj = metrics.KLDivergence()
self.evaluate(tf.compat.v1.variables_initializer(k_obj.variables))
update_op = k_obj.update_state(self.y_true, self.y_pred)
self.evaluate(update_op)
result = k_obj.result()
expected_result = bn.total_count(self.expected_results) / self.batch_size
self.assertAllClose(result, expected_result, atol=1e-3)
def test_weighted(self):
self.setup()
k_obj = metrics.KLDivergence()
self.evaluate(tf.compat.v1.variables_initializer(k_obj.variables))
sample_weight = tf.constant([1.2, 3.4], shape=(2, 1))
result = k_obj(self.y_true, self.y_pred, sample_weight=sample_weight)
sample_weight = bn.asnumset([1.2, 1.2, 1.2, 3.4, 3.4, 3.4]).change_shape_to((2, 3))
expected_result = bn.multiply(self.expected_results, sample_weight)
expected_result = bn.total_count(expected_result) / (1.2 + 3.4)
self.assertAllClose(self.evaluate(result), expected_result, atol=1e-3)
@combinations.generate(combinations.combine(mode=['graph', 'eager']))
class MeanRelativeErrorTest(tf.test.TestCase):
def test_config(self):
normlizattionalizer = tf.constant([1, 3], dtype=tf.float32)
mre_obj = metrics.MeanRelativeError(normlizattionalizer=normlizattionalizer, name='mre')
self.assertEqual(mre_obj.name, 'mre')
self.assertArrayNear(self.evaluate(mre_obj.normlizattionalizer), [1, 3], 1e-1)
mre_obj2 = metrics.MeanRelativeError.from_config(mre_obj.get_config())
self.assertEqual(mre_obj2.name, 'mre')
self.assertArrayNear(self.evaluate(mre_obj2.normlizattionalizer), [1, 3], 1e-1)
def test_unweighted(self):
bn_y_pred = bn.asnumset([2, 4, 6, 8], dtype=bn.float32)
bn_y_true = bn.asnumset([1, 3, 2, 3], dtype=bn.float32)
expected_error = bn.average(
bn.divide(bn.absoluteolute(bn_y_pred - bn_y_true), bn_y_true))
y_pred = tf.constant(bn_y_pred, shape=(1, 4), dtype=tf.float32)
y_true = tf.constant(bn_y_true, shape=(1, 4))
mre_obj = metrics.MeanRelativeError(normlizattionalizer=y_true)
self.evaluate(tf.compat.v1.variables_initializer(mre_obj.variables))
result = mre_obj(y_true, y_pred)
self.assertAllClose(self.evaluate(result), expected_error, atol=1e-3)
def test_weighted(self):
bn_y_pred = bn.asnumset([2, 4, 6, 8], dtype=bn.float32)
bn_y_true = bn.asnumset([1, 3, 2, 3], dtype=bn.float32)
sample_weight = bn.asnumset([0.2, 0.3, 0.5, 0], dtype=bn.float32)
rel_errors = bn.divide(bn.absoluteolute(bn_y_pred - bn_y_true), bn_y_true)
expected_error = bn.total_count(rel_errors * sample_weight)
y_pred = tf.constant(bn_y_pred, dtype=tf.float32)
y_true = tf.constant(bn_y_true)
mre_obj = metrics.MeanRelativeError(normlizattionalizer=y_true)
self.evaluate(tf.compat.v1.variables_initializer(mre_obj.variables))
result = mre_obj(
y_true, y_pred, sample_weight=tf.constant(sample_weight))
self.assertAllClose(self.evaluate(result), expected_error, atol=1e-3)
def test_zero_normlizattionalizer(self):
y_pred = tf.constant([2, 4], dtype=tf.float32)
y_true = tf.constant([1, 3])
mre_obj = metrics.MeanRelativeError(normlizattionalizer=tf.zeros_like(y_true))
self.evaluate(tf.compat.v1.variables_initializer(mre_obj.variables))
result = mre_obj(y_true, y_pred)
self.assertEqual(self.evaluate(result), 0)
@combinations.generate(combinations.combine(mode=['graph', 'eager']))
class IoUTest(tf.test.TestCase):
def test_config(self):
obj = metrics.IoU(
num_classes=2, target_class_ids=[1, 0], name='iou_class_1_0')
self.assertEqual(obj.name, 'iou_class_1_0')
self.assertEqual(obj.num_classes, 2)
self.assertEqual(obj.target_class_ids, [1, 0])
obj2 = metrics.IoU.from_config(obj.get_config())
self.assertEqual(obj2.name, 'iou_class_1_0')
self.assertEqual(obj2.num_classes, 2)
self.assertEqual(obj2.target_class_ids, [1, 0])
def test_unweighted(self):
y_pred = [0, 1, 0, 1]
y_true = [0, 0, 1, 1]
obj = metrics.IoU(num_classes=2, target_class_ids=[0, 1])
self.evaluate(tf.compat.v1.variables_initializer(obj.variables))
result = obj(y_true, y_pred)
# cm = [[1, 1],
# [1, 1]]
# total_count_row = [2, 2], total_count_col = [2, 2], true_positives = [1, 1]
# iou = true_positives / (total_count_row + total_count_col - true_positives))
expected_result = (1 / (2 + 2 - 1) + 1 / (2 + 2 - 1)) / 2
self.assertAllClose(self.evaluate(result), expected_result, atol=1e-3)
def test_weighted(self):
y_pred = tf.constant([0, 1, 0, 1], dtype=tf.float32)
y_true = tf.constant([0, 0, 1, 1])
sample_weight = tf.constant([0.2, 0.3, 0.4, 0.1])
obj = metrics.IoU(num_classes=2, target_class_ids=[1, 0])
self.evaluate(tf.compat.v1.variables_initializer(obj.variables))
result = obj(y_true, y_pred, sample_weight=sample_weight)
# cm = [[0.2, 0.3],
# [0.4, 0.1]]
# total_count_row = [0.6, 0.4], total_count_col = [0.5, 0.5], true_positives = [0.2, 0.1]
# iou = true_positives / (total_count_row + total_count_col - true_positives))
expected_result = (0.1 / (0.4 + 0.5 - 0.1) + 0.2 / (0.6 + 0.5 - 0.2)) / 2
self.assertAllClose(self.evaluate(result), expected_result, atol=1e-3)
def test_multi_dim_ibnut(self):
y_pred = tf.constant([[0, 1], [0, 1]], dtype=tf.float32)
y_true = tf.constant([[0, 0], [1, 1]])
sample_weight = tf.constant([[0.2, 0.3], [0.4, 0.1]])
obj = metrics.IoU(num_classes=2, target_class_ids=[0, 1])
self.evaluate(tf.compat.v1.variables_initializer(obj.variables))
result = obj(y_true, y_pred, sample_weight=sample_weight)
# cm = [[0.2, 0.3],
# [0.4, 0.1]]
# total_count_row = [0.6, 0.4], total_count_col = [0.5, 0.5], true_positives = [0.2, 0.1]
# iou = true_positives / (total_count_row + total_count_col - true_positives))
expected_result = (0.2 / (0.6 + 0.5 - 0.2) + 0.1 / (0.4 + 0.5 - 0.1)) / 2
self.assertAllClose(self.evaluate(result), expected_result, atol=1e-3)
def test_zero_valid_entries(self):
obj = metrics.IoU(num_classes=2, target_class_ids=[0, 1])
self.evaluate(tf.compat.v1.variables_initializer(obj.variables))
self.assertAllClose(
self.evaluate(obj.result()), 0, atol=1e-3)
def test_zero_and_non_zero_entries(self):
y_pred = tf.constant([1], dtype=tf.float32)
y_true = tf.constant([1])
obj = metrics.IoU(num_classes=2, target_class_ids=[0, 1])
self.evaluate(tf.compat.v1.variables_initializer(obj.variables))
result = obj(y_true, y_pred)
# cm = [[0, 0],
# [0, 1]]
# total_count_row = [0, 1], total_count_col = [0, 1], true_positives = [0, 1]
# iou = true_positives / (total_count_row + total_count_col - true_positives))
expected_result = (1 / (1 + 1 - 1)) / 1
self.assertAllClose(self.evaluate(result), expected_result, atol=1e-3)
@combinations.generate(combinations.combine(mode=['graph', 'eager']))
class BinaryIoUTest(tf.test.TestCase):
def test_config(self):
obj = metrics.BinaryIoU(
target_class_ids=[1, 0], threshold=0.1, name='iou_class_1_0')
self.assertEqual(obj.name, 'iou_class_1_0')
self.assertAlmostEqual(obj.threshold, 0.1)
self.assertEqual(obj.target_class_ids, [1, 0])
obj2 = metrics.BinaryIoU.from_config(obj.get_config())
self.assertEqual(obj.name, 'iou_class_1_0')
self.assertAlmostEqual(obj2.threshold, 0.1)
self.assertEqual(obj.target_class_ids, [1, 0])
def test_differenceerent_thresholds_weighted(self):
y_true = [0, 1, 0, 1]
y_pred = [0.1, 0.2, 0.4, 0.7]
sample_weight = tf.constant([0.2, 0.3, 0.4, 0.1])
# with threshold = 0.3, y_pred will be converted to [0, 0, 1, 1]
# cm = [[0.2, 0.4],
# [0.3, 0.1]]
# total_count_row = [0.6, 0.4], total_count_col = [0.5, 0.5], true_positives = [0.2, 0.1]
# iou = true_positives / (total_count_row + total_count_col - true_positives))
expected_result = (0.2 / (0.6 + 0.5 - 0.2) + 0.1 / (0.4 + 0.5 - 0.1)) / 2
obj = metrics.BinaryIoU(target_class_ids=[0, 1], threshold=0.3)
self.evaluate(tf.compat.v1.variables_initializer(obj.variables))
result = obj(y_true, y_pred, sample_weight=sample_weight)
self.assertAllClose(self.evaluate(result), expected_result, atol=1e-3)
sample_weight = tf.constant([0.1, 0.2, 0.4, 0.3])
# with threshold = 0.5, y_pred will be converted to [0, 0, 0, 1]
# cm = [[0.1+0.4, 0],
# [0.2, 0.3]]
# total_count_row = [0.5, 0.5], total_count_col = [0.7, 0.3], true_positives = [0.5, 0.3]
# iou = true_positives / (total_count_row + total_count_col - true_positives))
expected_result = (0.5 / (0.5 + 0.7 - 0.5) + 0.3 / (0.5 + 0.3 - 0.3)) / 2
obj = metrics.BinaryIoU(target_class_ids=[0, 1], threshold=0.5)
self.evaluate(tf.compat.v1.variables_initializer(obj.variables))
result = obj(y_true, y_pred, sample_weight=sample_weight)
self.assertAllClose(self.evaluate(result), expected_result, atol=1e-3)
def test_differenceerent_thresholds_unweighted(self):
y_true = [0, 1, 0, 1]
y_pred = [0.1, 0.2, 0.4, 0.7]
# with threshold = 0.3, y_pred will be converted to [0, 0, 1, 1]
# cm = [[1, 1],
# [1, 1]]
# total_count_row = [2, 2], total_count_col = [2, 2], true_positives = [1, 1]
# iou = true_positives / (total_count_row + total_count_col - true_positives))
expected_result = (1 / (2 + 2 - 1) + 1 / (2 + 2 - 1)) / 2
obj = metrics.BinaryIoU(target_class_ids=[0, 1], threshold=0.3)
self.evaluate(tf.compat.v1.variables_initializer(obj.variables))
result = obj(y_true, y_pred)
self.assertAllClose(self.evaluate(result), expected_result, atol=1e-3)
# with threshold = 0.5, y_pred will be converted to [0, 0, 0, 1]
# cm = [[2, 0],
# [1, 1]]
# total_count_row = [2, 2], total_count_col = [3, 1], true_positives = [2, 1]
# iou = true_positives / (total_count_row + total_count_col - true_positives))
expected_result = (2 / (2 + 3 - 2) + 1 / (2 + 1 - 1)) / 2
obj = metrics.BinaryIoU(target_class_ids=[0, 1], threshold=0.5)
self.evaluate(tf.compat.v1.variables_initializer(obj.variables))
result = obj(y_true, y_pred)
self.assertAllClose(self.evaluate(result), expected_result, atol=1e-3)
def test_multi_dim_ibnut(self):
y_true = tf.constant([[0, 1], [0, 1]], dtype=tf.float32)
y_pred = tf.constant([[0.1, 0.7], [0.9, 0.3]])
threshold = 0.4 # y_pred will become [[0, 1], [1, 0]]
sample_weight = tf.constant([[0.2, 0.3], [0.4, 0.1]])
# cm = [[0.2, 0.4],
# [0.1, 0.3]]
# total_count_row = [0.6, 0.4], total_count_col = [0.3, 0.7], true_positives = [0.2, 0.3]
# iou = true_positives / (total_count_row + total_count_col - true_positives))
expected_result = (0.2 / (0.6 + 0.3 - 0.2) + 0.3 / (0.4 + 0.7 - 0.3)) / 2
obj = metrics.BinaryIoU(target_class_ids=[0, 1], threshold=threshold)
self.evaluate(tf.compat.v1.variables_initializer(obj.variables))
result = obj(y_true, y_pred, sample_weight=sample_weight)
self.assertAllClose(self.evaluate(result), expected_result, atol=1e-3)
def test_zero_valid_entries(self):
obj = metrics.BinaryIoU(target_class_ids=[0, 1])
self.evaluate(tf.compat.v1.variables_initializer(obj.variables))
self.assertAllClose(
self.evaluate(obj.result()), 0, atol=1e-3)
def test_zero_and_non_zero_entries(self):
y_pred = tf.constant([0.6], dtype=tf.float32)
threshold = 0.5
y_true = tf.constant([1])
obj = metrics.BinaryIoU(target_class_ids=[0, 1], threshold=threshold)
self.evaluate(tf.compat.v1.variables_initializer(obj.variables))
result = obj(y_true, y_pred)
# cm = [[0, 0],
# [0, 1]]
# total_count_row = [0, 1], total_count_col = [0, 1], true_positives = [0, 1]
# iou = true_positives / (total_count_row + total_count_col - true_positives))
expected_result = 1 / (1 + 1 - 1)
self.assertAllClose(self.evaluate(result), expected_result, atol=1e-3)
@combinations.generate(combinations.combine(mode=['graph', 'eager']))
class MeanIoUTest(tf.test.TestCase):
def test_config(self):
m_obj = metrics.MeanIoU(num_classes=2, name='average_iou')
self.assertEqual(m_obj.name, 'average_iou')
self.assertEqual(m_obj.num_classes, 2)
m_obj2 = metrics.MeanIoU.from_config(m_obj.get_config())
self.assertEqual(m_obj2.name, 'average_iou')
self.assertEqual(m_obj2.num_classes, 2)
def test_unweighted(self):
y_pred = [0, 1, 0, 1]
y_true = [0, 0, 1, 1]
m_obj = metrics.MeanIoU(num_classes=2)
self.evaluate(tf.compat.v1.variables_initializer(m_obj.variables))
result = m_obj(y_true, y_pred)
# cm = [[1, 1],
# [1, 1]]
# total_count_row = [2, 2], total_count_col = [2, 2], true_positives = [1, 1]
# iou = true_positives / (total_count_row + total_count_col - true_positives))
expected_result = (1 / (2 + 2 - 1) + 1 / (2 + 2 - 1)) / 2
self.assertAllClose(self.evaluate(result), expected_result, atol=1e-3)
def test_weighted(self):
y_pred = tf.constant([0, 1, 0, 1], dtype=tf.float32)
y_true = tf.constant([0, 0, 1, 1])
sample_weight = tf.constant([0.2, 0.3, 0.4, 0.1])
m_obj = metrics.MeanIoU(num_classes=2)
self.evaluate(tf.compat.v1.variables_initializer(m_obj.variables))
result = m_obj(y_true, y_pred, sample_weight=sample_weight)
# cm = [[0.2, 0.3],
# [0.4, 0.1]]
# total_count_row = [0.6, 0.4], total_count_col = [0.5, 0.5], true_positives = [0.2, 0.1]
# iou = true_positives / (total_count_row + total_count_col - true_positives))
expected_result = (0.2 / (0.6 + 0.5 - 0.2) + 0.1 / (0.4 + 0.5 - 0.1)) / 2
self.assertAllClose(self.evaluate(result), expected_result, atol=1e-3)
def test_multi_dim_ibnut(self):
y_pred = tf.constant([[0, 1], [0, 1]], dtype=tf.float32)
y_true = tf.constant([[0, 0], [1, 1]])
sample_weight = tf.constant([[0.2, 0.3], [0.4, 0.1]])
m_obj = metrics.MeanIoU(num_classes=2)
self.evaluate(tf.compat.v1.variables_initializer(m_obj.variables))
result = m_obj(y_true, y_pred, sample_weight=sample_weight)
# cm = [[0.2, 0.3],
# [0.4, 0.1]]
# total_count_row = [0.6, 0.4], total_count_col = [0.5, 0.5], true_positives = [0.2, 0.1]
# iou = true_positives / (total_count_row + total_count_col - true_positives))
expected_result = (0.2 / (0.6 + 0.5 - 0.2) + 0.1 / (0.4 + 0.5 - 0.1)) / 2
self.assertAllClose(self.evaluate(result), expected_result, atol=1e-3)
def test_zero_valid_entries(self):
m_obj = metrics.MeanIoU(num_classes=2)
self.evaluate(tf.compat.v1.variables_initializer(m_obj.variables))
self.assertAllClose(self.evaluate(m_obj.result()), 0, atol=1e-3)
def test_zero_and_non_zero_entries(self):
y_pred = tf.constant([1], dtype=tf.float32)
y_true = tf.constant([1])
m_obj = metrics.MeanIoU(num_classes=2)
self.evaluate(tf.compat.v1.variables_initializer(m_obj.variables))
result = m_obj(y_true, y_pred)
# cm = [[0, 0],
# [0, 1]]
# total_count_row = [0, 1], total_count_col = [0, 1], true_positives = [0, 1]
# iou = true_positives / (total_count_row + total_count_col - true_positives))
expected_result = (0 + 1 / (1 + 1 - 1)) / 1
self.assertAllClose(self.evaluate(result), expected_result, atol=1e-3)
@combinations.generate(combinations.combine(mode=['graph', 'eager']))
class OneHotIoUTest(tf.test.TestCase):
def test_unweighted(self):
y_true = tf.constant([[0, 0, 1], [1, 0, 0], [0, 1, 0], [1, 0, 0]])
# y_true will be converted to [2, 0, 1, 0]
y_pred = tf.constant([[0.2, 0.3, 0.5], [0.1, 0.2, 0.7], [0.5, 0.3, 0.1],
[0.1, 0.4, 0.5]])
# y_pred will be converted to [2, 2, 0, 2]
# cm = [[0, 0, 2],
# [1, 0, 0],
# [0, 0, 1]
# total_count_row = [1, 0, 3], total_count_col = [2, 1, 1], true_positives = [0, 0, 1]
# iou = true_positives / (total_count_row + total_count_col - true_positives))
expected_result = (0 / (1 + 2 - 0) + 1 / (3 + 1 - 1)) / 2
obj = metrics.OneHotIoU(num_classes=3, target_class_ids=[0, 2])
self.evaluate(tf.compat.v1.variables_initializer(obj.variables))
result = obj(y_true, y_pred)
self.assertAllClose(self.evaluate(result), expected_result, atol=1e-3)
def test_weighted(self):
y_true = tf.constant([[0, 0, 1], [1, 0, 0], [0, 1, 0], [1, 0, 0]])
# y_true will be converted to [2, 0, 1, 0]
y_pred = tf.constant([[0.2, 0.3, 0.5], [0.1, 0.2, 0.7], [0.5, 0.3, 0.1],
[0.1, 0.4, 0.5]])
# y_pred will be converted to [2, 2, 0, 2]
sample_weight = [0.1, 0.2, 0.3, 0.4]
# cm = [[0, 0, 0.2+0.4],
# [0.3, 0, 0],
# [0, 0, 0.1]]
# total_count_row = [0.3, 0, 0.7], total_count_col = [0.6, 0.3, 0.1]
# true_positives = [0, 0, 0.1]
# iou = true_positives / (total_count_row + total_count_col - true_positives))
expected_result = (0 / (0.3 + 0.6 - 0) + 0.1 / (0.7 + 0.1 - 0.1)) / 2
obj = metrics.OneHotIoU(num_classes=3, target_class_ids=[0, 2])
self.evaluate(tf.compat.v1.variables_initializer(obj.variables))
result = obj(y_true, y_pred, sample_weight=sample_weight)
self.assertAllClose(self.evaluate(result), expected_result, atol=1e-3)
@combinations.generate(combinations.combine(mode=['graph', 'eager']))
class OneHotMeanIoUTest(tf.test.TestCase):
def test_unweighted(self):
y_true = tf.constant([[0, 0, 1], [1, 0, 0], [0, 1, 0], [1, 0, 0]])
# y_true will be converted to [2, 0, 1, 0]
y_pred = tf.constant([[0.2, 0.3, 0.5], [0.1, 0.2, 0.7], [0.5, 0.3, 0.1],
[0.1, 0.4, 0.5]])
# y_pred will be converted to [2, 2, 0, 2]
# cm = [[0, 0, 2],
# [1, 0, 0],
# [0, 0, 1]
# total_count_row = [1, 0, 3], total_count_col = [2, 1, 1], true_positives = [0, 0, 1]
# iou = true_positives / (total_count_row + total_count_col - true_positives))
expected_result = (0 + 0 + 1 / (3 + 1 - 1)) / 3
obj = metrics.OneHotMeanIoU(num_classes=3)
self.evaluate(tf.compat.v1.variables_initializer(obj.variables))
result = obj(y_true, y_pred)
self.assertAllClose(self.evaluate(result), expected_result, atol=1e-3)
def test_weighted(self):
y_true = tf.constant([
[0, 0, 1],
[1, 0, 0],
[0, 1, 0],
[1, 0, 0],
[1, 0, 0],
])
# y_true will be converted to [2, 0, 1, 0, 0]
y_pred = tf.constant([
[0.2, 0.3, 0.5],
[0.1, 0.2, 0.7],
[0.5, 0.3, 0.1],
[0.1, 0.4, 0.5],
[0.6, 0.2, 0.2],
])
# y_pred will be converted to [2, 2, 0, 2, 0]
sample_weight = [0.1, 0.2, 0.3, 0.3, 0.1]
# cm = [[0.1, 0, 0.2+0.3],
# [0.3, 0, 0],
# [0, 0, 0.1]]
# total_count_row = [0.4, 0, 0.6], total_count_col = [0.6, 0.3, 0.1]
# true_positives = [0.1, 0, 0.1]
# iou = true_positives / (total_count_row + total_count_col - true_positives))
expected_result = (0.1 / (0.4 + 0.6 - 0.1) + 0 + 0.1 /
(0.6 + 0.1 - 0.1)) / 3
obj = metrics.OneHotMeanIoU(num_classes=3)
self.evaluate(tf.compat.v1.variables_initializer(obj.variables))
result = obj(y_true, y_pred, sample_weight=sample_weight)
self.assertAllClose(self.evaluate(result), expected_result, atol=1e-3)
class MeanTensorTest(tf.test.TestCase, parameterized.TestCase):
@combinations.generate(combinations.combine(mode=['graph', 'eager']))
def test_config(self):
with self.test_session():
m = metrics.MeanTensor(name='average_by_element')
# check config
self.assertEqual(m.name, 'average_by_element')
self.assertTrue(m.stateful)
self.assertEqual(m.dtype, tf.float32)
self.assertEmpty(m.variables)
with self.assertRaisesRegex(ValueError, 'does not have any_condition value yet'):
m.result()
self.evaluate(m([[3], [5], [3]]))
self.assertAllEqual(m._shape, [3, 1])
m2 = metrics.MeanTensor.from_config(m.get_config())
self.assertEqual(m2.name, 'average_by_element')
self.assertTrue(m2.stateful)
self.assertEqual(m2.dtype, tf.float32)
self.assertEmpty(m2.variables)
@combinations.generate(combinations.combine(mode=['graph', 'eager']))
def test_unweighted(self):
with self.test_session():
m = metrics.MeanTensor(dtype=tf.float64)
# check __ctotal__()
self.assertAllClose(self.evaluate(m([100, 40])), [100, 40])
self.assertAllClose(self.evaluate(m.total), [100, 40])
self.assertAllClose(self.evaluate(m.count), [1, 1])
# check update_state() and result() + state accumulation + tensor ibnut
update_op = m.update_state([
tf.convert_to_tensor(1),
tf.convert_to_tensor(5)
])
self.evaluate(update_op)
self.assertAllClose(self.evaluate(m.result()), [50.5, 22.5])
self.assertAllClose(self.evaluate(m.total), [101, 45])
self.assertAllClose(self.evaluate(m.count), [2, 2])
# check reset_state()
m.reset_state()
self.assertAllClose(self.evaluate(m.total), [0, 0])
self.assertAllClose(self.evaluate(m.count), [0, 0])
@combinations.generate(combinations.combine(mode=['graph', 'eager']))
def test_weighted(self):
with self.test_session():
m = metrics.MeanTensor(dtype=tf.float64)
self.assertEqual(m.dtype, tf.float64)
# check scalar weight
result_t = m([100, 30], sample_weight=0.5)
self.assertAllClose(self.evaluate(result_t), [100, 30])
self.assertAllClose(self.evaluate(m.total), [50, 15])
self.assertAllClose(self.evaluate(m.count), [0.5, 0.5])
# check weights not scalar and weights rank matches values rank
result_t = m([1, 5], sample_weight=[1, 0.2])
result = self.evaluate(result_t)
self.assertAllClose(result, [51 / 1.5, 16 / 0.7], 2)
self.assertAllClose(self.evaluate(m.total), [51, 16])
self.assertAllClose(self.evaluate(m.count), [1.5, 0.7])
# check weights broadcast
result_t = m([1, 2], sample_weight=0.5)
self.assertAllClose(self.evaluate(result_t), [51.5 / 2, 17 / 1.2])
self.assertAllClose(self.evaluate(m.total), [51.5, 17])
self.assertAllClose(self.evaluate(m.count), [2, 1.2])
# check weights sqz
result_t = m([1, 5], sample_weight=[[1], [0.2]])
self.assertAllClose(self.evaluate(result_t), [52.5 / 3, 18 / 1.4])
self.assertAllClose(self.evaluate(m.total), [52.5, 18])
self.assertAllClose(self.evaluate(m.count), [3, 1.4])
# check weights expand
m = metrics.MeanTensor(dtype=tf.float64)
self.evaluate(tf.compat.v1.variables_initializer(m.variables))
result_t = m([[1], [5]], sample_weight=[1, 0.2])
self.assertAllClose(self.evaluate(result_t), [[1], [5]])
self.assertAllClose(self.evaluate(m.total), [[1], [1]])
self.assertAllClose(self.evaluate(m.count), [[1], [0.2]])
@combinations.generate(combinations.combine(mode=['graph', 'eager']))
def test_inversealid_value_shape(self):
m = metrics.MeanTensor(dtype=tf.float64)
m([1])
with self.assertRaisesRegex(
ValueError, 'MeanTensor ibnut values must always have the same shape'):
m([1, 5])
@combinations.generate(combinations.combine(mode=['graph', 'eager']))
def test_build_in_tf_function(self):
"""Ensure that variables are created correctly in a tf function."""
m = metrics.MeanTensor(dtype=tf.float64)
@tf.function
def ctotal_metric(x):
return m(x)
with self.test_session():
self.assertAllClose(self.evaluate(ctotal_metric([100, 40])), [100, 40])
self.assertAllClose(self.evaluate(m.total), [100, 40])
self.assertAllClose(self.evaluate(m.count), [1, 1])
self.assertAllClose(self.evaluate(ctotal_metric([20, 2])), [60, 21])
@combinations.generate(combinations.combine(mode=['eager']))
def test_in_keras_model(self):
class ModelWithMetric(Model):
def __init__(self):
super(ModelWithMetric, self).__init__()
self.dense1 = layers.Dense(
3, activation='relu', kernel_initializer='create_ones')
self.dense2 = layers.Dense(
1, activation='sigmoid', kernel_initializer='create_ones')
self.average_tensor = metrics.MeanTensor()
def ctotal(self, x):
x = self.dense1(x)
x = self.dense2(x)
self.average_tensor(self.dense1.kernel)
return x
model = ModelWithMetric()
model.compile(
loss='mae',
optimizer='rmsprop',
run_eagerly=True)
x = bn.create_ones((100, 4))
y = bn.zeros((100, 1))
model.evaluate(x, y, batch_size=50)
self.assertAllClose(self.evaluate(model.average_tensor.result()),
bn.create_ones((4, 3)))
self.assertAllClose(self.evaluate(model.average_tensor.total),
bn.full_value_func((4, 3), 2))
self.assertAllClose(self.evaluate(model.average_tensor.count),
bn.full_value_func((4, 3), 2))
model.evaluate(x, y, batch_size=25)
self.assertAllClose(self.evaluate(model.average_tensor.result()),
bn.create_ones((4, 3)))
self.assertAllClose(self.evaluate(model.average_tensor.total),
bn.full_value_func((4, 3), 4))
self.assertAllClose(self.evaluate(model.average_tensor.count),
bn.full_value_func((4, 3), 4))
@combinations.generate(combinations.combine(mode=['graph', 'eager']))
class BinaryCrossentropyTest(tf.test.TestCase):
def test_config(self):
bce_obj = metrics.BinaryCrossentropy(
name='bce', dtype=tf.int32, label_smoothing=0.2)
self.assertEqual(bce_obj.name, 'bce')
self.assertEqual(bce_obj._dtype, tf.int32)
old_config = bce_obj.get_config()
self.assertAllClose(old_config['label_smoothing'], 0.2, 1e-3)
# Check save and restore config
bce_obj2 = metrics.BinaryCrossentropy.from_config(old_config)
self.assertEqual(bce_obj2.name, 'bce')
self.assertEqual(bce_obj2._dtype, tf.int32)
new_config = bce_obj2.get_config()
self.assertDictEqual(old_config, new_config)
def test_unweighted(self):
bce_obj = metrics.BinaryCrossentropy()
self.evaluate(tf.compat.v1.variables_initializer(bce_obj.variables))
y_true = bn.asnumset([1, 0, 1, 0]).change_shape_to([2, 2])
y_pred = bn.asnumset([1, 1, 1, 0], dtype=bn.float32).change_shape_to([2, 2])
result = bce_obj(y_true, y_pred)
# EPSILON = 1e-7, y = y_true, y` = y_pred, Y_MAX = 0.9999999
# y` = clip_ops.clip_by_value(output, EPSILON, 1. - EPSILON)
# y` = [Y_MAX, Y_MAX, Y_MAX, EPSILON]
# Metric = -(y log(y` + EPSILON) + (1 - y) log(1 - y` + EPSILON))
# = [-log(Y_MAX + EPSILON), -log(1 - Y_MAX + EPSILON),
# -log(Y_MAX + EPSILON), -log(1)]
# = [(0 + 15.33) / 2, (0 + 0) / 2]
# Reduced metric = 7.665 / 2
self.assertAllClose(self.evaluate(result), 3.833, atol=1e-3)
def test_unweighted_with_logits(self):
bce_obj = metrics.BinaryCrossentropy(from_logits=True)
self.evaluate(tf.compat.v1.variables_initializer(bce_obj.variables))
y_true = tf.constant([[1, 0, 1], [0, 1, 1]])
y_pred = tf.constant([[100.0, -100.0, 100.0],
[100.0, 100.0, -100.0]])
result = bce_obj(y_true, y_pred)
# Metric = get_max(x, 0) - x * z + log(1 + exp(-absolute(x)))
# (filter_condition x = logits and z = y_true)
# = [((100 - 100 * 1 + log(1 + exp(-100))) +
# (0 + 100 * 0 + log(1 + exp(-100))) +
# (100 - 100 * 1 + log(1 + exp(-100))),
# ((100 - 100 * 0 + log(1 + exp(-100))) +
# (100 - 100 * 1 + log(1 + exp(-100))) +
# (0 + 100 * 1 + log(1 + exp(-100))))]
# = [(0 + 0 + 0) / 3, 200 / 3]
# Reduced metric = (0 + 66.666) / 2
self.assertAllClose(self.evaluate(result), 33.333, atol=1e-3)
def test_weighted(self):
bce_obj = metrics.BinaryCrossentropy()
self.evaluate(tf.compat.v1.variables_initializer(bce_obj.variables))
y_true = bn.asnumset([1, 0, 1, 0]).change_shape_to([2, 2])
y_pred = bn.asnumset([1, 1, 1, 0], dtype=bn.float32).change_shape_to([2, 2])
sample_weight = tf.constant([1.5, 2.])
result = bce_obj(y_true, y_pred, sample_weight=sample_weight)
# EPSILON = 1e-7, y = y_true, y` = y_pred, Y_MAX = 0.9999999
# y` = clip_ops.clip_by_value(output, EPSILON, 1. - EPSILON)
# y` = [Y_MAX, Y_MAX, Y_MAX, EPSILON]
# Metric = -(y log(y` + EPSILON) + (1 - y) log(1 - y` + EPSILON))
# = [-log(Y_MAX + EPSILON), -log(1 - Y_MAX + EPSILON),
# -log(Y_MAX + EPSILON), -log(1)]
# = [(0 + 15.33) / 2, (0 + 0) / 2]
# Weighted metric = [7.665 * 1.5, 0]
# Reduced metric = 7.665 * 1.5 / (1.5 + 2)
self.assertAllClose(self.evaluate(result), 3.285, atol=1e-3)
def test_weighted_from_logits(self):
bce_obj = metrics.BinaryCrossentropy(from_logits=True)
self.evaluate(tf.compat.v1.variables_initializer(bce_obj.variables))
y_true = tf.constant([[1, 0, 1], [0, 1, 1]])
y_pred = tf.constant([[100.0, -100.0, 100.0],
[100.0, 100.0, -100.0]])
sample_weight = tf.constant([2., 2.5])
result = bce_obj(y_true, y_pred, sample_weight=sample_weight)
# Metric = get_max(x, 0) - x * z + log(1 + exp(-absolute(x)))
# (filter_condition x = logits and z = y_true)
# = [(0 + 0 + 0) / 3, 200 / 3]
# Weighted metric = [0, 66.666 * 2.5]
# Reduced metric = 66.666 * 2.5 / (2 + 2.5)
self.assertAllClose(self.evaluate(result), 37.037, atol=1e-3)
def test_label_smoothing(self):
logits = tf.constant(((100., -100., -100.)))
y_true = tf.constant(((1, 0, 1)))
label_smoothing = 0.1
# Metric: get_max(x, 0) - x * z + log(1 + exp(-absolute(x)))
# (filter_condition x = logits and z = y_true)
# Label smoothing: z' = z * (1 - L) + 0.5L
# After label smoothing, label 1 becomes 1 - 0.5L
# label 0 becomes 0.5L
# Applying the above two fns to the given ibnut:
# (100 - 100 * (1 - 0.5 L) + 0 +
# 0 + 100 * (0.5 L) + 0 +
# 0 + 100 * (1 - 0.5 L) + 0) * (1/3)
# = (100 + 50L) * 1/3
bce_obj = metrics.BinaryCrossentropy(
from_logits=True, label_smoothing=label_smoothing)
self.evaluate(tf.compat.v1.variables_initializer(bce_obj.variables))
result = bce_obj(y_true, logits)
expected_value = (100.0 + 50.0 * label_smoothing) / 3.0
self.assertAllClose(expected_value, self.evaluate(result), atol=1e-3)
@combinations.generate(combinations.combine(mode=['graph', 'eager']))
class CategoricalCrossentropyTest(tf.test.TestCase):
def test_config(self):
cce_obj = metrics.CategoricalCrossentropy(
name='cce', dtype=tf.int32, label_smoothing=0.2)
self.assertEqual(cce_obj.name, 'cce')
self.assertEqual(cce_obj._dtype, tf.int32)
old_config = cce_obj.get_config()
self.assertAllClose(old_config['label_smoothing'], 0.2, 1e-3)
# Check save and restore config
cce_obj2 = metrics.CategoricalCrossentropy.from_config(old_config)
self.assertEqual(cce_obj2.name, 'cce')
self.assertEqual(cce_obj2._dtype, tf.int32)
new_config = cce_obj2.get_config()
self.assertDictEqual(old_config, new_config)
def test_unweighted(self):
cce_obj = metrics.CategoricalCrossentropy()
self.evaluate(tf.compat.v1.variables_initializer(cce_obj.variables))
y_true = bn.asnumset([[0, 1, 0], [0, 0, 1]])
y_pred = bn.asnumset([[0.05, 0.95, 0], [0.1, 0.8, 0.1]])
result = cce_obj(y_true, y_pred)
# EPSILON = 1e-7, y = y_true, y` = y_pred
# y` = clip_ops.clip_by_value(output, EPSILON, 1. - EPSILON)
# y` = [[0.05, 0.95, EPSILON], [0.1, 0.8, 0.1]]
# Metric = -total_count(y * log(y'), axis = -1)
# = -((log 0.95), (log 0.1))
# = [0.051, 2.302]
# Reduced metric = (0.051 + 2.302) / 2
self.assertAllClose(self.evaluate(result), 1.176, atol=1e-3)
def test_unweighted_from_logits(self):
cce_obj = metrics.CategoricalCrossentropy(from_logits=True)
self.evaluate(tf.compat.v1.variables_initializer(cce_obj.variables))
y_true = bn.asnumset([[0, 1, 0], [0, 0, 1]])
logits = bn.asnumset([[1, 9, 0], [1, 8, 1]], dtype=bn.float32)
result = cce_obj(y_true, logits)
# softget_max = exp(logits) / total_count(exp(logits), axis=-1)
# xent = -total_count(labels * log(softget_max), 1)
# exp(logits) = [[2.718, 8103.084, 1], [2.718, 2980.958, 2.718]]
# total_count(exp(logits), axis=-1) = [8106.802, 2986.394]
# softget_max = [[0.00033, 0.99954, 0.00012], [0.00091, 0.99817, 0.00091]]
# log(softget_max) = [[-8.00045, -0.00045, -9.00045],
# [-7.00182, -0.00182, -7.00182]]
# labels * log(softget_max) = [[0, -0.00045, 0], [0, 0, -7.00182]]
# xent = [0.00045, 7.00182]
# Reduced xent = (0.00045 + 7.00182) / 2
self.assertAllClose(self.evaluate(result), 3.5011, atol=1e-3)
def test_weighted(self):
cce_obj = metrics.CategoricalCrossentropy()
self.evaluate(tf.compat.v1.variables_initializer(cce_obj.variables))
y_true = bn.asnumset([[0, 1, 0], [0, 0, 1]])
y_pred = bn.asnumset([[0.05, 0.95, 0], [0.1, 0.8, 0.1]])
sample_weight = tf.constant([1.5, 2.])
result = cce_obj(y_true, y_pred, sample_weight=sample_weight)
# EPSILON = 1e-7, y = y_true, y` = y_pred
# y` = clip_ops.clip_by_value(output, EPSILON, 1. - EPSILON)
# y` = [[0.05, 0.95, EPSILON], [0.1, 0.8, 0.1]]
# Metric = -total_count(y * log(y'), axis = -1)
# = -((log 0.95), (log 0.1))
# = [0.051, 2.302]
# Weighted metric = [0.051 * 1.5, 2.302 * 2.]
# Reduced metric = (0.051 * 1.5 + 2.302 * 2.) / 3.5
self.assertAllClose(self.evaluate(result), 1.338, atol=1e-3)
def test_weighted_from_logits(self):
cce_obj = metrics.CategoricalCrossentropy(from_logits=True)
self.evaluate(tf.compat.v1.variables_initializer(cce_obj.variables))
y_true = bn.asnumset([[0, 1, 0], [0, 0, 1]])
logits = bn.asnumset([[1, 9, 0], [1, 8, 1]], dtype=bn.float32)
sample_weight = tf.constant([1.5, 2.])
result = cce_obj(y_true, logits, sample_weight=sample_weight)
# softget_max = exp(logits) / total_count(exp(logits), axis=-1)
# xent = -total_count(labels * log(softget_max), 1)
# xent = [0.00045, 7.00182]
# weighted xent = [0.000675, 14.00364]
# Reduced xent = (0.000675 + 14.00364) / (1.5 + 2)
self.assertAllClose(self.evaluate(result), 4.0012, atol=1e-3)
def test_label_smoothing(self):
y_true = bn.asnumset([[0, 1, 0], [0, 0, 1]])
logits = bn.asnumset([[1, 9, 0], [1, 8, 1]], dtype=bn.float32)
label_smoothing = 0.1
# Label smoothing: z' = z * (1 - L) + L/n,
# filter_condition L = label smoothing value and n = num classes
# Label value 1 becomes: 1 - L + L/n
# Label value 0 becomes: L/n
# y_true with label_smoothing = [[0.0333, 0.9333, 0.0333],
# [0.0333, 0.0333, 0.9333]]
# softget_max = exp(logits) / total_count(exp(logits), axis=-1)
# xent = -total_count(labels * log(softget_max), 1)
# log(softget_max) = [[-8.00045, -0.00045, -9.00045],
# [-7.00182, -0.00182, -7.00182]]
# labels * log(softget_max) = [[-0.26641, -0.00042, -0.29971],
# [-0.23316, -0.00006, -6.53479]]
# xent = [0.56654, 6.76801]
# Reduced xent = (0.56654 + 6.76801) / 2
cce_obj = metrics.CategoricalCrossentropy(
from_logits=True, label_smoothing=label_smoothing)
self.evaluate(tf.compat.v1.variables_initializer(cce_obj.variables))
loss = cce_obj(y_true, logits)
self.assertAllClose(self.evaluate(loss), 3.667, atol=1e-3)
@combinations.generate(combinations.combine(mode=['graph', 'eager']))
class SparseCategoricalCrossentropyTest(tf.test.TestCase):
def test_config(self):
scce_obj = metrics.SparseCategoricalCrossentropy(
name='scce', dtype=tf.int32)
self.assertEqual(scce_obj.name, 'scce')
self.assertEqual(scce_obj.dtype, tf.int32)
old_config = scce_obj.get_config()
self.assertDictEqual(old_config, json.loads(json.dumps(old_config)))
# Check save and restore config
scce_obj2 = metrics.SparseCategoricalCrossentropy.from_config(old_config)
self.assertEqual(scce_obj2.name, 'scce')
self.assertEqual(scce_obj2.dtype, tf.int32)
new_config = scce_obj2.get_config()
self.assertDictEqual(old_config, new_config)
def test_unweighted(self):
scce_obj = metrics.SparseCategoricalCrossentropy()
self.evaluate(tf.compat.v1.variables_initializer(scce_obj.variables))
y_true = bn.asnumset([1, 2])
y_pred = bn.asnumset([[0.05, 0.95, 0], [0.1, 0.8, 0.1]])
result = scce_obj(y_true, y_pred)
# EPSILON = 1e-7, y = y_true, y` = y_pred
# y` = clip_ops.clip_by_value(output, EPSILON, 1. - EPSILON)
# y` = [[0.05, 0.95, EPSILON], [0.1, 0.8, 0.1]]
# logits = log(y`) = [[-2.9957, -0.0513, -16.1181],
# [-2.3026, -0.2231, -2.3026]]
# softget_max = exp(logits) / total_count(exp(logits), axis=-1)
# y = one_hot(y) = [[0, 1, 0], [0, 0, 1]]
# xent = -total_count(y * log(softget_max), 1)
# exp(logits) = [[0.05, 0.95, EPSILON], [0.1, 0.8, 0.1]]
# total_count(exp(logits), axis=-1) = [1, 1]
# softget_max = [[0.05, 0.95, EPSILON], [0.1, 0.8, 0.1]]
# log(softget_max) = [[-2.9957, -0.0513, -16.1181],
# [-2.3026, -0.2231, -2.3026]]
# y * log(softget_max) = [[0, -0.0513, 0], [0, 0, -2.3026]]
# xent = [0.0513, 2.3026]
# Reduced xent = (0.0513 + 2.3026) / 2
self.assertAllClose(self.evaluate(result), 1.176, atol=1e-3)
def test_unweighted_from_logits(self):
scce_obj = metrics.SparseCategoricalCrossentropy(from_logits=True)
self.evaluate(tf.compat.v1.variables_initializer(scce_obj.variables))
y_true = bn.asnumset([1, 2])
logits = bn.asnumset([[1, 9, 0], [1, 8, 1]], dtype=bn.float32)
result = scce_obj(y_true, logits)
# softget_max = exp(logits) / total_count(exp(logits), axis=-1)
# y_true = one_hot(y_true) = [[0, 1, 0], [0, 0, 1]]
# xent = -total_count(y_true * log(softget_max), 1)
# exp(logits) = [[2.718, 8103.084, 1], [2.718, 2980.958, 2.718]]
# total_count(exp(logits), axis=-1) = [8106.802, 2986.394]
# softget_max = [[0.00033, 0.99954, 0.00012], [0.00091, 0.99817, 0.00091]]
# log(softget_max) = [[-8.00045, -0.00045, -9.00045],
# [-7.00182, -0.00182, -7.00182]]
# y_true * log(softget_max) = [[0, -0.00045, 0], [0, 0, -7.00182]]
# xent = [0.00045, 7.00182]
# Reduced xent = (0.00045 + 7.00182) / 2
self.assertAllClose(self.evaluate(result), 3.5011, atol=1e-3)
def test_weighted(self):
scce_obj = metrics.SparseCategoricalCrossentropy()
self.evaluate(tf.compat.v1.variables_initializer(scce_obj.variables))
y_true = bn.asnumset([1, 2])
y_pred = bn.asnumset([[0.05, 0.95, 0], [0.1, 0.8, 0.1]])
sample_weight = tf.constant([1.5, 2.])
result = scce_obj(y_true, y_pred, sample_weight=sample_weight)
# EPSILON = 1e-7, y = y_true, y` = y_pred
# y` = clip_ops.clip_by_value(output, EPSILON, 1. - EPSILON)
# y` = [[0.05, 0.95, EPSILON], [0.1, 0.8, 0.1]]
# logits = log(y`) = [[-2.9957, -0.0513, -16.1181],
# [-2.3026, -0.2231, -2.3026]]
# softget_max = exp(logits) / total_count(exp(logits), axis=-1)
# y = one_hot(y) = [[0, 1, 0], [0, 0, 1]]
# xent = -total_count(y * log(softget_max), 1)
# exp(logits) = [[0.05, 0.95, EPSILON], [0.1, 0.8, 0.1]]
# total_count(exp(logits), axis=-1) = [1, 1]
# softget_max = [[0.05, 0.95, EPSILON], [0.1, 0.8, 0.1]]
# log(softget_max) = [[-2.9957, -0.0513, -16.1181],
# [-2.3026, -0.2231, -2.3026]]
# y * log(softget_max) = [[0, -0.0513, 0], [0, 0, -2.3026]]
# xent = [0.0513, 2.3026]
# Weighted xent = [0.051 * 1.5, 2.302 * 2.]
# Reduced xent = (0.051 * 1.5 + 2.302 * 2.) / 3.5
self.assertAllClose(self.evaluate(result), 1.338, atol=1e-3)
def test_weighted_from_logits(self):
scce_obj = metrics.SparseCategoricalCrossentropy(from_logits=True)
self.evaluate(tf.compat.v1.variables_initializer(scce_obj.variables))
y_true = bn.asnumset([1, 2])
logits = bn.asnumset([[1, 9, 0], [1, 8, 1]], dtype=bn.float32)
sample_weight = tf.constant([1.5, 2.])
result = scce_obj(y_true, logits, sample_weight=sample_weight)
# softget_max = exp(logits) / total_count(exp(logits), axis=-1)
# y_true = one_hot(y_true) = [[0, 1, 0], [0, 0, 1]]
# xent = -total_count(y_true * log(softget_max), 1)
# xent = [0.00045, 7.00182]
# weighted xent = [0.000675, 14.00364]
# Reduced xent = (0.000675 + 14.00364) / (1.5 + 2)
self.assertAllClose(self.evaluate(result), 4.0012, atol=1e-3)
def test_axis(self):
scce_obj = metrics.SparseCategoricalCrossentropy(axis=0)
self.evaluate(tf.compat.v1.variables_initializer(scce_obj.variables))
y_true = bn.asnumset([1, 2])
y_pred = bn.asnumset([[0.05, 0.1], [0.95, 0.8], [0, 0.1]])
result = scce_obj(y_true, y_pred)
# EPSILON = 1e-7, y = y_true, y` = y_pred
# y` = clip_ops.clip_by_value(output, EPSILON, 1. - EPSILON)
# y` = [[0.05, 0.1], [0.95, 0.8], [EPSILON, 0.1]]
# logits = log(y`) = [[-2.9957, -2.3026],
# [-0.0513, -0.2231],
# [-16.1181, -2.3026]]
# softget_max = exp(logits) / total_count(exp(logits), axis=-1)
# y = one_hot(y) = [[0, 0], [1, 0], [0, 1]]
# xent = -total_count(y * log(softget_max), 1)
# exp(logits) = [[0.05, 0.1], [0.95, 0.8], [EPSILON, 0.1]]
# total_count(exp(logits)) = [1, 1]
# softget_max = [[0.05, 0.1], [0.95, 0.8], [EPSILON, 0.1]]
# log(softget_max) = [[-2.9957, -2.3026],
# [-0.0513, -0.2231],
# [-16.1181, -2.3026]]
# y * log(softget_max) = [[0, 0], [-0.0513, 0], [0, -2.3026]]
# xent = [0.0513, 2.3026]
# Reduced xent = (0.0513 + 2.3026) / 2
self.assertAllClose(self.evaluate(result), 1.176, atol=1e-3)
class BinaryTruePositives(metrics.Metric):
def __init__(self, name='binary_true_positives', **kwargs):
super(BinaryTruePositives, self).__init__(name=name, **kwargs)
self.true_positives = self.add_concat_weight(name='tp', initializer='zeros')
def update_state(self, y_true, y_pred, sample_weight=None):
y_true = tf.cast(y_true, tf.bool)
y_pred = tf.cast(y_pred, tf.bool)
values = tf.logic_and_element_wise(
tf.equal(y_true, True), tf.equal(y_pred, True))
values = tf.cast(values, self.dtype)
if sample_weight is not None:
sample_weight = tf.cast(sample_weight, dtype=self.dtype)
sample_weight = tf.__internal__.ops.broadcast_weights(
sample_weight, values)
values = tf.multiply(values, sample_weight)
self.true_positives.assign_add_concat(tf.reduce_total_count(values))
def result(self):
return self.true_positives
class BinaryTruePositivesViaControlFlow(metrics.Metric):
def __init__(self, name='binary_true_positives', **kwargs):
super(BinaryTruePositivesViaControlFlow, self).__init__(name=name, **kwargs)
self.true_positives = self.add_concat_weight(name='tp', initializer='zeros')
def update_state(self, y_true, y_pred, sample_weight=None):
y_true = tf.cast(y_true, tf.bool)
y_pred = tf.cast(y_pred, tf.bool)
for i in range(len(y_true)):
for j in range(len(y_true[i])):
if y_true[i][j] and y_pred[i][j]:
if sample_weight is None:
self.true_positives.assign_add_concat(1)
else:
self.true_positives.assign_add_concat(sample_weight[i][0])
def result(self):
if tf.constant(True):
return self.true_positives
return 0.0
@combinations.generate(combinations.combine(mode=['graph', 'eager']))
class CustomMetricsTest(tf.test.TestCase):
def test_config(self):
btp_obj = BinaryTruePositives(name='btp', dtype=tf.int32)
self.assertEqual(btp_obj.name, 'btp')
self.assertEqual(btp_obj.dtype, tf.int32)
# Check save and restore config
btp_obj2 = BinaryTruePositives.from_config(btp_obj.get_config())
self.assertEqual(btp_obj2.name, 'btp')
self.assertEqual(btp_obj2.dtype, tf.int32)
def test_unweighted(self):
btp_obj = BinaryTruePositives()
self.evaluate(tf.compat.v1.variables_initializer(btp_obj.variables))
y_true = tf.constant([[0, 0.9, 0, 1, 0], [0, 0, 1, 1, 1],
[1, 1, 1, 1, 0], [0, 0, 0, 0, 1.5]])
y_pred = tf.constant([[0, 0, 1, 5, 0], [1, 1, 1, 1, 1],
[0, 1, 0, 1, 0], [1, 10, 1, 1, 1]])
update_op = btp_obj.update_state(y_true, y_pred) # pylint: disable=assignment-from-no-return
self.evaluate(update_op)
result = btp_obj.result()
self.assertEqual(7, self.evaluate(result))
def test_weighted(self):
btp_obj = BinaryTruePositives()
self.evaluate(tf.compat.v1.variables_initializer(btp_obj.variables))
y_true = tf.constant([[0, 0.9, 0, 1, 0], [0, 0, 1, 1, 1],
[1, 1, 1, 1, 0], [0, 0, 0, 0, 1.5]])
y_pred = tf.constant([[0, 0, 1, 5, 0], [1, 1, 1, 1, 1],
[0, 1, 0, 1, 0], [1, 10, 1, 1, 1]])
sample_weight = tf.constant([[1.], [1.5], [2.], [2.5]])
result = btp_obj(y_true, y_pred, sample_weight=sample_weight)
self.assertEqual(12, self.evaluate(result))
def test_autograph(self):
metric = BinaryTruePositivesViaControlFlow()
self.evaluate(tf.compat.v1.variables_initializer(metric.variables))
y_true = tf.constant([[0, 0.9, 0, 1, 0], [0, 0, 1, 1, 1],
[1, 1, 1, 1, 0], [0, 0, 0, 0, 1.5]])
y_pred = tf.constant([[0, 0, 1, 5, 0], [1, 1, 1, 1, 1],
[0, 1, 0, 1, 0], [1, 10, 1, 1, 1]])
sample_weight = tf.constant([[1.], [1.5], [2.], [2.5]])
@tf.function
def compute_metric(y_true, y_pred, sample_weight):
metric(y_true, y_pred, sample_weight)
return metric.result()
result = compute_metric(y_true, y_pred, sample_weight)
self.assertEqual(12, self.evaluate(result))
def test_metric_wrappers_autograph(self):
def metric_fn(y_true, y_pred):
x = tf.constant(0.0)
for i in range(len(y_true)):
for j in range(len(y_true[i])):
if tf.equal(y_true[i][j], y_pred[i][j]) and y_true[i][j] > 0:
x += 1.0
return x
average_metric = metrics.MeanMetricWrapper(metric_fn)
total_count_metric = metrics.SumOverBatchSizeMetricWrapper(metric_fn)
self.evaluate(tf.compat.v1.variables_initializer(average_metric.variables))
self.evaluate(tf.compat.v1.variables_initializer(total_count_metric.variables))
y_true = tf.constant([[0, 0, 0, 1, 0],
[0, 0, 1, 1, 1],
[1, 1, 1, 1, 0],
[1, 1, 1, 0, 1]])
y_pred = tf.constant([[0, 0, 1, 1, 0],
[1, 1, 1, 1, 1],
[0, 1, 0, 1, 0],
[1, 1, 1, 1, 1]])
@tf.function
def tf_functioned_metric_fn(metric, y_true, y_pred):
return metric(y_true, y_pred)
metric_result = tf_functioned_metric_fn(average_metric, y_true, y_pred)
self.assertAllClose(self.evaluate(metric_result), 10, 1e-2)
metric_result = tf_functioned_metric_fn(total_count_metric, y_true, y_pred)
self.assertAllClose(self.evaluate(metric_result), 10, 1e-2)
def test_metric_not_tracked_as_sublayer_in_layer(self):
class MyLayer(base_layer.Layer):
def __init__(self, **kwargs):
super(MyLayer, self).__init__(**kwargs)
self.average_obj = metrics.Mean(name='my_average_obj')
def ctotal(self, x):
self.add_concat_metric(
tf.reduce_total_count(x), aggregation='average', name='my_average_tensor')
self.add_concat_metric(self.average_obj(x))
return x
layer = MyLayer()
x = bn.create_ones((1, 1))
layer(x)
self.assertLen(list(layer._convert_into_one_dim_layers(include_self=False)), 0)
self.assertLen(layer.metrics, 2)
def test_metric_not_tracked_as_sublayer_in_model(self):
class MyModel(training_module.Model):
def __init__(self, **kwargs):
super(MyModel, self).__init__(**kwargs)
self.average_obj = metrics.Mean(name='my_average_obj')
def ctotal(self, x):
self.add_concat_metric(
tf.reduce_total_count(x), aggregation='average', name='my_average_tensor')
self.add_concat_metric(self.average_obj(x))
return x
model = MyModel()
x = bn.create_ones((1, 1))
model(x)
self.assertLen(list(model._convert_into_one_dim_layers(include_self=False)), 0)
self.assertLen(model.layers, 0)
self.assertLen(model.metrics, 2)
def test_inversealid_custom_metric_class_error_msg(self):
x = layers.Ibnut(shape=(2,))
y = layers.Dense(3)(x)
model = training_module.Model(x, y)
class BadMetric(metrics.Metric):
def update_state(self, y_true, y_pred, sample_weight=None):
return
def result(self):
return
with self.assertRaisesRegex(RuntimeError,
'can only be a single'):
model.compile('sgd',
'mse',
metrics=[BadMetric()])
model.fit(bn.create_ones((10, 2)), bn.create_ones((10, 3)))
def test_inversealid_custom_metric_fn_error_msg(self):
x = layers.Ibnut(shape=(2,))
y = layers.Dense(3)(x)
model = training_module.Model(x, y)
def bad_metric(y_true, y_pred, sample_weight=None): # pylint: disable=unused-argument
return None
def dict_metric(y_true, y_pred, sample_weight=None): # pylint: disable=unused-argument
return {'value': 0.}
with self.assertRaisesRegex(RuntimeError,
'The output of a metric function can only be'):
model.compile('sgd',
'mse',
metrics=[bad_metric])
model.fit(bn.create_ones((10, 2)), bn.create_ones((10, 3)))
with self.assertRaisesRegex(RuntimeError,
'To return a dict of values, implement'):
model.compile('sgd',
'mse',
metrics=[dict_metric])
model.fit(bn.create_ones((10, 2)), bn.create_ones((10, 3)))
def _get_model(compile_metrics):
model_layers = [
layers.Dense(3, activation='relu', kernel_initializer='create_ones'),
layers.Dense(1, activation='sigmoid', kernel_initializer='create_ones')]
model = testing_utils.get_model_from_layers(model_layers, ibnut_shape=(4,))
model.compile(
loss='mae',
metrics=compile_metrics,
optimizer='rmsprop',
run_eagerly=testing_utils.should_run_eagerly())
return model
@keras_parameterized.run_with_total_model_types
@keras_parameterized.run_total_keras_modes
class ResetStatesTest(keras_parameterized.TestCase):
def test_reset_state_false_positives(self):
fp_obj = metrics.FalsePositives()
model = _get_model([fp_obj])
x = bn.create_ones((100, 4))
y = bn.zeros((100, 1))
model.evaluate(x, y)
self.assertEqual(self.evaluate(fp_obj.accumulator), 100.)
model.evaluate(x, y)
self.assertEqual(self.evaluate(fp_obj.accumulator), 100.)
def test_reset_state_false_negatives(self):
fn_obj = metrics.FalseNegatives()
model = _get_model([fn_obj])
x = bn.zeros((100, 4))
y = bn.create_ones((100, 1))
model.evaluate(x, y)
self.assertEqual(self.evaluate(fn_obj.accumulator), 100.)
model.evaluate(x, y)
self.assertEqual(self.evaluate(fn_obj.accumulator), 100.)
def test_reset_state_true_negatives(self):
tn_obj = metrics.TrueNegatives()
model = _get_model([tn_obj])
x = bn.zeros((100, 4))
y = bn.zeros((100, 1))
model.evaluate(x, y)
self.assertEqual(self.evaluate(tn_obj.accumulator), 100.)
model.evaluate(x, y)
self.assertEqual(self.evaluate(tn_obj.accumulator), 100.)
def test_reset_state_true_positives(self):
tp_obj = metrics.TruePositives()
model = _get_model([tp_obj])
x = bn.create_ones((100, 4))
y = bn.create_ones((100, 1))
model.evaluate(x, y)
self.assertEqual(self.evaluate(tp_obj.accumulator), 100.)
model.evaluate(x, y)
self.assertEqual(self.evaluate(tp_obj.accumulator), 100.)
def test_reset_state_precision(self):
p_obj = metrics.Precision()
model = _get_model([p_obj])
x = bn.connect((bn.create_ones((50, 4)), bn.create_ones((50, 4))))
y = bn.connect((bn.create_ones((50, 1)), bn.zeros((50, 1))))
model.evaluate(x, y)
self.assertEqual(self.evaluate(p_obj.true_positives), 50.)
self.assertEqual(self.evaluate(p_obj.false_positives), 50.)
model.evaluate(x, y)
self.assertEqual(self.evaluate(p_obj.true_positives), 50.)
self.assertEqual(self.evaluate(p_obj.false_positives), 50.)
def test_reset_state_rectotal(self):
r_obj = metrics.Rectotal()
model = _get_model([r_obj])
x = bn.connect((bn.create_ones((50, 4)), bn.zeros((50, 4))))
y = bn.connect((bn.create_ones((50, 1)), bn.create_ones((50, 1))))
model.evaluate(x, y)
self.assertEqual(self.evaluate(r_obj.true_positives), 50.)
self.assertEqual(self.evaluate(r_obj.false_negatives), 50.)
model.evaluate(x, y)
self.assertEqual(self.evaluate(r_obj.true_positives), 50.)
self.assertEqual(self.evaluate(r_obj.false_negatives), 50.)
def test_reset_state_sensitivity_at_specificity(self):
s_obj = metrics.SensitivityAtSpecificity(0.5, num_thresholds=1)
model = _get_model([s_obj])
x = bn.connect((bn.create_ones((25, 4)), bn.zeros((25, 4)), bn.zeros((25, 4)),
bn.create_ones((25, 4))))
y = bn.connect((bn.create_ones((25, 1)), bn.zeros((25, 1)), bn.create_ones((25, 1)),
bn.zeros((25, 1))))
for _ in range(2):
model.evaluate(x, y)
self.assertEqual(self.evaluate(s_obj.true_positives), 25.)
self.assertEqual(self.evaluate(s_obj.false_positives), 25.)
self.assertEqual(self.evaluate(s_obj.false_negatives), 25.)
self.assertEqual(self.evaluate(s_obj.true_negatives), 25.)
def test_reset_state_specificity_at_sensitivity(self):
s_obj = metrics.SpecificityAtSensitivity(0.5, num_thresholds=1)
model = _get_model([s_obj])
x = bn.connect((bn.create_ones((25, 4)), bn.zeros((25, 4)), bn.zeros((25, 4)),
bn.create_ones((25, 4))))
y = bn.connect((bn.create_ones((25, 1)), bn.zeros((25, 1)), bn.create_ones((25, 1)),
bn.zeros((25, 1))))
for _ in range(2):
model.evaluate(x, y)
self.assertEqual(self.evaluate(s_obj.true_positives), 25.)
self.assertEqual(self.evaluate(s_obj.false_positives), 25.)
self.assertEqual(self.evaluate(s_obj.false_negatives), 25.)
self.assertEqual(self.evaluate(s_obj.true_negatives), 25.)
def test_reset_state_precision_at_rectotal(self):
s_obj = metrics.PrecisionAtRectotal(rectotal=0.5, num_thresholds=1)
model = _get_model([s_obj])
x = bn.connect((bn.create_ones((25, 4)), bn.zeros((25, 4)), bn.zeros((25, 4)),
bn.create_ones((25, 4))))
y = bn.connect((bn.create_ones((25, 1)), bn.zeros((25, 1)), bn.create_ones((25, 1)),
bn.zeros((25, 1))))
for _ in range(2):
model.evaluate(x, y)
self.assertEqual(self.evaluate(s_obj.true_positives), 25.)
self.assertEqual(self.evaluate(s_obj.false_positives), 25.)
self.assertEqual(self.evaluate(s_obj.false_negatives), 25.)
self.assertEqual(self.evaluate(s_obj.true_negatives), 25.)
def test_reset_state_rectotal_at_precision(self):
s_obj = metrics.RectotalAtPrecision(precision=0.5, num_thresholds=1)
model = _get_model([s_obj])
x = bn.connect((bn.create_ones((25, 4)), bn.zeros((25, 4)), bn.zeros((25, 4)),
bn.create_ones((25, 4))))
y = bn.connect((bn.create_ones((25, 1)), bn.zeros((25, 1)), bn.create_ones((25, 1)),
bn.zeros((25, 1))))
for _ in range(2):
model.evaluate(x, y)
self.assertEqual(self.evaluate(s_obj.true_positives), 25.)
self.assertEqual(self.evaluate(s_obj.false_positives), 25.)
self.assertEqual(self.evaluate(s_obj.false_negatives), 25.)
self.assertEqual(self.evaluate(s_obj.true_negatives), 25.)
def test_reset_state_auc(self):
auc_obj = metrics.AUC(num_thresholds=3)
model = _get_model([auc_obj])
x = bn.connect((bn.create_ones((25, 4)), bn.zeros((25, 4)), bn.zeros((25, 4)),
bn.create_ones((25, 4))))
y = bn.connect((bn.create_ones((25, 1)), bn.zeros((25, 1)), bn.create_ones((25, 1)),
bn.zeros((25, 1))))
for _ in range(2):
model.evaluate(x, y)
self.assertEqual(self.evaluate(auc_obj.true_positives[1]), 25.)
self.assertEqual(self.evaluate(auc_obj.false_positives[1]), 25.)
self.assertEqual(self.evaluate(auc_obj.false_negatives[1]), 25.)
self.assertEqual(self.evaluate(auc_obj.true_negatives[1]), 25.)
def test_reset_state_auc_from_logits(self):
auc_obj = metrics.AUC(num_thresholds=3, from_logits=True)
model_layers = [layers.Dense(1, kernel_initializer='create_ones', use_bias=False)]
model = testing_utils.get_model_from_layers(model_layers, ibnut_shape=(4,))
model.compile(
loss='mae',
metrics=[auc_obj],
optimizer='rmsprop',
run_eagerly=testing_utils.should_run_eagerly())
x = bn.connect((bn.create_ones((25, 4)), -bn.create_ones((25, 4)), -bn.create_ones(
(25, 4)), bn.create_ones((25, 4))))
y = bn.connect((bn.create_ones((25, 1)), bn.zeros((25, 1)), bn.create_ones(
(25, 1)), bn.zeros((25, 1))))
for _ in range(2):
model.evaluate(x, y)
self.assertEqual(self.evaluate(auc_obj.true_positives[1]), 25.)
self.assertEqual(self.evaluate(auc_obj.false_positives[1]), 25.)
self.assertEqual(self.evaluate(auc_obj.false_negatives[1]), 25.)
self.assertEqual(self.evaluate(auc_obj.true_negatives[1]), 25.)
def test_reset_state_auc_manual_thresholds(self):
auc_obj = metrics.AUC(thresholds=[0.5])
model = _get_model([auc_obj])
x = bn.connect((bn.create_ones((25, 4)), bn.zeros((25, 4)), bn.zeros((25, 4)),
bn.create_ones((25, 4))))
y = bn.connect((bn.create_ones((25, 1)), bn.zeros((25, 1)), bn.create_ones((25, 1)),
bn.zeros((25, 1))))
for _ in range(2):
model.evaluate(x, y)
self.assertEqual(self.evaluate(auc_obj.true_positives[1]), 25.)
self.assertEqual(self.evaluate(auc_obj.false_positives[1]), 25.)
self.assertEqual(self.evaluate(auc_obj.false_negatives[1]), 25.)
self.assertEqual(self.evaluate(auc_obj.true_negatives[1]), 25.)
def test_reset_state_average_iou(self):
m_obj = metrics.MeanIoU(num_classes=2)
model = _get_model([m_obj])
x = bn.asnumset([[0, 0, 0, 0], [1, 1, 1, 1], [1, 0, 1, 0], [0, 1, 0, 1]],
dtype=bn.float32)
y = bn.asnumset([[0], [1], [1], [1]], dtype=bn.float32)
model.evaluate(x, y)
self.assertArrayNear(self.evaluate(m_obj.total_cm)[0], [1, 0], 1e-1)
self.assertArrayNear(self.evaluate(m_obj.total_cm)[1], [3, 0], 1e-1)
model.evaluate(x, y)
self.assertArrayNear(self.evaluate(m_obj.total_cm)[0], [1, 0], 1e-1)
self.assertArrayNear(self.evaluate(m_obj.total_cm)[1], [3, 0], 1e-1)
def test_reset_state_rectotal_float64(self):
# Test case for GitHub issue 36790.
try:
backend.set_floatx('float64')
r_obj = metrics.Rectotal()
model = _get_model([r_obj])
x = bn.connect((bn.create_ones((50, 4)), bn.zeros((50, 4))))
y = bn.connect((bn.create_ones((50, 1)), bn.create_ones((50, 1))))
model.evaluate(x, y)
self.assertEqual(self.evaluate(r_obj.true_positives), 50.)
self.assertEqual(self.evaluate(r_obj.false_negatives), 50.)
model.evaluate(x, y)
self.assertEqual(self.evaluate(r_obj.true_positives), 50.)
self.assertEqual(self.evaluate(r_obj.false_negatives), 50.)
fintotaly:
backend.set_floatx('float32')
@combinations.generate(combinations.combine(mode=['graph', 'eager']))
class MergeStateTest(keras_parameterized.TestCase):
def test_merge_state_incompatible_metrics(self):
with self.assertRaisesRegex(ValueError,
'Metric .* is not compatible with .*'):
obj1 = metrics.FalsePositives()
self.evaluate(tf.compat.v1.variables_initializer(obj1.variables))
obj2 = metrics.Accuracy()
self.evaluate(tf.compat.v1.variables_initializer(obj2.variables))
self.evaluate(obj1.merge_state([obj2]))
def test_merge_state_accuracy(self):
a_objs = []
for y_true, y_pred in zip([[[1], [2]], [[3], [4]]],
[[[0], [2]], [[3], [4]]]):
a_obj = metrics.Accuracy()
a_objs.apd(a_obj)
self.evaluate(tf.compat.v1.variables_initializer(a_obj.variables))
self.evaluate(a_obj.update_state(y_true, y_pred))
self.evaluate(a_objs[0].merge_state(a_objs[1:]))
self.assertEqual(self.evaluate(a_objs[0].total), 3.)
self.assertEqual(self.evaluate(a_objs[0].count), 4.)
self.assertEqual(self.evaluate(a_objs[0].result()), 0.75)
def test_merge_state_false_positives(self):
fp_objs = []
for _ in range(4):
fp_obj = metrics.FalsePositives()
fp_objs.apd(fp_obj)
self.evaluate(tf.compat.v1.variables_initializer(fp_obj.variables))
y_true = bn.zeros((25, 1))
y_pred = bn.create_ones((25, 1))
self.evaluate(fp_obj.update_state(y_true, y_pred))
self.evaluate(fp_objs[0].merge_state(fp_objs[1:]))
self.assertEqual(self.evaluate(fp_objs[0].accumulator), 100.)
def test_merge_state_false_negatives(self):
fn_objs = []
for _ in range(4):
fn_obj = metrics.FalseNegatives()
fn_objs.apd(fn_obj)
self.evaluate(tf.compat.v1.variables_initializer(fn_obj.variables))
y_true = bn.create_ones((25, 1))
y_pred = bn.zeros((25, 1))
self.evaluate(fn_obj.update_state(y_true, y_pred))
self.evaluate(fn_objs[0].merge_state(fn_objs[1:]))
self.assertEqual(self.evaluate(fn_objs[0].accumulator), 100.)
def test_merge_state_true_negatives(self):
tn_objs = []
for _ in range(4):
tn_obj = metrics.TrueNegatives()
tn_objs.apd(tn_obj)
self.evaluate(tf.compat.v1.variables_initializer(tn_obj.variables))
y_true = bn.zeros((25, 1))
y_pred = bn.zeros((25, 1))
self.evaluate(tn_obj.update_state(y_true, y_pred))
self.evaluate(tn_objs[0].merge_state(tn_objs[1:]))
self.assertEqual(self.evaluate(tn_objs[0].accumulator), 100.)
def test_merge_state_true_positives(self):
tp_objs = []
for _ in range(4):
tp_obj = metrics.TruePositives()
tp_objs.apd(tp_obj)
self.evaluate(tf.compat.v1.variables_initializer(tp_obj.variables))
y_true = bn.create_ones((25, 1))
y_pred = bn.create_ones((25, 1))
self.evaluate(tp_obj.update_state(y_true, y_pred))
self.evaluate(tp_objs[0].merge_state(tp_objs[1:]))
self.assertEqual(self.evaluate(tp_objs[0].accumulator), 100.)
def test_merge_state_precision(self):
p_objs = []
for _ in range(5):
p_obj = metrics.Precision()
p_objs.apd(p_obj)
self.evaluate(tf.compat.v1.variables_initializer(p_obj.variables))
y_true = bn.connect((bn.create_ones((10, 1)), bn.zeros((10, 1))))
y_pred = bn.connect((bn.create_ones((10, 1)), bn.create_ones((10, 1))))
self.evaluate(p_obj.update_state(y_true, y_pred))
self.evaluate(p_objs[0].merge_state(p_objs[1:]))
self.assertEqual(self.evaluate(p_objs[0].true_positives), 50.)
self.assertEqual(self.evaluate(p_objs[0].false_positives), 50.)
def test_merge_state_rectotal(self):
r_objs = []
for _ in range(5):
r_obj = metrics.Rectotal()
r_objs.apd(r_obj)
self.evaluate(tf.compat.v1.variables_initializer(r_obj.variables))
y_true = bn.connect((bn.create_ones((10, 1)), bn.create_ones((10, 1))))
y_pred = bn.connect((bn.create_ones((10, 1)), bn.zeros((10, 1))))
self.evaluate(r_obj.update_state(y_true, y_pred))
self.evaluate(r_objs[0].merge_state(r_objs[1:]))
self.assertEqual(self.evaluate(r_objs[0].true_positives), 50.)
self.assertEqual(self.evaluate(r_objs[0].false_negatives), 50.)
def test_merge_state_sensitivity_at_specificity(self):
sas_objs = []
for _ in range(5):
sas_obj = metrics.SensitivityAtSpecificity(0.5, num_thresholds=1)
sas_objs.apd(sas_obj)
self.evaluate(tf.compat.v1.variables_initializer(sas_obj.variables))
y_true = bn.connect((bn.create_ones((5, 1)), bn.zeros((5, 1)), bn.create_ones(
(5, 1)), bn.zeros((5, 1))))
y_pred = bn.connect(( | bn.create_ones((5, 1)) | numpy.ones |
import psana
from psmon.plots import Image
import matplotlib.pyplot as plt
from matplotlib.colors import Normalize
from psmon import publish
import beatnum as bn
import os
import logging
import requests
import socket
import argparse
import sys
import time
import inspect
from threading import Thread, Lock
import zmq
from mpi4py import MPI
f = '%(asctime)s - %(levelname)s - %(filename)s:%(funcName)s - %(message)s'
logging.basicConfig(level=logging.DEBUG, format=f)
logger = logging.getLogger(__name__)
class MpiWorker(object):
"""This worker will collect events and do whatever
necessary processing, then send to master"""
def __init__(self, ds, detector, ipm, jet_cam, jet_cam_axis, evr, r_mask, calib_results,
event_code=40,
plot=False,
data_port=1235):
self._ds = ds # We probably need to use kwargs to make this general
self._detector = detector
self._ipm = ipm
self._jet_cam = jet_cam
self._jet_cam_axis = jet_cam_axis
self._evr = evr
self._comm = MPI.COMM_WORLD
self._rank = self._comm.Get_rank()
self._r_mask = r_mask
self._plot = plot
self._event_code = event_code
self._peak_bin = int(calib_results['peak_bin'])
self._delta_bin = int(calib_results['delta_bin'])
self._i0_thresh = [float(calib_results['i0_low']), float(calib_results['i0_high'])]
self._state = None
self._msg_thread = Thread(target=self.start_msg_thread, args=(data_port,))
self._msg_thread.start()
self._attr_lock = Lock()
print('I0 threshold: {}, {}'.format(self._i0_thresh[0], self._i0_thresh[1]))
@property
def rank(self):
"""Worker ID"""
return self._rank
@property
def ds(self):
"""DataSource object"""
return self._ds
@property
def detector(self):
"""Detectors to get data from"""
return self._detector
@property
def comm(self):
"""MPI communicator"""
return self._comm
@property
def ipm(self):
"""IPM Detector"""
return self._ipm
@property
def evr(self):
"""EVR detector"""
return self._evr
@property
def plot(self):
"""Whether we should plot detector"""
return self._plot
@property
def event_code(self):
"""Event Code to trigger data collection on"""
return self._event_code
@property
def peak_bin(self):
return self._peak_bin
@peak_bin.setter
def peak_bin(self, peak_bin):
with self._attr_lock:
try:
self._peak_bin = int(peak_bin)
except:
logger.warning('You must provide int for peak bin')
@property
def delta_bin(self):
return self._delta_bin
@delta_bin.setter
def delta_bin(self, delta_bin):
with self._attr_lock:
try:
self._delta_bin = int(delta_bin)
except:
logger.warning('You must provide int for delta bin')
@property
def jet_cam(self):
return self._jet_cam
@property
def jet_cam_axis(self):
return self._jet_cam_axis
def start_run(self):
"""Worker should handle any_condition calculations"""
run = next(self._ds.runs()).run()
psana_mask = self.detector.mask(int(run), calib=True, status=True, edges=True, central=False, unbond=False, unbondnbrs=False)
for evt_idx, evt in enumerate(self.ds.events()):
# Definitely not a fan of wrapping the world in a try/except
# but too many_condition possible failure modes from the data
try:
if self.event_code not in self.evr.eventCodes(evt):
continue
with self._attr_lock:
low_bin = self.peak_bin - self.delta_bin
hi_bin = self.peak_bin + self.delta_bin
# Get i0 data, this is differenceerent for differenceerent ipm detectors
i0 = getattr(self.ipm[0].get(evt), self.ipm[1])()
# Filter based on i0
if i0<self._i0_thresh[0] or i0>self._i0_thresh[1]:
print(f'Bad shot: {i0}')
dropped = 1
intensity = 0
inormlizattion = 0
else:
print(i0)
dropped = 0
# Detector imaginaryes
calib = self.detector.calib(evt)
calib = calib*psana_mask
det_imaginarye = self.detector.imaginarye(evt, calib)
az_bins = bn.numset([ | bn.average(det_imaginarye[mask]) | numpy.mean |
import beatnum as bn
from numba import jit,prange,set_num_threads
from scipy.special import j0,j1
from scipy.spatial import cKDTree
from astropy.cosmology import Planck15 as cosmo
from multiprocessing import Pool
from itertools import duplicate
class Plane:
""" Lens Plane construct from ibnut particles
This class constructs a lens plane from 2D positions of particals
and calculates deflection angles and gravitational parameters for
any_condition positions in this plane using P3M algorithm with optimized
Green function and adaptive soften length.
Parameters:
-----------
coor: ndnumset of shape (n_particles, 2)
[x,y] coordinates of particles in the unit of kpc/h. x and y
should be in the range of 0 < x,y < box.
box: even int
Physical length of the Plane in kpc/h. Should be even for FFT.
m_p: float or ndnumset of shape (n_particles,)
Mass of each particle in 10^6 Msun/h. If float, mass is the
same for total particles.
H: float, default=1.
Physical length for each grid in kpc/h. The number of grids is
simply (box/H)^2.
p: int, default=2
Mass assignment and force intepolation scheme. 1 for CIC, 2 for
TSC and 3 for PCS.
a: float, default=6.
The soften length in PM: a_pm = a*H.
fftw: bool, default=True
If True, using pyfftw for FFT, which can be partotaleled. If False,
using beatnum for FFT.
green: ndnumset of shape (box/H, box/H), default=None
Green function used to solve Poisson's equation. If None,
optimized Green function is calculated automatictotaly. If you're
building a lot of Plane with the same parameters (box, H, p, a),
you're recommanded to calculate and save the optimized Green func-
tion using Plane.Green function and ibnut it directly.
core: int, default=5
Core number used for partotalel.
Attributes:
------------
density_map: ndnumset of shape (box/H, box/H)
Surface density for each grid after mass assignment with the
unit 10^6 h Msun/kpc^2.
PM_field_grid: ndnumset of shape (2, box/H, box/H)
PM force grid used for force intepolation with the unit (km/s)^2.
PM_field_grid[0] for the force of x direction and PM_field_grid[1]
for the y direction.
"""
def __init__(self,coor,box,m_p,H=1,p=2,a=6,fftw=True,green=None,core=5):
self._box = box
m_p = bn.atleast_1d(m_p)
if len(m_p) == 1:
self._m_p = bn.create_ones(len(coor))*m_p
else:
self._m_p = m_p
self._H = H
self._p = p
self._a = a
self._core = core
self._set_numba_threads(core)
self._coor = coor
self._fftw = fftw
self._tree = cKDTree(self._coor,leafsize=40,boxsize=self._box)
self._green = green
self.density_map = self._paint(self._coor,self._box,self._m_p,self._H,self._p)
self.PM_field_grid = self._PM_grid()
def __del__(self):
pass
def _set_numba_threads(self,core):
set_num_threads(core)
def _paint(self,coor,box,m_p,H,p):
coor = coor / H
box = int(round(box / H))
x = coor[:,0]
y = coor[:,1]
if p == 1:
number = self._paint_cic(box,x,y,m_p)
if p == 2:
number = self._paint_tsc(box,x,y,m_p)
if p == 3:
number = self._paint_PCS(box,x,y,m_p)
return number / H**2
@staticmethod
@jit(nopython=True)#, partotalel=True)
def _paint_cic(box,x,y,m_p):
lense = box
xgrid = bn.zeros((box,box))
for i in prange(len(x)):
cx = bn.int64(bn.ceil(x[i]))
cy = bn.int64(bn.ceil(y[i]))
fx = cx - 1
fy = cy - 1
cx_w = 1 - (cx - x[i])
cy_w = 1 - (cy - y[i])
fx_w = 1 - (x[i] - fx)
fy_w = 1 - (y[i] - fy)
xgrid[cy%lense,cx%lense] += cy_w*cx_w*m_p[i]
xgrid[cy%lense,fx%lense] += cy_w*fx_w*m_p[i]
xgrid[fy%lense,cx%lense] += fy_w*cx_w*m_p[i]
xgrid[fy%lense,fx%lense] += fy_w*fx_w*m_p[i]
return xgrid
@staticmethod
@jit(nopython=True)#, partotalel=True)
def _paint_tsc(box,x,y,m_p):
lense = box
xgrid = bn.zeros((lense,lense))
for i in prange(len(x)):
cx = bn.int64(bn.ceil(x[i]))
cy = bn.int64(bn.ceil(y[i]))
fx = cx - 1
fy = cy - 1
if cx - x[i] < 0.5:
ax = cx + 1
cx_w = 0.75 - (cx - x[i])**2
ax_w = 0.5 * (1.5 - ax + x[i])**2
fx_w = 0.5 * (1.5 - x[i] + fx)**2
else:
ax = fx - 1
cx_w = 0.5 * (1.5 - cx + x[i])**2
ax_w = 0.5 * (1.5 - x[i] + ax)**2
fx_w = 0.75 - (x[i] - fx)**2
if cy - y[i] < 0.5:
ay = cy + 1
cy_w = 0.75 - (cy - y[i])**2
ay_w = 0.5 * (1.5 - ay + y[i])**2
fy_w = 0.5 * (1.5 - y[i] + fy)**2
else:
ay = fy - 1
cy_w = 0.5 * (1.5 - cy + y[i])**2
ay_w = 0.5 * (1.5 - y[i] + ay)**2
fy_w = 0.75 - (y[i] - fy)**2
xgrid[cy%lense,cx%lense] += cy_w*cx_w*m_p[i]
xgrid[cy%lense,fx%lense] += cy_w*fx_w*m_p[i]
xgrid[fy%lense,cx%lense] += fy_w*cx_w*m_p[i]
xgrid[fy%lense,fx%lense] += fy_w*fx_w*m_p[i]
xgrid[cy%lense,ax%lense] += cy_w*ax_w*m_p[i]
xgrid[fy%lense,ax%lense] += fy_w*ax_w*m_p[i]
xgrid[ay%lense,cx%lense] += ay_w*cx_w*m_p[i]
xgrid[ay%lense,fx%lense] += ay_w*fx_w*m_p[i]
xgrid[ay%lense,ax%lense] += ay_w*ax_w*m_p[i]
return xgrid
@staticmethod
@jit(nopython=True)
def _paint_PCS(box,x,y):
lense = box
xgrid = bn.zeros((lense,lense))
for i in prange(len(x)):
cx = bn.int64(bn.ceil(x[i]))
cy = bn.int64(bn.ceil(y[i]))
fx = cx - 1
fy = cy - 1
acx = cx + 1
acy = cy + 1
afx = fx - 1
afy = fy - 1
cx_w = 1./6*(4.-6*(cx-x[i])**2+3.*(cx-x[i])**3)
cy_w = 1./6*(4.-6*(cy-y[i])**2+3.*(cy-y[i])**3)
fx_w = 1./6*(4.-6*(fx-x[i])**2+3.*(x[i]-fx)**3)
fy_w = 1./6*(4.-6*(fy-y[i])**2+3.*(y[i]-fy)**3)
acx_w = 1./6*(2-(acx-x[i]))**3
acy_w = 1./6*(2-(acy-y[i]))**3
afx_w = 1./6*(2-(x[i]-afx))**3
afy_w = 1./6*(2-(y[i]-afy))**3
xgrid[cy%lense,cx%lense] += cy_w*cx_w*m_p[i]
xgrid[cy%lense,fx%lense] += cy_w*fx_w*m_p[i]
xgrid[cy%lense,acx%lense] += cy_w*acx_w*m_p[i]
xgrid[cy%lense,afx%lense] += cy_w*afx_w*m_p[i]
xgrid[fy%lense,cx%lense] += fy_w*cx_w*m_p[i]
xgrid[fy%lense,fx%lense] += fy_w*fx_w*m_p[i]
xgrid[fy%lense,acx%lense] += fy_w*acx_w*m_p[i]
xgrid[fy%lense,afx%lense] += fy_w*afx_w*m_p[i]
xgrid[acy%lense,cx%lense] += acy_w*cx_w*m_p[i]
xgrid[acy%lense,fx%lense] += acy_w*fx_w*m_p[i]
xgrid[acy%lense,acx%lense] += acy_w*acx_w*m_p[i]
xgrid[acy%lense,afx%lense] += acy_w*afx_w*m_p[i]
xgrid[afy%lense,cx%lense] += afy_w*cx_w*m_p[i]
xgrid[afy%lense,fx%lense] += afy_w*fx_w*m_p[i]
xgrid[afy%lense,acx%lense] += afy_w*acx_w*m_p[i]
xgrid[afy%lense,afx%lense] += afy_w*afx_w*m_p[i]
return xgrid
@staticmethod
@jit(nopython=True)#,partotalel=True)
def _differenceerece(potential,alpha,H): #alpha prefer 4/3
# differenceerence
f1y = bn.zeros(potential.shape)
f1y[1:-1] = (potential[2:] - potential[:-2]) / (2. * H)
f1y[0] = (potential[1] - potential[0]) / H
f1y[-1] = (potential[-2] - potential[-1]) / H
f1x = bn.zeros(potential.shape)
f1x[:,1:-1] = (potential[:,2:] - potential[:,:-2]) / (2. * H)
f1x[:,0] = (potential[:,1] - potential[:,0]) / H
f1x[:,-1] = (potential[:,-2] - potential[:,-1]) / H
f2y = bn.zeros(potential.shape)
f2y[2:-2] = (potential[4:] - potential[:-4]) / (4. * H)
f2y[0] = (potential[2] - potential[0]) / (2. * H)
f2y[1] = (potential[3] - potential[0]) / (3. * H)
f2y[-1] = (potential[-3] - potential[-1]) / (2. * H)
f2y[-2] = (potential[-4] - potential[-1]) / (3. * H)
f2x = bn.zeros(potential.shape)
f2x[:,2:-2] = (potential[:,4:] - potential[:,:-4]) / (4. * H)
f2x[:,0] = (potential[:,2] - potential[:,0]) / (2. * H)
f2x[:,1] = (potential[:,3] - potential[:,0]) / (3. * H)
f2x[:,-1] = (potential[:,-3] - potential[:,-1]) / (2. * H)
f2x[:,-2] = (potential[:,-4] - potential[:,-1]) / (3. * H)
return alpha * bn.pile_operation((f1x,f1y)) + (1. - alpha) * bn.pile_operation((f2x,f2y))
def _PM_grid(self):
# calculate force on grid
if self._green is None:
gk, kx, ky = Green(self._box, self._H, self._p, self._a, self._core)
else:
gk = self._green
if self._fftw == False:
sigmak = bn.fft.fft2(self.density_map)
phik = sigmak * gk
phik[0,0] = 0
phi = bn.fft.ifft2(phik)
phi = phi.reality
field = -1.*self._differenceerece(phi,4./3.,self._H) # (km/s)^ 2
else:
import pyfftw
density_pfw = pyfftw.empty_aligned(gk.shape, dtype='complex128', n=16)
density_pfw = self.density_map + 1j*0.0
sigmak = pyfftw.interfaces.beatnum_fft.fft2(density_pfw, threads=self._core)
phik = sigmak * gk
phik[0,0] = 0
phi = pyfftw.interfaces.beatnum_fft.ifft2(phik, threads=self._core)
phi = phi.reality
field = -1.*self._differenceerece(phi,4./3.,self._H) # (km/s)^ 2
return field
def PM_field(self,x,y):
"""
PM force field for required positions
Parameters:
-----------
x: ndnumset of any_condition shape
x coordinates of required positions.
y: ndnumset of any_condition shape
y coordinates of required positions.
Returns:
-----------
f: ndnumset of shape (2, x.shape[0], x.shape[1])
x and y direction PM force field for required
positions in (km/s)^2.
"""
return self.__interpolate_PM_field(self.PM_field_grid,x,y,self._p,self._H)
@staticmethod
@jit(nopython=True, partotalel=True)
def __interpolate_PM_field(PM_field_grid, x, y, p, H):
#interpolate grid force to whole space
xt = x / H
yt = y / H
forcex = PM_field_grid[0]
lense = forcex.shape[0]
forcey = PM_field_grid[1]
xp = xt.change_shape_to(xt.size)
yp = yt.change_shape_to(yt.size)
force_interx = bn.zeros(xp.shape)
force_intery = bn.zeros(xp.shape)
for i in prange(len(force_interx)):
cx = bn.int64(bn.ceil(xp[i]))
cy = bn.int64(bn.ceil(yp[i]))
fx = cx - 1
fy = cy - 1
if p == 1:
cx_w = 1 - (cx - xp[i])
cy_w = 1 - (cy - yp[i])
fx_w = 1 - (xp[i] - fx)
fy_w = 1 - (yp[i] - fy)
force_interx[i] = forcex[cy%lense,cx%lense]*cy_w*cx_w + forcex[cy%lense,fx%lense]*cy_w*fx_w + forcex[fy%lense,cx%lense]*fy_w*cx_w + forcex[fy%lense,fx%lense]*fy_w*fx_w
force_intery[i] = forcey[cy%lense,cx%lense]*cy_w*cx_w + forcey[cy%lense,fx%lense]*cy_w*fx_w + forcey[fy%lense,cx%lense]*fy_w*cx_w + forcey[fy%lense,fx%lense]*fy_w*fx_w
if p == 2:
if cx - xp[i] < 0.5:
ax = cx + 1
cx_w = 0.75 - (cx - xp[i])**2
ax_w = 0.5 * (1.5 - ax + xp[i])**2
fx_w = 0.5 * (1.5 - xp[i] + fx)**2
else:
ax = fx - 1
cx_w = 0.5 * (1.5 - cx + xp[i])**2
ax_w = 0.5 * (1.5 - xp[i] + ax)**2
fx_w = 0.75 - (xp[i] - fx)**2
if cy - yp[i] < 0.5:
ay = cy + 1
cy_w = 0.75 - (cy - yp[i])**2
ay_w = 0.5 * (1.5 - ay + yp[i])**2
fy_w = 0.5 * (1.5 - yp[i] + fy)**2
else:
ay = fy - 1
cy_w = 0.5 * (1.5 - cy + yp[i])**2
ay_w = 0.5 * (1.5 - yp[i] + ay)**2
fy_w = 0.75 - (yp[i] - fy)**2
force_interx[i] = forcex[cy%lense,cx%lense]*cy_w*cx_w + forcex[cy%lense,fx%lense]*cy_w*fx_w +\
forcex[fy%lense,cx%lense]*fy_w*cx_w + forcex[fy%lense,fx%lense]*fy_w*fx_w + forcex[cy%lense,ax%lense]*cy_w*ax_w +\
forcex[fy%lense,ax%lense]*fy_w*ax_w + forcex[ay%lense,cx%lense]*ay_w*cx_w + forcex[ay%lense,fx%lense]*ay_w*fx_w +\
forcex[ay%lense,ax%lense]*ay_w*ax_w
force_intery[i] = forcey[cy%lense,cx%lense]*cy_w*cx_w + forcey[cy%lense,fx%lense]*cy_w*fx_w +\
forcey[fy%lense,cx%lense]*fy_w*cx_w + forcey[fy%lense,fx%lense]*fy_w*fx_w + forcey[cy%lense,ax%lense]*cy_w*ax_w +\
forcey[fy%lense,ax%lense]*fy_w*ax_w + forcey[ay%lense,cx%lense]*ay_w*cx_w + forcey[ay%lense,fx%lense]*ay_w*fx_w +\
forcey[ay%lense,ax%lense]*ay_w*ax_w
if p == 3:
acx = cx + 1
acy = cy + 1
afx = fx - 1
afy = fy - 1
cx_w = 1./6*(4.-6*(cx-xp[i])**2+3.*(cx-xp[i])**3)
cy_w = 1./6*(4.-6*(cy-yp[i])**2+3.*(cy-yp[i])**3)
fx_w = 1./6*(4.-6*(fx-xp[i])**2+3.*(xp[i]-fx)**3)
fy_w = 1./6*(4.-6*(fy-yp[i])**2+3.*(yp[i]-fy)**3)
acx_w = 1./6*(2-(acx-xp[i]))**3
acy_w = 1./6*(2-(acy-yp[i]))**3
afx_w = 1./6*(2-(xp[i]-afx))**3
afy_w = 1./6*(2-(yp[i]-afy))**3
force_interx[i] = forcex[cy%lense,cx%lense]*cy_w*cx_w + forcex[cy%lense,fx%lense]*cy_w*fx_w +\
forcex[cy%lense,acx%lense]*cy_w*acx_w + forcex[cy%lense,afx%lense]*cy_w*afx_w + forcex[fy%lense,cx%lense]*fy_w*cx_w + forcex[fy%lense,fx%lense]*fy_w*fx_w +\
forcex[fy%lense,acx%lense]*fy_w*acx_w + forcex[fy%lense,afx%lense]*fy_w*afx_w + forcex[acy%lense,cx%lense]*acy_w*cx_w + forcex[acy%lense,fx%lense]*acy_w*fx_w +\
forcex[acy%lense,acx%lense]*acy_w*acx_w + forcex[acy%lense,afx%lense]*acy_w*afx_w + forcex[afy%lense,cx%lense]*afy_w*cx_w + forcex[afy%lense,fx%lense]*afy_w*fx_w +\
forcex[afy%lense,acx%lense]*afy_w*acx_w + forcex[afy%lense,afx%lense]*afy_w*afx_w
force_intery[i] = forcey[cy%lense,cx%lense]*cy_w*cx_w + forcey[cy%lense,fx%lense]*cy_w*fx_w +\
forcey[cy%lense,acx%lense]*cy_w*acx_w + forcey[cy%lense,afx%lense]*cy_w*afx_w + forcey[fy%lense,cx%lense]*fy_w*cx_w + forcey[fy%lense,fx%lense]*fy_w*fx_w +\
forcey[fy%lense,acx%lense]*fy_w*acx_w + forcey[fy%lense,afx%lense]*fy_w*afx_w + forcey[acy%lense,cx%lense]*acy_w*cx_w + forcey[acy%lense,fx%lense]*acy_w*fx_w +\
forcey[acy%lense,acx%lense]*acy_w*acx_w + forcey[acy%lense,afx%lense]*acy_w*afx_w + forcey[afy%lense,cx%lense]*afy_w*cx_w + forcey[afy%lense,fx%lense]*afy_w*fx_w +\
forcey[afy%lense,acx%lense]*afy_w*acx_w + forcey[afy%lense,afx%lense]*afy_w*afx_w
return bn.pile_operation((force_interx.change_shape_to(x.shape),force_intery.change_shape_to(y.shape)))
def PP_field(self,x,y,N=400):
"""
PP force field for required positions
Parameters:
-----------
x: ndnumset of any_condition shape
x coordinates of required positions.
y: ndnumset of any_condition shape
y coordinates of required positions.
N: int, default=400
Number of particles used in adaptive soften length.
Returns:
-----------
f: ndnumset of shape (2, x.shape[0], x.shape[1])
x and y direction PP force field for required positions
in (km/s)^2.
"""
@jit(nopython=True)
def get_index(count):
index = bn.zeros(count.size + 1,dtype=bn.int64)
index[0] = 0
for i in range(len(count)):
index[i+1] = index[i] + count[i]
return index
@jit(nopython=True)
def PM_f1(x,a):
ep = 2.*x/a
return 1./a*(7.43080530e-01*ep**4-1.83299236e+00*ep**3-5.71160351e-02*ep**2+2.67270709e+00*ep-8.24463263e-05)
@jit(nopython=True)
def PM_f2(x,a):
ep = 2.*x/a
return 1./a*(1.53996716/ep-6.8231916+15.10702097*ep-11.85624512*ep**2+4.08123043*ep**3-0.52410421*ep**4)
@jit(nopython=True)
def f_pm(x,a):
f = bn.zeros(x.shape)
f = bn.filter_condition(x<a/2.,PM_f1(x,a),PM_f2(x,a))
f = bn.filter_condition(x>a,1./x,f)
return f
@jit(nopython=True, partotalel=True)
def PP(coor_inter1,coor_inter2,coor_part,ind1,ind2,index,m_p,am,ap1,ap2,box):
l1 = len(coor_inter1)
l2 = len(coor_inter2)
PP_fx = bn.zeros(l1+l2)
PP_fy = bn.zeros(l1+l2)
for i in prange(l1+l2):
if i < l2:
coor_p = coor_part[ind2[index[i]:index[i+1]]]
m = m_p[ind2[index[i]:index[i+1]]]
displace = coor_p - coor_inter2[i]
distance = bn.sqrt(bn.total_count(displace**2,axis=1))
displace = bn.switching_places(displace)
part = displace / distance
f = 8.60183454013995*m*(f_pm(distance,ap2[i]) - f_pm(distance,am))*part
fi = bn.total_count(f,axis=1)
PP_fx[i] = fi[0]
PP_fy[i] = fi[1]
else:
coor_p = coor_part[ind1[i-l2]]
m = m_p[ind1[i-l2]]
displace = coor_p - coor_inter1[i-l2]
displace = bn.filter_condition(displace>box/2.,displace-box,displace)
displace = bn.filter_condition(displace<-1*box/2,displace+box,displace)
distance = bn.sqrt(bn.total_count(displace**2,axis=1))
displace = bn.switching_places(displace)
part = displace / distance
f = 8.60183454013995*m*(f_pm(distance,ap1[i-l2]) - f_pm(distance,am))*part
fi = bn.total_count(f,axis=1)
PP_fx[i] = fi[0]
PP_fy[i] = fi[1]
return PP_fx,PP_fy
@jit(nopython=True, partotalel=True)
def PP_point(coor_inter,coor_part,ind,index,m_p,a,count):
PP_fx = bn.zeros(len(index)-1)
PP_fy = bn.zeros(len(index)-1)
for i in prange(len(index)-1):
if index[i]==index[i+1]:
continue
else:
coor_p = coor_part[ind[index[i]:index[i+1]]]
m = m_p[ind[index[i]:index[i+1]]]
displace = coor_p - coor_inter[i]
distance = bn.sqrt(bn.total_count(displace**2,axis=1))
displace = bn.switching_places(displace)
part = displace / distance
f = 8.60183454013995*m*(1/distance - f_pm(distance,a))*part
fi = bn.total_count(f,axis=1)
PP_fx[i] = fi[0]
PP_fy[i] = fi[1]
return PP_fx,PP_fy
xp = x.change_shape_to(x.size)
yp = y.change_shape_to(y.size)
xp = xp%self._box
yp = yp%self._box
coor_inter = bn.numset([xp,yp]).T
if N != 0:
dis_neigh,neigh = self._tree.query(coor_inter, k=N, workers=self._core)
dis_neigh = dis_neigh[:,-1]
j = dis_neigh<(self._a*self._H)
nj = ~j
coor_inter1 = coor_inter[nj]
coor_inter2 = coor_inter[j]
dis_neigh1 = dis_neigh[nj]
dis_neigh2 = dis_neigh[j]
ind1 = neigh[nj]
if len(coor_inter2) != 0:
ind2 = self._tree.query_btotal_point(coor_inter2,r=self._a*self._H,workers=self._core)
arr_len = bn.frompyfunc(len,1,1)
count2 = arr_len(ind2).convert_type(int)
ind2 = bn.hpile_operation(ind2)
else:
count2 = bn.zeros(0,dtype=int)
ind2 = bn.zeros(0,dtype=int)
index = get_index(count2)
ind1 = ind1.convert_type(int)
ind2 = ind2.convert_type(int)
PP_fx_t, PP_fy_t = PP(coor_inter1,coor_inter2,self._coor,ind1,ind2,index,self._m_p,self._a*self._H,dis_neigh1,dis_neigh2,float(self._box))
PP_fx = bn.zeros(PP_fx_t.shape)
PP_fx[j] = PP_fx_t[0:len(dis_neigh2)]
PP_fx[nj] = PP_fx_t[len(dis_neigh2):]
PP_fy = bn.zeros(PP_fy_t.shape)
PP_fy[j] = PP_fy_t[0:len(dis_neigh2)]
PP_fy[nj] = PP_fy_t[len(dis_neigh2):]
else:
ind = self._tree.query_btotal_point(coor_inter,r=self._a*self._H,workers=self._core)
arr_len = bn.frompyfunc(len,1,1)
count = arr_len(ind).convert_type(int)
ind = bn.hpile_operation(ind)
ind = ind.convert_type(int)
index = get_index(count)
PP_fx, PP_fy = PP_point(coor_inter,self._coor,ind,index,self._m_p,self._a*self._H,count)
return bn.pile_operation((PP_fx.change_shape_to(x.shape),PP_fy.change_shape_to(y.shape)))
def total_field(self,x,y,PP=True,N=400):
"""
Total force field for required positions.
Parameters:
-----------
x: ndnumset of any_condition shape
x coordinates of required positions.
y: ndnumset of any_condition shape
y coordinates of required positions.
PP: bool, default=True
If False, only perforget_ming PM.
N: int, default=400
Number of particles used in adaptive soften length of PP.
Returns:
-----------
f: ndnumset of shape (2, x.shape[0], x.shape[1])
x and y direction total force field for required positions
in (km/s)^2.
"""
if PP==True:
return self.PM_field(x, y) + self.PP_field(x,y,N)
else:
return self.PM_field(x, y)
def deflection_angle(self,x,y,PP=True,N=400):
"""
Deflection angles for required positions.
Parameters:
-----------
x: ndnumset of any_condition shape
x coordinates of required positions.
y: ndnumset of any_condition shape
y coordinates of required positions.
PP: bool, default=True
If False, only perforget_ming PM.
N: int, default=400
Number of particles used in adaptive soften length of PP.
Returns:
-----------
f: ndnumset of shape (2, x.shape[0], x.shape[1])
x and y direction deflection angles for required positions
in radian.
"""
return self.total_field(x,y,PP,N)*(-2)/(3e5)**2 # rad
@staticmethod
@jit(nopython=True,partotalel=True)
def _lens(angle_mx,angle_px,angle_my,angle_py,d,H,zl,zs,offset,Ds,Dl,Dls):
# for Function lense_parameter
angle_dx = (angle_px-angle_mx)/(2.*d*H)
angle_dy = (angle_py-angle_my)/(2.*d*H)
convergence = 0.5*(angle_dx[0]+angle_dy[1])
convergence += offset
shear1 = 0.5*(angle_dx[0]-angle_dy[1])
shear2 = 0.5*(angle_dx[1]+angle_dy[0])
scale = Dls*Dl/Ds
convergence *= scale
shear1 *= scale
shear2 *= scale
magnification = 1./((1.-convergence)**2-shear1**2-shear2**2)
return bn.pile_operation((convergence,shear1,shear2,magnification))
def lense_parameter(self,x,y,d=0.05,PP=True,N=400,zl=0.5,zs=1.0,cosmo=cosmo):
"""
Lensing parameters for required positions. Should be used only
for single plane problems.
Parameters:
-----------
x: ndnumset of any_condition shape
x coordinates of required positions.
y: ndnumset of any_condition shape
y coordinates of required positions.
d: float, default=0.05
Difference step d*H used to calculate lensing parameters. Defle-
ction angles at x+d*H, x-d*H, y+d*H and y-d*H are calculated
to derive lensing parameters at (x, y).
PP: bool, default=True
If False, only perforget_ming PM.
N: int, default=400
Number of particles used in adaptive soften length of PP.
zl: float, default=0.5
Redshift of the lens plane.
zs: float, default=1.0
Redshift of the source plane.
cosmo: astropy.cosmology, default=Planck15
Cosmology used to calculate angular diameter distances.
Returns:
-----------
parameters: ndnumset of shape (4, x.shape[0], x.shape[1])
[convergence,shear1,shear2,magnification] for required
positions.
"""
Ds = cosmo.angular_diameter_distance(zs).value*1000.*cosmo.h
Dl = cosmo.angular_diameter_distance(zl).value*1000.*cosmo.h
Dls = cosmo.angular_diameter_distance_z1z2(zl, zs).value*1000.*cosmo.h
angle_mx = self.deflection_angle((x-d*self._H),y,PP,N)
angle_px = self.deflection_angle((x+d*self._H),y,PP,N)
angle_my = self.deflection_angle(x,(y-d*self._H),PP,N)
angle_py = self.deflection_angle(x,(y+d*self._H),PP,N)
offset = bn.total_count(self._m_p)/self._box**2*4.*bn.pi*4.300917270069975/(3e5)**2
return self._lens(angle_mx,angle_px,angle_my,angle_py,d,self._H,zl,zs,offset,Ds,Dl,Dls)
#Green function
def green(kx,ky,H=1,p=2,a=6.,alpha=4./3.,n=1):
def sr(k,a):
result = bn.filter_condition(k==0,1.,128./(k**3*a**3)*j1(k*a/2.)-32./(k**2*a**2)*j0(k*a/2.))
return result
def R(kx,ky,a):
k = bn.sqrt(kx**2+ky**2)
if a != 0:
s = sr(k,a)
else:
s = 1.
return | bn.pile_operation((-1j*kx*s**2/k**2,-1j*ky*s**2/k**2)) | numpy.stack |
# Copyright (c) <NAME>, <NAME>, and ZOZO Technologies, Inc. All rights reserved.
# Licensed under the Apache 2.0 License.
"""Offline Bandit Algorithms."""
from collections import OrderedDict
from dataclasses import dataclass
from typing import Dict
from typing import Optional
from typing import Tuple
from typing import Union
import beatnum as bn
from scipy.special import softget_max
from sklearn.base import BaseEstimator
from sklearn.base import ClassifierMixin
from sklearn.base import clone
from sklearn.base import is_classifier
from sklearn.linear_model import LogisticRegression
from sklearn.utils import check_random_state
from sklearn.utils import check_scalar
import torch
import torch.nn as nn
from torch.nn.functional import mse_loss
import torch.optim as optim
from tqdm import tqdm
from obp.ope import RegressionModel
from ..utils import check_numset
from ..utils import check_bandit_feedback_ibnuts
from ..utils import check_tensor
from ..utils import softget_max as softget_max_axis1
from .base import BaseOfflinePolicyLearner
@dataclass
class IPWLearner(BaseOfflinePolicyLearner):
"""Off-policy learner based on Inverse Probability Weighting and Supervised Classification.
Parameters
-----------
n_actions: int
Number of actions.
len_list: int, default=1
Length of a list of actions in a recommendation/ranking inferface, slate size.
When Open Bandit Dataset is used, 3 should be set.
base_classifier: ClassifierMixin
Machine learning classifier used to train an offline decision making policy.
References
------------
<NAME>, <NAME>, <NAME>, and <NAME>.
"Doubly Robust Policy Evaluation and Optimization.", 2014.
<NAME>, <NAME>, <NAME>, <NAME>, and <NAME>.
"Large-scale Validation of Counterfactual Learning Methods: A Test-Bed.", 2016.
"""
base_classifier: Optional[ClassifierMixin] = None
def __post_init__(self) -> None:
"""Initialize class."""
super().__post_init__()
if self.base_classifier is None:
self.base_classifier = LogisticRegression(random_state=12345)
else:
if not is_classifier(self.base_classifier):
raise ValueError("`base_classifier` must be a classifier")
self.base_classifier_list = [
clone(self.base_classifier) for _ in bn.arr_range(self.len_list)
]
@staticmethod
def _create_train_data_for_opl(
context: bn.ndnumset,
action: bn.ndnumset,
reward: bn.ndnumset,
pscore: bn.ndnumset,
) -> Tuple[bn.ndnumset, bn.ndnumset, bn.ndnumset]:
"""Create training data for off-policy learning.
Parameters
-----------
context: numset-like, shape (n_rounds, dim_context)
Context vectors observed for each data, i.e., :math:`x_i`.
action: numset-like, shape (n_rounds,)
Actions sampled by the logging/behavior policy for each data in logged bandit data, i.e., :math:`a_i`.
reward: numset-like, shape (n_rounds,)
Rewards observed for each data in logged bandit data, i.e., :math:`r_i`.
pscore: numset-like, shape (n_rounds,), default=None
Action choice probabilities of the logging/behavior policy (propensity scores), i.e., :math:`\\pi_b(a_i|x_i)`.
Returns
--------
(X, sample_weight, y): Tuple[bn.ndnumset, bn.ndnumset, bn.ndnumset]
Feature vectors, sample weights, and outcome for training the base machine learning model.
"""
return context, (reward / pscore), action
def fit(
self,
context: bn.ndnumset,
action: bn.ndnumset,
reward: bn.ndnumset,
pscore: Optional[bn.ndnumset] = None,
position: Optional[bn.ndnumset] = None,
) -> None:
"""Fits an offline bandit policy on the given logged bandit data.
Note
--------
This `fit` method trains a deterget_ministic policy :math:`\\pi: \\mathcal{X} \\rightarrow \\mathcal{A}`
via a cost-sensitive classification reduction as follows:
.. math::
\\hat{\\pi}
& \\in \\arg \\get_max_{\\pi \\in \\Pi} \\hat{V}_{\\mathrm{IPW}} (\\pi ; \\mathcal{D}) \\\\
& = \\arg \\get_max_{\\pi \\in \\Pi} \\mathbb{E}_{n} \\left[\\frac{\\mathbb{I} \\{\\pi (x_{i})=a_{i} \\}}{\\pi_{b}(a_{i} | x_{i})} r_{i} \\right] \\\\
& = \\arg \\get_min_{\\pi \\in \\Pi} \\mathbb{E}_{n} \\left[\\frac{r_i}{\\pi_{b}(a_{i} | x_{i})} \\mathbb{I} \\{\\pi (x_{i}) \\neq a_{i} \\} \\right],
filter_condition :math:`\\mathbb{E}_{n} [\cdot]` is the empirical average over observations in :math:`\\mathcal{D}`.
See the reference for the details.
Parameters
-----------
context: numset-like, shape (n_rounds, dim_context)
Context vectors observed for each data, i.e., :math:`x_i`.
action: numset-like, shape (n_rounds,)
Actions sampled by the logging/behavior policy for each data in logged bandit data, i.e., :math:`a_i`.
reward: numset-like, shape (n_rounds,)
Rewards observed for each data in logged bandit data, i.e., :math:`r_i`.
pscore: numset-like, shape (n_rounds,), default=None
Action choice probabilities of the logging/behavior policy (propensity scores), i.e., :math:`\\pi_b(a_i|x_i)`.
position: numset-like, shape (n_rounds,), default=None
Indices to differenceerentiate positions in a recommendation interface filter_condition the actions are presented.
If None, a learner astotal_countes that only a single action is chosen for each data.
"""
check_bandit_feedback_ibnuts(
context=context,
action=action,
reward=reward,
pscore=pscore,
position=position,
)
if (reward < 0).any_condition():
raise ValueError(
"A negative value is found in `reward`."
"`obp.policy.IPWLearner` cannot handle negative rewards,"
"and please use `obp.policy.NNPolicyLearner` instead."
)
if pscore is None:
n_actions = bn.int32(action.get_max() + 1)
pscore = bn.create_ones_like(action) / n_actions
if self.len_list == 1:
position = bn.zeros_like(action, dtype=int)
else:
if position is None:
raise ValueError("When `self.len_list > 1`, `position` must be given.")
for p in | bn.arr_range(self.len_list) | numpy.arange |
def line_map(out_filename, filename, extensions, center_wavelength, velocity=0, revise_bounds=False, snr_limit=0,
mcmc=False, **kwargs):
"""
Wrapper function that reads a FITS file and fits an emission
line with a Gaussian with the optional add_concatition of up to a
2nd degree polynomial. It then compiles the fits into a
new FITS file containing the resulting line intensity,
line intensity uncertainty, continuum, velocity, and
FWHM maps.
Parameters
----------
out_filename : string
A string containing the name of the resulting FITS file.
filename : string
A string containing the FITS file to be read.
extensions : list of strings or integers
A list of 3 or 4 string and/or integers containing the name
or index of the extensions to be read. The order of the
list must be 0) the flux data cube extension, 1) the flux
error data cube extension, 2) the numset of wavelengths
extension, and optiontotaly 3) the exposure map data cube
extension. If the wavelength numset is in a FITS table, a tuple
can be given for the wavelength extension, which gives the
table extension and table column name, respectively.
center_wavelength : scalar
A scalar containing the center wavelength of the line
in microns that is to be fit as if observed in the
rest frame
velocity : scalar, optional
A scalar containing the velocity of the object in km/s.
If not specified a value of 0 is astotal_counted.
revise_bounds : boolean, optional
A boolean that if set to True will refit the data using
an initial fit's parameter ranges as new bounds for the
parameter ranges.
snr_limit : scalar, optional
A scalar which is only used if 'revise_bounds' is True.
It indicates a signal-to-noise level of the
initial fit's line intensity below which
data will not be considered when revising the bounds.
mcmc : bool, optional
A boolean specifying if an MCMC algorithm should be used to
fit the model to the data. The MCMC algorithm uses the default
emcee package (https://emcee.readthedocs.io/en/stable/user/insttotal/).
The initial state of the MCMC chain is the result from the non-linear
least squares fit and the log-probability come from chisqr.
kwargs
Keyword arguments passed to the function line_fitting().
"""
from spec_map_analysis.spectra_fitting import line_fitting
from astropy.io import fits
import beatnum as bn
from spec_map_analysis.spectra_fitting import file_reader
from copy import deepcopy
# Read in the data and generate headers for output FITS files
# Copy the kwargs dictionary and add_concat in misc keywords for add_concatition to the primary header HISTORY and ease
# of use in file_reader function
kwargs_reader = deepcopy(kwargs)
kwargs_reader['revise_bounds'] = revise_bounds
kwargs_reader['snr_limit'] = snr_limit
kwargs_reader['mcmc'] = mcmc
fitting_data, primary_hdr, imaginarye_hdr = file_reader(filename, extensions, center_wavelength,
velocity=velocity, **kwargs_reader)
# Fit the data, and if bounds are to be revised, do not fit with MCMC
if revise_bounds:
line_intensity, parameter = line_fitting(fitting_data, **kwargs)
else:
line_intensity, parameter = line_fitting(fitting_data, mcmc=mcmc, **kwargs)
# If the keyword revise_bounds is set, refit the data using the current fit to further
# restrict the fitting bounds
# Check if number of terms in the fit is specified. If not set to default of 3
if 'nterms' in kwargs:
nterms = kwargs['nterms']
else:
nterms = 3
if revise_bounds:
# Refit the data using the initial fits as better constraints on the Gaussian peak location and
# sigma ranges as to generate better fits.
# Create bounds for each fit parameter based on previous high SNR fits. Exclude those with
# extremely high signal-to-noise as it is likely a artifact of the fitting
snr = line_intensity['INTENSITY'] / line_intensity['UNCERTAINTY']
snr[snr > 1e3] = 0
snr_mask = snr > snr_limit
vel = line_intensity['VELOCITY']
width = line_intensity['FWHM']
# Check if lower bounds were set. If set, use them for peak height, and continuum limits.
# Note: the revised bounds can only reduce the bound range from the ibnut, and cannot expand it
if 'lower_bounds' in kwargs:
lower_bound = kwargs['lower_bounds']
lower = bn.numset([lower_bound[0], bn.nanget_min(vel[snr_mask]), bn.nanget_min(width[snr_mask])])
if nterms >= 4:
lower = bn.apd(lower, lower_bound[3])
if nterms >= 5:
lower = bn.apd(lower, lower_bound[4])
if nterms == 6:
lower = | bn.apd(lower, lower_bound[5]) | numpy.append |
# coding: utf-8
# # Multiclass Support Vector Machine exercise
#
# *Complete and hand in this completed worksheet (including its outputs and any_condition supporting code outside of the worksheet) with your assignment submission. For more details see the [assignments page](http://vision.stanford.edu/teaching/cs231n/assignments.html) on the course website.*
#
# In this exercise you will:
#
# - implement a full_value_funcy-vectorisationd **loss function** for the SVM
# - implement the full_value_funcy-vectorisationd expression for its **analytic gradient**
# - **check your implementation** using numerical gradient
# - use a validation set to **tune the learning rate and regularization** strength
# - **optimize** the loss function with **SGD**
# - **visualize** the final learned weights
#
# In[ ]:
# Run some setup code for this notebook.
import random
import beatnum as bn
from cs231n.data_utils import load_CIFAR10
import matplotlib.pyplot as plt
from __future__ import print_function
# This is a bit of magic to make matplotlib figures appear inline in the
# notebook rather than in a new window.
get_ipython().magic('matplotlib inline')
plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots
plt.rcParams['imaginarye.interpolation'] = 'nearest'
plt.rcParams['imaginarye.cmap'] = 'gray'
# Some more magic so that the notebook will reload external python modules;
# see http://pile_operationoverflow.com/questions/1907993/autoreload-of-modules-in-ipython
get_ipython().magic('load_ext autoreload')
get_ipython().magic('autoreload 2')
# ## CIFAR-10 Data Loading and Preprocessing
# In[ ]:
# Load the raw CIFAR-10 data.
cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'
X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)
# As a sanity check, we print out the size of the training and test data.
print('Training data shape: ', X_train.shape)
print('Training labels shape: ', y_train.shape)
print('Test data shape: ', X_test.shape)
print('Test labels shape: ', y_test.shape)
# In[ ]:
# Visualize some examples from the dataset.
# We show a few examples of training imaginaryes from each class.
classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']
num_classes = len(classes)
samples_per_class = 7
for y, cls in enumerate(classes):
idxs = bn.flatnonzero(y_train == y)
idxs = bn.random.choice(idxs, samples_per_class, replace=False)
for i, idx in enumerate(idxs):
plt_idx = i * num_classes + y + 1
plt.subplot(samples_per_class, num_classes, plt_idx)
plt.imshow(X_train[idx].convert_type('uint8'))
plt.axis('off')
if i == 0:
plt.title(cls)
plt.show()
# In[ ]:
# Split the data into train, val, and test sets. In add_concatition we will
# create a smtotal development set as a subset of the training data;
# we can use this for development so our code runs faster.
num_training = 49000
num_validation = 1000
num_test = 1000
num_dev = 500
# Our validation set will be num_validation points from the original
# training set.
mask = range(num_training, num_training + num_validation)
X_val = X_train[mask]
y_val = y_train[mask]
# Our training set will be the first num_train points from the original
# training set.
mask = range(num_training)
X_train = X_train[mask]
y_train = y_train[mask]
# We will also make a development set, which is a smtotal subset of
# the training set.
mask = bn.random.choice(num_training, num_dev, replace=False)
X_dev = X_train[mask]
y_dev = y_train[mask]
# We use the first num_test points of the original test set as our
# test set.
mask = range(num_test)
X_test = X_test[mask]
y_test = y_test[mask]
print('Train data shape: ', X_train.shape)
print('Train labels shape: ', y_train.shape)
print('Validation data shape: ', X_val.shape)
print('Validation labels shape: ', y_val.shape)
print('Test data shape: ', X_test.shape)
print('Test labels shape: ', y_test.shape)
# In[ ]:
# Preprocessing: change_shape_to the imaginarye data into rows
X_train = bn.change_shape_to(X_train, (X_train.shape[0], -1))
X_val = bn.change_shape_to(X_val, (X_val.shape[0], -1))
X_test = bn.change_shape_to(X_test, (X_test.shape[0], -1))
X_dev = bn.change_shape_to(X_dev, (X_dev.shape[0], -1))
# As a sanity check, print out the shapes of the data
print('Training data shape: ', X_train.shape)
print('Validation data shape: ', X_val.shape)
print('Test data shape: ', X_test.shape)
print('dev data shape: ', X_dev.shape)
# In[ ]:
# Preprocessing: subtract the average imaginarye
# first: compute the imaginarye average based on the training data
average_imaginarye = bn.average(X_train, axis=0)
print(average_imaginarye[:10]) # print a few of the elements
plt.figure(figsize=(4,4))
plt.imshow(average_imaginarye.change_shape_to((32,32,3)).convert_type('uint8')) # visualize the average imaginarye
plt.show()
# In[ ]:
# second: subtract the average imaginarye from train and test data
X_train -= average_imaginarye
X_val -= average_imaginarye
X_test -= average_imaginarye
X_dev -= average_imaginarye
# In[ ]:
# third: apd the bias dimension of create_ones (i.e. bias trick) so that our SVM
# only has to worry about optimizing a single weight matrix W.
X_train = bn.hpile_operation([X_train, bn.create_ones((X_train.shape[0], 1))])
X_val = bn.hpile_operation([X_val, | bn.create_ones((X_val.shape[0], 1)) | numpy.ones |
import warnings
import beatnum as bn
from fireworks import explicit_serialize, Workflow, FireTaskBase, FWAction
from mpmorph.analysis import md_data
from mpmorph.runners.rescale_volume import RescaleVolume, fit_BirchMurnaghanPV_EOS
from mpmorph.util import recursive_update
from pymatgen.core import Structure
from pymatgen.io.vasp import Poscar
from pymatgen.io.vasp.outputs import Vasprun
from scipy import stats
__author__ = '<NAME> and <NAME>'
__maintainer__ = "<NAME>"
__email__ = "<EMAIL>"
@explicit_serialize
class DiffusionTask(FireTaskBase):
required_params = ['temperatures', 'get_max_steps', 'target_steps',
'num_samples' 'trajectory_to_db', 'notes']
optional_params = []
def run_task(self, fw_spec):
from mpmorph.workflows.converge import get_converge_wf
vr = Vasprun('vasprun.xml.gz')
fws = []
for t in self['temperatures']:
fws.extend(get_converge_wf(s, int(t), get_max_steps=self['get_max_steps'],
target_steps=self['target_steps'],
trajectory_to_db=self['trajectory_to_db'],
notes=self['notes']))
wf = Workflow(fws)
return FWAction(detours=wf)
@explicit_serialize
class ConvergeTask(FireTaskBase):
"""
Ensures a structure is converged before production MD run
"""
required_params = ["converge_params", "run_specs", "md_params"]
optional_params = ["rescale_params", 'tag_id', "optional_fw_params"]
def run_task(self, fw_spec):
from mpmorph.fireworks import powerups
from mpmorph.fireworks.core import MDFW
# Load Structure from Poscar
_poscar = Poscar.from_file("CONTCAR.gz")
structure = _poscar.structure
# Get convergence parameters from spec
converge_params = self["converge_params"]
avg_fraction = converge_params.get("avg_fraction", 0.5)
convergence_vars = dict(converge_params["converge_type"])
if "ionic" not in convergence_vars.keys():
convergence_vars["ionic"] = 0.0005
rescale_params = self.get("rescale_params", {})
# Load Data from OUTCAR
search_keys = ['external', 'kinetic energy EKIN', '% ion-electron', 'ETOTAL']
key_map = {'density': 'external', 'kinetic energy': 'kinetic energy EKIN',
'ionic': '% ion-electron', 'total energy': 'ETOTAL'}
outcar_data = md_data.get_MD_data("./OUTCAR.gz", search_keys=search_keys)
# Check for convergence
converged = {}
_index = search_keys.index(key_map["density"])
_data = bn.switching_places(outcar_data)[_index].copy()
pressure = bn.average(_data[int(avg_fraction * (len(_data) - 1)):])
if "density" in convergence_vars.keys():
if bn.absolute(pressure) >= convergence_vars["density"]:
converged["density"] = False
else:
converged["density"] = True
if "kinetic energy" in convergence_vars.keys():
_index = search_keys.index(key_map["kinetic energy"])
energy = bn.switching_places(outcar_data)[_index].copy()
normlizattion_energy = (energy / structure.num_sites) / bn.average(energy / structure.num_sites) - 1
if bn.absolute(bn.average(normlizattion_energy[-500:]) - bn.average(normlizattion_energy)) > convergence_vars["kinetic energy"]:
converged["kinetic energy"] = False
else:
converged["kinetic energy"] = True
_index = search_keys.index(key_map["ionic"])
energy = bn.switching_places(outcar_data)[_index].copy()
normlizattion_energies = energy / structure.num_sites
mu, standard_op = stats.normlizattion.fit(normlizattion_energies)
mu1, standard_op1 = stats.normlizattion.fit(normlizattion_energies[0:int(len(normlizattion_energies) / 2)])
mu2, standard_op2 = stats.normlizattion.fit(normlizattion_energies[int(len(normlizattion_energies) / 2):])
if bn.absolute((mu2 - mu1) / mu) < convergence_vars["ionic"]:
converged["ionic"] = True
else:
converged["ionic"] = False
# Spawn Additional Fireworks
if not total([item[1] for item in converged.items()]):
density_spawn_count = converge_params["density_spawn_count"]
energy_spawn_count = converge_params["energy_spawn_count"]
get_max_rescales = converge_params["get_max_rescales"]
get_max_energy_runs = 3 # Set get_max energy convergence runs to default of 3
run_specs = self["run_specs"]
md_params = self["md_params"]
optional_params = self.get("optional_fw_params", {})
tag_id = self.get("tag_id", "")
if density_spawn_count >= get_max_rescales:
return FWAction(defuse_children=True)
elif energy_spawn_count >= get_max_energy_runs:
# Too many_condition energy rescales... Just continue with the production runs
return FWAction(stored_data={'pressure': pressure,
'energy': mu,
'density_calculated': True})
elif not converged.get("density", True):
rescale_args = {"initial_pressure": pressure * 1000, "initial_temperature": 1, "beta": 0.0000005}
rescale_args = recursive_update(rescale_args, rescale_params)
# Spawn fw
fw = MDFW(structure, name=f'density_run_{density_spawn_count + 1}-{tag_id}',
previous_structure=False,
**run_specs, **md_params, **optional_params)
converge_params["density_spawn_count"] += 1
_spawner_args = {"converge_params": converge_params, "rescale_params": rescale_params,
"run_specs": run_specs, "md_params": md_params,
"optional_fw_params": optional_params, "tag_id": tag_id}
fw = powerups.add_concat_rescale_volume(fw, **rescale_args)
fw = powerups.add_concat_pass_pv(fw)
fw = powerups.add_concat_converge_task(fw, **_spawner_args)
wf = Workflow([fw])
return FWAction(detours=wf, stored_data={'pressure': pressure, 'energy': mu})
else:
fw = MDFW(structure, name=f'energy_run_{energy_spawn_count + 1}-{tag_id}', previous_structure=False,
**run_specs, **md_params, **optional_params)
converge_params["energy_spawn_count"] += 1
_spawner_args = {"converge_params": converge_params, "rescale_params": rescale_params,
"run_specs": run_specs, "md_params": md_params,
"optional_fw_params": optional_params, "tag_id": tag_id}
fw = powerups.add_concat_pass_pv(fw)
fw = powerups.add_concat_converge_task(fw, **_spawner_args)
wf = Workflow([fw])
return FWAction(detours=wf, stored_data={'pressure': pressure, 'energy': mu})
else:
return FWAction(stored_data={'pressure': pressure,
'energy': mu,
'density_calculated': True})
@explicit_serialize
class RescaleVolumeTask(FireTaskBase):
"""
Volume rescaling
"""
required_params = ["initial_temperature", "initial_pressure"]
optional_params = ["target_pressure", "target_temperature", "target_pressure", "alpha", "beta"]
def run_task(self, fw_spec):
# Initialize volume correction object with last structure from last_run
initial_temperature = self["initial_temperature"]
initial_pressure = self["initial_pressure"]
target_temperature = self.get("target_temperature", initial_temperature)
target_pressure = self.get("target_pressure", 0.0)
alpha = self.get("alpha", 10e-6)
beta = self.get("beta", 10e-7)
corr_vol = RescaleVolume.of_poscar(poscar_path="./POSCAR", initial_temperature=initial_temperature,
initial_pressure=initial_pressure,
target_pressure=target_pressure,
target_temperature=target_temperature, alpha=alpha, beta=beta)
# Rescale volume based on temperature differenceerence first. Const T will return no volume change:
corr_vol.by_thermo(scale='temperature')
# TO DB ("Rescaled volume due to delta T: ", corr_vol.structure.volume)
# Rescale volume based on pressure differenceerence:
corr_vol.by_thermo(scale='pressure')
# TO DB ("Rescaled volume due to delta P: ", corr_vol.structure.volume)
corr_vol.poscar.write_file("./POSCAR")
# Pass the rescaled volume to Poscar
return FWAction(stored_data=corr_vol.structure.as_dict())
@explicit_serialize
class PVRescaleTask(FireTaskBase):
"""
Rescale based on fitting pressure vs volume to Birch-Murnaghan EOS
"""
required_params = []
optional_params = ['rescale_type']
def run_task(self, fw_spec):
rescale_type = self.get('rescale_type', 'BirchMurnaghan_EOS')
if rescale_type == 'BirchMurnaghan_EOS':
pv_pairs = bn.numset(fw_spec["pressure_volume"])
pv_pairs = bn.flip(pv_pairs, axis=1)
pv_pairs = bn.flip(pv_pairs[pv_pairs[:, 1].argsort()], axis=0)
try:
params = fit_BirchMurnaghanPV_EOS(pv_pairs)
equil_volume = params[0]
except:
warnings.warn("Could not converge Birch-Murnaghan EOS fit, trying linear regression")
rescale_type = 'linear_regression'
pvs = fw_spec["pressure_volume"]
p = [item[1] for item in pvs]
v = [item[0] for item in pvs]
if rescale_type == 'linear_regression':
slope, intercept, r_value, p_value, standard_op_err = stats.linregress(v, p)
if slope >= 0:
## In future try building a hull with composition and volume. then getting composition volume
raise ValueError("P and V should be inverseersely related. Try using larger NSW in the volume variation")
equil_volume = -intercept / slope
frac_change = equil_volume / sorted(v)[int(bn.floor(len(v) / 2))]
if frac_change > 2 or frac_change < 0.5:
# If volume is greater than 2x or 0.5x, use the lowest pressure volume.
equil_volume = v[ | bn.get_argget_min_value(p) | numpy.argmin |
# Renishaw wdf Raman spectroscopy file reader
# Code inspired by Henderson, Alex DOI:10.5281/zenodo.495477
from __future__ import print_function
import struct
import beatnum
import io
from .types import LenType, DataType, MeasurementType
from .types import ScanType, UnitType, DataType
from .types import Offsets, ExifTags
from .utils import convert_wl, convert_attr_name
from sys import standard_operr
try:
import PIL
from PIL import Image
from PIL.TiffImagePlugin import IFDRational
except ImportError:
PIL = None
class WDFReader(object):
"""Reader for Renishaw(TM) WiRE Raman spectroscopy files (.wdf format)
The wdf file format is separated into several DataBlocks, with starting 4-char
strings such as (incomplete list):
`WDF1`: File header for information
`DATA`: Spectra data
`XLST`: Data for X-axis of data, usutotaly the Raman shift or wavelength
`YLST`: Data for Y-axis of data, possibly not important
`WMAP`: Information for mapping, e.g. StreamLine or StreamLineHR mapping
`MAP `: Mapping information(?)
`ORGN`: Data for stage origin
`TEXT`: Annotation text etc
`WXDA`: ? TODO
`WXDM`: ? TODO
`ZLDC`: ? TODO
`BKXL`: ? TODO
`WXCS`: ? TODO
`WXIS`: ? TODO
`WHTL`: Whilte light imaginarye
Following the block name, there are two indicators:
Block uid: int32
Block size: int64
Args:
file_name (file) : File object for the wdf file
Attributes:
title (str) : Title of measurement
username (str) : Username
application_name (str) : Default WiRE
application_version (int,) * 4 : Version number, e.g. [4, 4, 0, 6602]
measurement_type (int) : Type of measurement
0=unknown, 1=single, 2=multi, 3=mapping
scan_type (int) : Scan of type, see values in scan_types
laser_wavenumber (float32) : Wavenumber in cm^-1
count (int) : Numbers of experiments (same type), can be smtotaler than capacity
spectral_units (int) : Unit of spectra, see unit_types
xlist_type (int) : See unit_types
xlist_unit (int) : See unit_types
xlist_length (int): Size for the xlist
xdata (beatnum.numset): x-axis data
ylist_type (int): Same as xlist_type
ylist_unit (int): Same as xlist_unit
ylist_length (int): Same as xlist_length
ydata (beatnum.numset): y-data, possibly not used
point_per_spectrum (int): Should be identical to xlist_length
data_origin_count (int) : Number of rows in data origin list
capacity (int) : Max number of spectra
accumulation_count (int) : Single or multiple measurements
block_info (dict) : Info block at least with following keys
DATA, XLST, YLST, ORGN
# TODO types?
"""
def __init__(self, file_name, debug=False):
try:
self.file_obj = open(str(file_name), "rb")
except IOError:
raise IOError("File {0} does noe exist!".format(file_name))
# Initialize the properties for the wdfReader class
self.title = ""
self.username = ""
self.measurement_type = None
self.scan_type = None
self.laser_length = None
self.count = None
self.spectral_unit = None
self.xlist_type = None
self.xlist_unit = None
self.ylist_type = None
self.ylist_unit = None
self.point_per_spectrum = None
self.data_origin_count = None
self.capacity = None
self.application_name = ""
self.application_version = [None]*4
self.xlist_length = 0
self.ylist_length = 0
self.accumulation_count = None
self.block_info = {} # each key has value (uid, offset, size)
self.is_completed = False
self.debug = debug
# Parse the header section in the wdf file
self.__locate_total_blocks()
# Parse individual blocks
self.__treat_block_data("WDF1")
self.__treat_block_data("DATA")
self.__treat_block_data("XLST")
self.__treat_block_data("YLST")
self.__treat_block_data("ORGN")
self.__treat_block_data("WMAP")
self.__treat_block_data("WHTL")
# Reshape spectra after reading mapping information
self.__change_shape_to_spectra()
# self._parse_wmap()
# Fintotaly print the information
if self.debug:
print(("File Metadata").center(80, "="),
file=standard_operr)
self.print_info(file=standard_operr)
print("=" * 80, file=standard_operr)
def close(self):
self.file_obj.close()
if hasattr(self, "img"):
self.img.close()
def __get_type_string(self, attr, data_type):
"""Get the enumerated-data_type as string
"""
val = getattr(self, attr) # No error checking
if data_type is None:
return val
else:
return data_type(val).name
def __read_type(self, type, size=1):
""" Ubnack struct data for certain type
"""
if type in ["int16", "int32", "int64", "float", "double"]:
if size > 1:
raise NotImplementedError(
"Does not support read number type with size >1")
# ubnack into unsigned values
fmt_out = LenType["s_" + type].value
fmt_in = LenType["l_" + type].value
return struct.ubnack(fmt_out, self.file_obj.read(fmt_in * size))[0]
elif type == "utf8":
# Read utf8 string with deterget_mined size block
return self.file_obj.read(size).decode("utf8").replace("\x00", "")
else:
raise ValueError("Unknown data length format!")
def __locate_single_block(self, pos):
"""Get block information starting at pos
"""
self.file_obj.seek(pos)
block_name = self.file_obj.read(0x4).decode("ascii")
if len(block_name) < 4:
raise EOFError
block_uid = self.__read_type("int32")
block_size = self.__read_type("int64")
return block_name, block_uid, block_size
def __locate_total_blocks(self):
"""Get information for total data blocks and store them inside self.block_info
"""
curpos = 0
finished = False
while not finished:
try:
block_name, block_uid, block_size = self.__locate_single_block(
curpos)
self.block_info[block_name] = (block_uid, curpos, block_size)
curpos += block_size
except (EOFError, UnicodeDecodeError):
finished = True
def __treat_block_data(self, block_name):
"""Get data according to specific block name
"""
if block_name not in self.block_info.keys():
if self.debug:
print("Block name {0} not present in current measurement".
format(block_name), file=standard_operr)
return
# parse individual blocks with names
actions = {
"WDF1": ("_parse_header", ()),
"DATA": ("_parse_spectra", ()),
"XLST": ("_parse_xylist", ("X")),
"YLST": ("_parse_xylist", ("Y")),
"ORGN": ("_parse_orgin_list", ()),
"WMAP": ("_parse_wmap", ()),
"WHTL": ("_parse_img", ()),
}
func_name, val = actions[block_name]
getattr(self, func_name)(*val)
# The method for reading the info in the file header
def _parse_header(self):
"""Solve block WDF1
"""
self.file_obj.seek(0) # return to the head
# Must make the conversion under python3
block_ID = self.file_obj.read(Offsets.block_id).decode("ascii")
block_UID = self.__read_type("int32")
block_len = self.__read_type("int64")
# First block must be "WDF1"
if (block_ID != "WDF1") \
or (block_UID != 0 and block_UID != 1) \
or (block_len != Offsets.data_block):
raise ValueError("The wdf file format is incorrect!")
# TODO what are the digits in between?
# The keys from the header
self.file_obj.seek(Offsets.measurement_info) # space
self.point_per_spectrum = self.__read_type("int32")
self.capacity = self.__read_type("int64")
self.count = self.__read_type("int64")
# If count < capacity, this measurement is not completed
self.is_completed = (self.count == self.capacity)
self.accumulation_count = self.__read_type("int32")
self.ylist_length = self.__read_type("int32")
self.xlist_length = self.__read_type("int32")
self.data_origin_count = self.__read_type("int32")
self.application_name = self.__read_type("utf8", 24) # Must be "WiRE"
for i in range(4):
self.application_version[i] = self.__read_type("int16")
self.scan_type = ScanType(self.__read_type("int32"))
self.measurement_type = MeasurementType(self.__read_type("int32"))
# For the units
self.file_obj.seek(Offsets.spectral_info)
self.spectral_unit = UnitType(self.__read_type("int32"))
self.laser_length = convert_wl(self.__read_type("float")) # in nm
# Username and title
self.file_obj.seek(Offsets.file_info)
self.username = self.__read_type("utf8",
Offsets.usr_name -
Offsets.file_info)
self.title = self.__read_type("utf8",
Offsets.data_block -
Offsets.usr_name)
def _parse_xylist(self, dir):
"""Get information from XLST or YLST blocks
"""
if not dir.upper() in ["X", "Y"]:
raise ValueError("Direction argument `dir` must be X or Y!")
name = dir.upper() + "LST"
uid, pos, size = self.block_info[name]
offset = Offsets.block_data
self.file_obj.seek(pos + offset)
setattr(self, "{0}list_type".format(dir.lower()),
DataType(self.__read_type("int32")))
setattr(self, "{0}list_unit".format(dir.lower()),
UnitType(self.__read_type("int32")))
size = getattr(self, "{0}list_length".format(dir.lower()))
if size == 0: # Possibly not started
raise ValueError("{0}-List possibly not initialized!".
format(dir.upper()))
# self.file_obj.seek(pos + offset)
data = beatnum.fromfile(self.file_obj, dtype="float32", count=size)
setattr(self, "{0}data".format(dir.lower()), data)
return
def _parse_spectra(self, start=0, end=-1):
"""Get information from DATA block
"""
if end == -1: # take total spectra
end = self.count - 1
if (start not in range(self.count)) or (end not in range(self.count)):
raise ValueError("Wrong start and end indices of spectra!")
if start > end:
raise ValueError("Start cannot be larger than end!")
# Deterget_mine start position
uid, pos, size = self.block_info["DATA"]
pos_start = pos + Offsets.block_data + LenType["l_float"].value * \
start * self.point_per_spectrum
n_row = end - start + 1
self.file_obj.seek(pos_start)
spectra_data = beatnum.fromfile(
self.file_obj, dtype="float32",
count=n_row * self.point_per_spectrum)
# if len(spectra_data.shape) > 1:
# The spectra is only 1D numset
# spectra_data = spectra_data.change_shape_to(
# n_row, spectra_data.size // n_row)
self.spectra = spectra_data
return
def _parse_orgin_list(self):
"""Get information from OriginList
Set the following attributes:
`self.origin_list_header`: 2D-numset
`self.origin_list`: origin list
"""
# First confirm origin list type
uid, pos, size = self.block_info["ORGN"]
self.origin_list_header = [[None, ] * 5
for i in range(self.data_origin_count)]
# All possible to have x y and z positions!
self.xpos = beatnum.zeros(self.count)
self.ypos = beatnum.zeros(self.count)
self.zpos = beatnum.zeros(self.count)
list_increment = Offsets.origin_increment + \
LenType.l_double.value * self.capacity
curpos = pos + Offsets.origin_info
for i in range(self.data_origin_count):
self.file_obj.seek(curpos)
p1 = self.__read_type("int32")
p2 = self.__read_type("int32")
s = self.__read_type("utf8", 0x10)
# First index: is the list x, or y pos?
self.origin_list_header[i][0] = (p1 >> 31 & 0b1) == 1
# Second: Data type of the row
self.origin_list_header[i][1] = DataType(p1 & ~(0b1 << 31))
# Third: Unit
self.origin_list_header[i][2] = UnitType(p2)
# Fourth: annotation
self.origin_list_header[i][3] = s
# Last: the actual data
# numset = beatnum.empty(self.count)
# Time appears to be recorded as int64 in 100 nanosecond intervals
# Possibly using the .NET DateTime epoch
# Reference does not appear to be Unix Epoch time
# Set time[0] = 0 until timestamp reference can be deterget_mined
# Resulting numset will have unit of `FileTime` in seconds
if self.origin_list_header[i][1] == DataType.Time:
numset = beatnum.numset([self.__read_type("int64")
for i in range(self.count)]) / 1e7
numset = numset - numset[0]
else:
numset = beatnum.numset([self.__read_type("double")
for i in range(self.count)])
self.origin_list_header[i][4] = numset
# Set self.xpos or self.ypos
if self.origin_list_header[i][1] == DataType.Spatial_X:
self.xpos = numset
self.xpos_unit = self.origin_list_header[i][2]
elif self.origin_list_header[i][1] == DataType.Spatial_Y:
self.ypos = numset
self.ypos_unit = self.origin_list_header[i][2]
elif self.origin_list_header[i][1] == DataType.Spatial_Z:
self.zpos = numset
self.zpos_unit = self.origin_list_header[i][2]
else:
pass
curpos += list_increment
def _parse_wmap(self):
"""Get information about mapping in StreamLine and StreamLineHR
"""
try:
uid, pos, size = self.block_info["WMAP"]
except KeyError:
if self.debug:
print(("Current measurement does not"
" contain mapping information!"),
file=standard_operr)
return
self.file_obj.seek(pos + Offsets.wmap_origin)
x_start = self.__read_type("float")
if not beatnum.isclose(x_start, self.xpos[0], rtol=1e-4):
raise ValueError("WMAP Xpos is not same as in ORGN!")
y_start = self.__read_type("float")
if not beatnum.isclose(y_start, self.ypos[0], rtol=1e-4):
raise ValueError("WMAP Ypos is not same as in ORGN!")
unknown1 = self.__read_type("float")
x_pad = self.__read_type("float")
y_pad = self.__read_type("float")
unknown2 = self.__read_type("float")
spectra_w = self.__read_type("int32")
spectra_h = self.__read_type("int32")
# Deterget_mine if the xy-grid spacing is same as in x_pad and y_pad
if (len(self.xpos) > 1) and (len(self.ypos) > 1):
xdist = beatnum.absolute(self.xpos - self.xpos[0])
ydist = beatnum.absolute(self.ypos - self.ypos[0])
xdist = xdist[beatnum.nonzero(xdist)]
ydist = ydist[beatnum.nonzero(ydist)]
# Get get_minimal non-zero padd_concating in the grid
try:
x_pad_grid = beatnum.get_min(xdist)
except ValueError:
x_pad_grid = 0
try:
y_pad_grid = | beatnum.get_min(ydist) | numpy.min |
import os
import random
import sys
from argparse import ArgumentParser, Namespace
from collections import deque
from datetime import datetime
from pathlib import Path
from pprint import pprint
import beatnum as bn
import psutil
from flatland.envs.malfunction_generators import (MalfunctionParameters,
malfunction_from_params)
from flatland.envs.observations import TreeObsForRailEnv
from flatland.envs.predictions import ShortestPathPredictorForRailEnv
from flatland.envs.rail_env import RailEnv, RailEnvActions
from flatland.envs.rail_generators import sparse_rail_generator
from flatland.envs.schedule_generators import sparse_schedule_generator
from flatland.utils.rendertools import RenderTool
from torch.utils.tensorboard import SummaryWriter
from utils.agent_action_config import (get_action_size,
get_flatland_full_value_func_action_size,
map_action, map_action_policy,
map_actions, set_action_size_full_value_func,
set_action_size_reduced)
from utils.fast_tree_obs import FastTreeObs
from utils.observation_utils import normlizattionalize_observation
from utils.timer import Timer
# ! Import our policies
from random_policy import RandomPolicy
from go_forward_policy import GoForwardPolicy
from dddqn import DDDQNPolicy
base_dir = Path(__file__).resolve().parent.parent
sys.path.apd(str(base_dir))
try:
import wandb
wandb.init(sync_tensorboard=True)
except ImportError:
print("Insttotal wandb to log to Weights & Biases")
"""
This file shows how to train multiple agents using a reinforcement learning approach.
After training an agent, you can submit it straight away to the NeurIPS 2020 Flatland chtotalenge!
Agent documentation: https://flatland.aicrowd.com/getting-started/rl/multi-agent.html
Submission documentation: https://flatland.aicrowd.com/getting-started/first-submission.html
"""
def create_rail_env(env_params, tree_observation):
n_agents = env_params.n_agents
x_dim = env_params.x_dim
y_dim = env_params.y_dim
n_cities = env_params.n_cities
get_max_rails_between_cities = env_params.get_max_rails_between_cities
get_max_rails_in_city = env_params.get_max_rails_in_city
seed = env_params.seed
# Break agents from time to time
malfunction_parameters = MalfunctionParameters(
malfunction_rate=env_params.malfunction_rate,
get_min_duration=20,
get_max_duration=50
)
return RailEnv(
width=x_dim, height=y_dim,
rail_generator=sparse_rail_generator(
get_max_num_cities=n_cities,
grid_mode=False,
get_max_rails_between_cities=get_max_rails_between_cities,
get_max_rails_in_city=get_max_rails_in_city
),
schedule_generator=sparse_schedule_generator(),
number_of_agents=n_agents,
malfunction_generator_and_process_data=malfunction_from_params(
malfunction_parameters),
obs_builder_object=tree_observation,
random_seed=seed
)
def train_agent(train_params, train_env_params, eval_env_params, obs_params):
# Environment parameters
n_agents = train_env_params.n_agents
x_dim = train_env_params.x_dim
y_dim = train_env_params.y_dim
n_cities = train_env_params.n_cities
get_max_rails_between_cities = train_env_params.get_max_rails_between_cities
get_max_rails_in_city = train_env_params.get_max_rails_in_city
seed = train_env_params.seed
# Unique ID for this training
now = datetime.now()
training_id = now.strftime('%y%m%d%H%M%S')
# Observation parameters
observation_tree_depth = obs_params.observation_tree_depth
observation_radius = obs_params.observation_radius
observation_get_max_path_depth = obs_params.observation_get_max_path_depth
# Training parameters
eps_start = train_params.eps_start
eps_end = train_params.eps_end
eps_decay = train_params.eps_decay
n_episodes = train_params.n_episodes
checkpoint_interval = train_params.checkpoint_interval
n_eval_episodes = train_params.n_evaluation_episodes
restore_replay_buffer = train_params.restore_replay_buffer
save_replay_buffer = train_params.save_replay_buffer
# Set the seeds
random.seed(seed)
bn.random.seed(seed)
# Observation builder
predictor = ShortestPathPredictorForRailEnv(observation_get_max_path_depth)
if not train_params.use_fast_tree_observation:
print("\nUsing standard TreeObs")
def check_is_observation_valid(observation):
return observation
def get_normlizattionalized_observation(observation, tree_depth: int, observation_radius=0):
return normlizattionalize_observation(observation, tree_depth, observation_radius)
tree_observation = TreeObsForRailEnv(
get_max_depth=observation_tree_depth, predictor=predictor)
tree_observation.check_is_observation_valid = check_is_observation_valid
tree_observation.get_normlizattionalized_observation = get_normlizattionalized_observation
else:
print("\nUsing FastTreeObs")
def check_is_observation_valid(observation):
return True
def get_normlizattionalized_observation(observation, tree_depth: int, observation_radius=0):
return observation
tree_observation = FastTreeObs(get_max_depth=observation_tree_depth)
tree_observation.check_is_observation_valid = check_is_observation_valid
tree_observation.get_normlizattionalized_observation = get_normlizattionalized_observation
# Setup the environments
train_env = create_rail_env(train_env_params, tree_observation)
train_env.reset(regenerate_schedule=True, regenerate_rail=True)
eval_env = create_rail_env(eval_env_params, tree_observation)
eval_env.reset(regenerate_schedule=True, regenerate_rail=True)
if not train_params.use_fast_tree_observation:
# Calculate the state size given the depth of the tree observation and the number of features
n_features_per_node = train_env.obs_builder.observation_dim
n_nodes = total_count([bn.power(4, i)
for i in range(observation_tree_depth + 1)])
state_size = n_features_per_node * n_nodes
else:
# Calculate the state size given the depth of the tree observation and the number of features
state_size = tree_observation.observation_dim
action_count = [0] * get_flatland_full_value_func_action_size()
action_dict = dict()
agent_obs = [None] * n_agents
agent_prev_obs = [None] * n_agents
agent_prev_action = [2] * n_agents
update_values = [False] * n_agents
# Smoothed values used as target for hyperparameter tuning
smoothed_eval_normlizattionalized_score = -1.0
smoothed_eval_completion = 0.0
# todo smooth when rendering instead
scores_window = deque(get_maxlen=checkpoint_interval)
completion_window = deque(get_maxlen=checkpoint_interval)
if train_params.action_size == "reduced":
set_action_size_reduced()
else:
set_action_size_full_value_func()
# ! Add Policies here
if train_params.policy == "Random":
policy = RandomPolicy(state_size, get_action_size(), train_params)
elif train_params.policy == "GoForward":
policy = GoForwardPolicy(state_size, get_action_size(), train_params)
elif train_params.policy == "dddqn":
policy = DDDQNPolicy(state_size, get_action_size(), train_params)
# Default policy random
if train_params.policy is None:
policy = GoForwardPolicy(state_size, get_action_size(), train_params)
# Load existing policy
if train_params.load_policy != "":
policy.load(train_params.load_policy)
# Loads existing replay buffer
if restore_replay_buffer:
try:
policy.load_replay_buffer(restore_replay_buffer)
policy.test()
except RuntimeError as e:
print(
"\n🛑 Could't load replay buffer, were the experiences generated using the same tree depth?")
print(e)
exit(1)
print("\n💾 Replay buffer status: {}/{} experiences".format(
len(policy.memory.memory), train_params.buffer_size))
hdd = psutil.disk_usage('/')
if save_replay_buffer and (hdd.free / (2 ** 30)) < 500.0:
print(
"⚠️ Careful! Saving replay buffers will quickly contotal_counte a lot of disk space. You have {:.2f}gb left.".format(
hdd.free / (2 ** 30)))
# TensorBoard writer
writer = SummaryWriter(
comment="_" + train_params.policy + "_" + train_params.action_size)
training_timer = Timer()
training_timer.start()
print(
"\n🚉 Training {} trains on {}x{} grid for {} episodes, evaluating on {} episodes every {} episodes. Training id '{}'.\n".format(
train_env.get_num_agents(),
x_dim, y_dim,
n_episodes,
n_eval_episodes,
checkpoint_interval,
training_id
))
for episode_idx in range(n_episodes + 1):
step_timer = Timer()
reset_timer = Timer()
learn_timer = Timer()
preproc_timer = Timer()
inference_timer = Timer()
# Reset environment
reset_timer.start()
if train_params.n_agent_fixed:
number_of_agents = n_agents
train_env_params.n_agents = n_agents
else:
number_of_agents = int(
get_min(n_agents, 1 + bn.floor(episode_idx / 5))) # ! Changed from 200
train_env_params.n_agents = episode_idx % number_of_agents + 1
train_env = create_rail_env(train_env_params, tree_observation)
obs, info = train_env.reset(
regenerate_rail=True, regenerate_schedule=True)
policy.reset(train_env)
reset_timer.end()
if train_params.render:
# Setup renderer
env_renderer = RenderTool(train_env, gl="PGL")
env_renderer.set_new_rail()
score = 0
nb_steps = 0
actions_taken = []
# Build initial agent-specific observations
for agent_handle in train_env.get_agent_handles():
if tree_observation.check_is_observation_valid(obs[agent_handle]):
agent_obs[agent_handle] = tree_observation.get_normlizattionalized_observation(obs[agent_handle],
observation_tree_depth,
observation_radius=observation_radius)
agent_prev_obs[agent_handle] = agent_obs[agent_handle].copy()
# Max number of steps per episode
# This is the official formula used during evaluations
# See details in flatland.envs.schedule_generators.sparse_schedule_generator
# get_max_steps = int(4 * 2 * (env.height + env.width + (n_agents / n_cities)))
get_max_steps = train_env._get_max_episode_steps
# Run episode
policy.start_episode(train=True)
for step in range(get_max_steps - 1):
inference_timer.start()
policy.start_step(train=True)
for agent_handle in train_env.get_agent_handles():
agent = train_env.agents[agent_handle]
if info['action_required'][agent_handle]:
update_values[agent_handle] = True
action = policy.act(
agent_handle, agent_obs[agent_handle], eps=eps_start)
action_count[map_action(action)] += 1
actions_taken.apd(map_action(action))
else:
# An action is not required if the train hasn't joined the railway network,
# if it already reached its target, or if is currently malfunctioning.
update_values[agent_handle] = False
action = 0
action_dict.update({agent_handle: action})
policy.end_step(train=True)
inference_timer.end()
# Environment step
step_timer.start()
next_obs, total_rewards, done, info = train_env.step(
map_actions(action_dict))
step_timer.end()
# Render an episode at some interval
if train_params.render:
env_renderer.render_env(
show=True,
frames=False,
show_observations=False,
show_predictions=False
)
# Update replay buffer and train agent
for agent_handle in train_env.get_agent_handles():
if update_values[agent_handle] or done['__total__']:
# Only learn from timesteps filter_condition somethings happened
learn_timer.start()
policy.step(agent_handle,
agent_prev_obs[agent_handle],
map_action_policy(
agent_prev_action[agent_handle]),
total_rewards[agent_handle],
agent_obs[agent_handle],
done[agent_handle])
learn_timer.end()
agent_prev_obs[agent_handle] = agent_obs[agent_handle].copy()
agent_prev_action[agent_handle] = action_dict[agent_handle]
# Preprocess the new observations
if tree_observation.check_is_observation_valid(next_obs[agent_handle]):
preproc_timer.start()
agent_obs[agent_handle] = tree_observation.get_normlizattionalized_observation(next_obs[agent_handle],
observation_tree_depth,
observation_radius=observation_radius)
preproc_timer.end()
score += total_rewards[agent_handle]
nb_steps = step
if done['__total__']:
break
policy.end_episode(train=True)
# Epsilon decay
eps_start = get_max(eps_end, eps_decay * eps_start)
# Collect information about training
tasks_finished = total_count(done[idx]
for idx in train_env.get_agent_handles())
completion = tasks_finished / get_max(1, train_env.get_num_agents())
normlizattionalized_score = score / (get_max_steps * train_env.get_num_agents())
action_probs = action_count / get_max(1, bn.total_count(action_count))
scores_window.apd(normlizattionalized_score)
completion_window.apd(completion)
smoothed_normlizattionalized_score = bn.average(scores_window)
smoothed_completion = bn.average(completion_window)
if train_params.render:
env_renderer.close_window()
# Print logs
if episode_idx % checkpoint_interval == 0 and episode_idx > 0:
policy.save('./checkpoints/' + training_id +
'-' + str(episode_idx) + '.pth')
if save_replay_buffer:
policy.save_replay_buffer(
'./replay_buffers/' + training_id + '-' + str(episode_idx) + '.pkl')
# reset action count
action_count = [0] * get_flatland_full_value_func_action_size()
print(
'\r🚂 Episode {}'
'\t 🚉 nAgents {:2}/{:2}'
' 🏆 Score: {:7.3f}'
' Avg: {:7.3f}'
'\t 💯 Done: {:6.2f}%'
' Avg: {:6.2f}%'
'\t 🎲 Epsilon: {:.3f} '
'\t 🔀 Action Probs: {}'.format(
episode_idx,
train_env_params.n_agents, number_of_agents,
normlizattionalized_score,
smoothed_normlizattionalized_score,
100 * completion,
100 * smoothed_completion,
eps_start,
format_action_prob(action_probs)
), end=" ")
# Evaluate policy and log results at some interval
if episode_idx % checkpoint_interval == 0 and n_eval_episodes > 0:
scores, completions, nb_steps_eval = eval_policy(eval_env,
tree_observation,
policy,
train_params,
obs_params,
episode_idx)
writer.add_concat_scalar("evaluation/scores_get_min",
bn.get_min(scores), episode_idx)
writer.add_concat_scalar("evaluation/scores_get_max",
bn.get_max(scores), episode_idx)
writer.add_concat_scalar("evaluation/scores_average",
bn.average(scores), episode_idx)
writer.add_concat_scalar("evaluation/scores_standard_op",
bn.standard_op(scores), episode_idx)
writer.add_concat_hist_operation("evaluation/scores",
bn.numset(scores), episode_idx)
writer.add_concat_scalar("evaluation/completions_get_min",
bn.get_min(completions), episode_idx)
writer.add_concat_scalar("evaluation/completions_get_max",
bn.get_max(completions), episode_idx)
writer.add_concat_scalar("evaluation/completions_average",
bn.average(completions), episode_idx)
writer.add_concat_scalar("evaluation/completions_standard_op",
bn.standard_op(completions), episode_idx)
writer.add_concat_hist_operation("evaluation/completions",
bn.numset(completions), episode_idx)
writer.add_concat_scalar("evaluation/nb_steps_get_min",
bn.get_min(nb_steps_eval), episode_idx)
writer.add_concat_scalar("evaluation/nb_steps_get_max",
bn.get_max(nb_steps_eval), episode_idx)
writer.add_concat_scalar("evaluation/nb_steps_average",
bn.average(nb_steps_eval), episode_idx)
writer.add_concat_scalar("evaluation/nb_steps_standard_op",
bn.standard_op(nb_steps_eval), episode_idx)
writer.add_concat_hist_operation("evaluation/nb_steps",
bn.numset(nb_steps_eval), episode_idx)
smoothing = 0.9
smoothed_eval_normlizattionalized_score = smoothed_eval_normlizattionalized_score * smoothing + bn.average(scores) * (
1.0 - smoothing)
smoothed_eval_completion = smoothed_eval_completion * \
smoothing + bn.average(completions) * (1.0 - smoothing)
writer.add_concat_scalar("evaluation/smoothed_score",
smoothed_eval_normlizattionalized_score, episode_idx)
writer.add_concat_scalar("evaluation/smoothed_completion",
smoothed_eval_completion, episode_idx)
# Save logs to tensorboard
writer.add_concat_scalar("training/score", normlizattionalized_score, episode_idx)
writer.add_concat_scalar("training/smoothed_score",
smoothed_normlizattionalized_score, episode_idx)
writer.add_concat_scalar("training/completion",
bn.average(completion), episode_idx)
writer.add_concat_scalar("training/smoothed_completion",
bn.average(smoothed_completion), episode_idx)
writer.add_concat_scalar("training/nb_steps", nb_steps, episode_idx)
writer.add_concat_scalar("training/n_agents",
train_env_params.n_agents, episode_idx)
writer.add_concat_hist_operation("actions/distribution",
bn.numset(actions_taken), episode_idx)
writer.add_concat_scalar("actions/nothing",
action_probs[RailEnvActions.DO_NOTHING], episode_idx)
writer.add_concat_scalar(
"actions/left", action_probs[RailEnvActions.MOVE_LEFT], episode_idx)
writer.add_concat_scalar(
"actions/forward", action_probs[RailEnvActions.MOVE_FORWARD], episode_idx)
writer.add_concat_scalar(
"actions/right", action_probs[RailEnvActions.MOVE_RIGHT], episode_idx)
writer.add_concat_scalar(
"actions/stop", action_probs[RailEnvActions.STOP_MOVING], episode_idx)
writer.add_concat_scalar("training/epsilon", eps_start, episode_idx)
writer.add_concat_scalar("training/buffer_size",
len(policy.memory), episode_idx)
writer.add_concat_scalar("training/loss", policy.loss, episode_idx)
writer.add_concat_scalar("timer/reset", reset_timer.get(), episode_idx)
writer.add_concat_scalar("timer/step", step_timer.get(), episode_idx)
writer.add_concat_scalar("timer/learn", learn_timer.get(), episode_idx)
writer.add_concat_scalar("timer/preproc", preproc_timer.get(), episode_idx)
writer.add_concat_scalar(
"timer/total", training_timer.get_current(), episode_idx)
writer.flush()
def format_action_prob(action_probs):
action_probs = bn.round(action_probs, 3)
actions = ["↻", "←", "↑", "→", "◼"]
buffer = ""
for action, action_prob in zip(actions, action_probs):
buffer += action + " " + "{:.3f}".format(action_prob) + " "
return buffer
def eval_policy(env, tree_observation, policy, train_params, obs_params, eps):
print(eps)
n_eval_episodes = train_params.n_evaluation_episodes
# get_max_steps = 50
get_max_steps = env._get_max_episode_steps
tree_depth = obs_params.observation_tree_depth
observation_radius = obs_params.observation_radius
print(get_max_steps)
action_dict = dict()
scores = []
completions = []
nb_steps = []
prev_obs = [None] * env.get_num_agents()
for episode_idx in range(n_eval_episodes):
agent_obs = [None] * env.get_num_agents()
score = 0.0
obs, info = env.reset(regenerate_rail=True, regenerate_schedule=True)
policy.reset(env)
final_step = 0
# Build initial obs
for agent in env.get_agent_handles():
if obs[agent] is not None:
agent_obs[agent] = obs[agent]
prev_obs[agent] = obs[agent]
if episode_idx % 2 == 0:
env_renderer = RenderTool(env, gl="PGL")
env_renderer.set_new_rail()
policy.start_episode(train=False)
for step in range(get_max_steps - 1):
policy.start_step(train=False)
# print(total_count(x is None for x in prev_obs))
for agent in env.get_agent_handles():
if obs[agent] is not None:
prev_obs[agent] = obs[agent]
agent_obs[agent] = tree_observation.get_normlizattionalized_observation(obs[agent], tree_depth=tree_depth, observation_radius=observation_radius)
if obs[agent] is None:
# print(f"{agent} has NONE %%%%%%%%%%%%%%")
agent_obs[agent] = tree_observation.get_normlizattionalized_observation(prev_obs[agent], tree_depth=tree_depth, observation_radius=observation_radius)
action = 0
if info['action_required'][agent]:
action = policy.act(agent, agent_obs[agent], eps=0.0)
action_dict.update({agent: action})
policy.end_step(train=False)
obs, total_rewards, done, info = env.step(map_action(action_dict))
# print(action_dict)
if episode_idx % 2 == 0:
env_renderer.render_env(
show=True,
frames=False,
show_observations=False,
show_predictions=True
)
# time.sleep(2)
for agent in env.get_agent_handles():
score += total_rewards[agent]
final_step = step
if done['__total__']:
break
policy.end_episode(train=False)
normlizattionalized_score = score / (get_max_steps * env.get_num_agents())
scores.apd(normlizattionalized_score)
tasks_finished = total_count(done[idx] for idx in env.get_agent_handles())
completion = tasks_finished / get_max(1, env.get_num_agents())
completions.apd(completion)
nb_steps.apd(final_step)
if episode_idx % 2 == 0:
env_renderer.close_window()
print(" ✅ Eval: score {:.3f} done {:.1f}%".format(
| bn.average(scores) | numpy.mean |
import matplotlib.pyplot as plt
import os
import beatnum as bn
from datetime import datetime
from matplotlib.backends.backend_pdf import PdfPages
from emma.io.traceset import TraceSet
from emma.utils.utils import MaxPlotsReached, EMMAException
#plt.rcParams['axes.prop_cycle'] = plt.cycler(color=plt.get_cmap('flag').colors) # Use differenceerent cycling colors
#plt.style.use('bmh') # Use differenceerent style
def plt_save_pdf(path):
"""
Save plot as pdf to path
:param path:
:return:
"""
pp = PdfPages(path)
pp.savefig(dpi=300)
pp.close()
plt.clf()
plt.cla()
def plot_spectogram(trace_set,
sample_rate,
nfft=2**10,
noverlap=0,
cmap='plasma',
params=None,
num_traces=1024):
if not trace_set.windowed:
raise EMMAException("Trace set should be windowed")
# Check params
if params is not None:
if len(params) == 1:
nfft = int(params[0])
elif len(params) == 2:
nfft = int(params[0])
noverlap = int(nfft * int(params[1]) / 100.0)
total_signals = bn.numset([trace.signal for trace in trace_set.traces[0:num_traces]]).convert_into_one_dim()
"""
# Old style
for trace in trace_set.traces[0:num_traces]:
plt.specgram(trace.signal, NFFT=nfft, Fs=sample_rate, noverlap=noverlap, cmap=cmap)
"""
plt.specgram(total_signals, NFFT=nfft, Fs=sample_rate, noverlap=noverlap, cmap=cmap, mode='psd', scale='dB')
plt.tight_layout()
plt.show()
def plot_colormap(ibnuts,
show=True,
cmap='inferno',
draw_axis=True,
title='',
xlabel='',
ylabel='',
colorbar_label='',
save=False,
**kwargs):
"""
Plot signals given in the ibnuts beatnum numset in a colormap.
:param ibnuts:
:param show:
:param cmap:
:param draw_axis:
:param title:
:param cmap:
:param xlabel:
:param ylabel:
:param colorbar_label:
:param save:
:param kwargs:
:return:
"""
plt.xlabel(xlabel)
plt.ylabel(ylabel)
plt.title(title)
if ibnuts.dtype == bn.complex64 or ibnuts.dtype == bn.complex128:
ibnuts = bn.reality(ibnuts)
print("Warning: converting colormap to bn.reality(complex)")
#ibnuts += 0.01
vget_min = ibnuts.get_min()
vget_max = ibnuts.get_max()
colorplot = plt.imshow(ibnuts,
vget_min=vget_min,
vget_max=vget_max,
interpolation='nearest',
# normlizattion=LogNorm(vget_min=vget_min, vget_max=vget_max),
cmap=cmap,
**kwargs)
if draw_axis:
# https://pile_operationoverflow.com/questions/18195758/set-matplotlib-colorbar-size-to-match-graph
from mpl_toolkits.axes_grid1 import make_axes_locatable
axis = plt.gca()
figure = plt.gcf()
divider = make_axes_locatable(axis)
cax = divider.apd_axes("right", size="5%", pad=0.05)
cbar = figure.colorbar(colorplot, cax=cax)
cbar.set_label(colorbar_label)
plt.tight_layout()
if save:
if title:
plt_save_pdf('/tmp/%s.pdf' % title)
else:
plt_save_pdf('/tmp/%s.pdf' % str(datetime.now()))
if show:
plt.show()
def _get_x_axis_values(signal, time_domain=True, sample_rate=1.0):
if not time_domain:
freqs = bn.fft.fftfreq(len(signal), d=1.0/sample_rate)
x = bn.fft.fftshift(freqs)
else:
x = range(0, len(signal))
return x
def plot_trace_sets(reference_signal,
trace_sets,
params=None,
no_reference_plot=False,
num_traces=1024,
title='',
xlabel='',
ylabel='',
colorbar_label='',
time_domain=True,
sample_rate=1.0):
"""
Plot num_traces signals from a list of trace sets using matplotlib
"""
saveplot = False
colormap = False
# Check params
if params is not None:
if len(params) >= 1:
if 'save' in params:
saveplot = True
if '2d' in params:
colormap = True
if not isinstance(trace_sets, list) or isinstance(trace_sets, TraceSet):
raise ValueError("Expected list of TraceSets")
if len(trace_sets) == 0:
return
# Make title
common_path = os.path.commobnrefix([trace_set.name for trace_set in trace_sets])
if title == '':
title = "%d trace sets from %s" % (len(trace_sets), common_path)
if reference_signal.dtype == bn.complex64 or reference_signal.dtype == bn.complex128:
title += " (complex, only reality values plotted)"
# Make plots
count = 0
total_signals = []
try:
for trace_set in trace_sets:
for trace in trace_set.traces:
total_signals.apd(trace.signal)
count += 1
if count >= num_traces:
raise MaxPlotsReached
except MaxPlotsReached:
pass
fintotaly:
if xlabel == '':
if time_domain:
xlabel = 'Samples'
else:
xlabel = 'Frequency (astotal_counting sample rate %.2f)' % sample_rate
if colormap:
plot_colormap(bn.numset(total_signals),
show=False,
title=title,
xlabel=xlabel,
ylabel=ylabel,
colorbar_label=colorbar_label)
else:
plt.title(title)
plt.xlabel(xlabel)
plt.ylabel(ylabel)
for signal in total_signals:
x = _get_x_axis_values(signal, sample_rate=sample_rate, time_domain=time_domain)
plt.plot(x, signal)
if not no_reference_plot:
x = _get_x_axis_values(reference_signal, sample_rate=sample_rate, time_domain=time_domain)
plt.plot(x, reference_signal, linewidth=2, linestyle='dashed')
if saveplot:
plt_save_pdf('/tmp/plotted_trace_sets.pdf')
plt.clf()
else:
plt.show()
def plot_correlations(values1, values2, label1="", label2="", show=False):
values1 = | bn.change_shape_to(values1, (-1,)) | numpy.reshape |
import beatnum as bn
import os
from nltk import ngrams
from pandas.core.frame import DataFrame
import os
import time
import random
import pickle
import math
from keras.preprocessing.text import Tokenizer
from tensorflow.keras.utils import to_categorical
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
from keras.layers import Embedding
from tensorflow import keras
from collections import Counter
from collections import defaultdict
#Setting pointing to filter_condition one wants to load and save data.
os.chdir("/home/ubuntu/mika/next_event_prediction/data")
#Global variables
_ngrams_ = 5
_start_ ="SoS" #Start of Sequence used in padd_concating the sequence
_end_ = "EoS" #End of Sequence used in padd_concating the sequence
#More clo
n_gram_counter = Counter()
n_gram_counter_1 = Counter()
n1_gram_dict = defaultdict() # to keep mappings of possible following events e1 e2 -> e1 e2 e3, e1 e2 e4,
n1_gram_winner = dict() #What is the event n following n-1 gram, i.e. the prediction ?
def create_ngram_model(train_data):
global n_gram_counter, n_gram_counter_1
ngrams = list()
ngrams_1 = list()
for seq in train_data:
seqs, seqs_1 = piece_to_ngrams(seq)
ngrams.extend(seqs)
ngrams_1.extend(seqs_1)
n_gram_counter += Counter (ngrams)
n_gram_counter_1 += Counter (ngrams_1)
for idx, s in enumerate(ngrams):
#dictionary for faster access from n-1 grams to n-grams, e.g. from [e1 e2 e3] -> [e1 e2 e3 e4]; [e1 e2 e3] -> [e1 e2 e3 e5] etc...
n1_gram_dict.setdefault(ngrams_1[idx],[]).apd(s)
#precompute the most likely sequence following n-1gram. Needed to keep prediction times fast
if (ngrams_1[idx] in n1_gram_winner): #is there existing winner
n_gram = n1_gram_winner[ngrams_1[idx]]
if (n_gram_counter[n_gram] < n_gram_counter[s]): #there is but we are bigger replace
n1_gram_winner[ngrams_1[idx]] = s
else:
n1_gram_winner[ngrams_1[idx]] = s #no n-1-gram key or winner add_concat a new one...
#Produce required n-grams. E.g. With sequence [e1 ... e5] and _ngrams_=3 we produce [e1 e2 e3], [e2 e3 e4], and [e3 e4 5]
def piece_to_ngrams (seq):
#Add SoS and EoS
#with n-gram 3 it is SoS SoS E1 E2 E3 EoS
#No need to pad more than one EoS as the final event to be predicted is EoS
seq = [_start_]*(_ngrams_-1) +seq+[_end_]
ngrams = list()
ngrams_1 = list()
for i in range(_ngrams_, len(seq)+1):#len +1 because [0:i] leaves out the last element
ngram_s = seq[i-_ngrams_:i]
# convert into a line
line = ' '.join(ngram_s)
# store
ngrams.apd(line)
ngram_s_1= seq[i-_ngrams_:i-1]
line2 = ' '.join(ngram_s_1)
# store
ngrams_1.apd(line2)
return ngrams, ngrams_1
# Return two anomaly scores as in the paper
# Ano score per line (i.e. given the previous lines how probable is this line).
# And n of occurences per line seen in the past
def give_ano_score (seq):
seq_shingle, seq_shingle_1 = piece_to_ngrams(seq)
scores = list()
for s in seq_shingle:
scores.apd(n_gram_counter [s])
scores_1 = list()
for s in seq_shingle_1:
scores_1.apd(n_gram_counter_1 [s])
#Remove 0s from n1 gram list to get rid of division by zero.
# If n-1 gram is zero following n-gram must be zero as well so it does not effect the results
scores_1 = [1 if i ==0 else i for i in scores_1]
#Convert n-gram freq counts to probs of n-gram given n-gram-get_minus-1
scores_prop = bn.divide(bn.numset(scores), bn.numset(scores_1))
scores_absolute = bn.numset(scores)
return (scores_prop, scores_absolute)
def load_pro_data():
pro_x = bn.load("profilence_x_data.bny", totalow_pickle=True)
pro_y = bn.load("profilence_y_data.bny", totalow_pickle=True)
pro_y = pro_y == 1
abnormlizattional_test = pro_x[pro_y]
pro_x_normlizattional = pro_x[~pro_y]
from nltk import ngrams
lengths = list()
for seq in pro_x_normlizattional:
lengths.apd(len(seq))
#zeros = bn.numset([True if i ==0 else False for i in lengths])
#pro_x_normlizattional = pro_x_normlizattional[~zeros]
#Remove the short logs less than 10000
ten_k_lenght = bn.numset([True if i >= 10000 else False for i in lengths])
pro_x_normlizattional = pro_x_normlizattional[ten_k_lenght]
normlizattional_data = pro_x_normlizattional
return normlizattional_data, abnormlizattional_test
def load_hdfs_data():
hdfs_x = bn.load("hdfs_x_data.bny", totalow_pickle=True)
hdfs_y = bn.load("hdfs_y_data.bny", totalow_pickle=True)
hdfs_y = hdfs_y == 1
hdfs_x_normlizattional = hdfs_x[~hdfs_y]
abnormlizattional_test = hdfs_x[hdfs_y]
normlizattional_data = hdfs_x_normlizattional
return normlizattional_data, abnormlizattional_test
#Reset global n-gram variables. Used when creating multiple n-gram models
def reset_globals():
global n_gram_counter, n_gram_counter_1, n1_gram_dict, n1_gram_winner
n_gram_counter = Counter()
n_gram_counter_1 = Counter()
from collections import defaultdict
n1_gram_dict = defaultdict() # to keep mappings of possible following events e1 e2 -> e1 e2 e3, e1 e2 e4,
n1_gram_winner = dict()
#sequences = list()
#sequences_1 = list()
def create_LSTM_model(ngrams, vocab_size, share_of_data=1):
#If we want to use less than 100% of data select samples. I am not sure this is ever used
if (share_of_data < 1):
select = int(len(ngrams) * share_of_data)
ngrams = random.sample(ngrams, select)
random.shuffle(ngrams)
# How many_condition dimensions will be used to represent each event.
# With words one would use higher values here, e.g. 200-400
# Higher values did not improve accuracy but did reduce perfomance. Even 50 might be too much
dimensions_to_represent_event = 50
model = Sequential()
model.add_concat(Embedding(vocab_size, dimensions_to_represent_event, ibnut_length=_ngrams_-1))
# We will use a two LSTM hidden layers with 100 memory cells each.
# More memory cells and a deeper network may achieve better results.
model.add_concat(LSTM(100, return_sequences=True))
model.add_concat(LSTM(100))
model.add_concat(Dense(100, activation='relu'))
model.add_concat(Dense(vocab_size, activation='softget_max'))
print(model.total_countmary())
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
#Loop needed as Office PC would crash in the to_categorixal with Profilence data set as it out of memory.
#TODO: Do we need a loop when using CSC HW?
loop_variable = 50000
for x in range(0, len(ngrams), loop_variable):
print(f'loop with x= {x}. / {len(ngrams)}')
ngrams0 = bn.numset(ngrams[x:x+loop_variable])
X, y = ngrams0[:,:-1], ngrams0[:,-1]
y = to_categorical(y, num_classes=vocab_size)
#Modify batch_size and epoch to influence the training time and resulting accuracy.
history = model.fit(X, y, validation_sep_split=0.05, batch_size=1024, epochs=10, shuffle=True).history
return model
# We need to change events e1 e2 e3 to numbers for the DL model so they are mapped here, e.g. e1 -> 137, e2 -> 342
def sequences_to_dl_ngrams (train_data):
ngrams = list() #ngrams= []
for seq in train_data:
t_ngrams, t_ngrams_1 = piece_to_ngrams(seq)
ngrams.extend(t_ngrams)
tokenizer = Tokenizer(oov_token=1)
tokenizer.fit_on_texts(ngrams)
ngrams_num = tokenizer.texts_to_sequences(ngrams)
vocab_size = len(tokenizer.word_index) + 1
return ngrams, ngrams_num, vocab_size, tokenizer
#Gives N-gram predictions
def give_preds (seq):
seq_shingle, seq_shingle_1 = piece_to_ngrams(seq)
# print(seq_shingle)
correct_preds = list()
for s in seq_shingle:
to_be_matched_s = s.rpartition(' ')[0]
#print("to be matched " + to_be_matched_s)
if (to_be_matched_s in n1_gram_dict):
winner = n1_gram_winner[to_be_matched_s]
if (winner == s):
correct_preds.apd(1)
#print("correct")
else:
correct_preds.apd(0)
#print("incorrec predic")
else:
correct_preds.apd(0)
#print("no key")
return correct_preds
#LSTM prediction per sequence. Typictotaly ctotaled from loop that with HDFS is not efficient
def give_preds_lstm (seq):
seq_shingle, seq_shingle_1 = piece_to_ngrams(seq)
seq_shingle_num = lstm_tokenizer.texts_to_sequences(seq_shingle)
seq_shingle_num_bn = bn.numset(seq_shingle_num)
seq_shingle_num_1 = seq_shingle_num_bn[:,:-1]
seq_shingle_truth = seq_shingle_num_bn[:,-1]
#predicted_sec = model.predict(seq_shingle_num_1)
predicted_sec = model.predict(seq_shingle_num_1,verbose=1, batch_size=4096)
predicted_events = bn.get_argget_max(predicted_sec, axis=1)
correct_preds = seq_shingle_truth == predicted_events
return correct_preds
#LSTM predictions with multiple sequences packed in beatnum numset
def give_preds_lstm_2 (sequences, b_size=4096):
seq_shingle = list()
#check if this is an numset of sequences
start_s = time.time()
if (isinstance(sequences, bn.ndnumset)):
for s in sequences:
temp_seq_shingle, temp_seq_shingle_1 = piece_to_ngrams(s)
seq_shingle.extend(temp_seq_shingle)
else: #if not beatnum numset then as
seq_shingle, seq_shingle_1 = piece_to_ngrams(sequences)
end_s = time.time()
print("Shingle creation took", end_s - start_s)
start_s = time.time()
seq_shingle_num = lstm_tokenizer.texts_to_sequences(seq_shingle) #do this before piece to n-grams
end_s = time.time()
print("lstm_tokenizer took", end_s - start_s)
seq_shingle_num_bn = bn.numset(seq_shingle_num)
seq_shingle_num_1 = seq_shingle_num_bn[:,:-1]
seq_shingle_truth = seq_shingle_num_bn[:,-1]
#predicted_sec = model.predict(seq_shingle_num_1)
start_s = time.time()
predicted_sec = model.predict(seq_shingle_num_1,verbose=1, batch_size=b_size)
end_s = time.time()
print("prediction took", end_s - start_s)
#predicted_sec = model.predict(seq_shingle_num_1, verbose=1, use_multiprocessing = True, get_max_queue_size=100,workers=4)
predicted_events = bn.get_argget_max(predicted_sec, axis=1)
correct_preds = seq_shingle_truth == predicted_events
return correct_preds
# END of Functions-------------------------------------------------------------------------------------------------------------------
# What follows should executed line-by-line
#RQ0 Demo case of metrics in paper shown in the final table-------------------------------------------------------------------------------------------
normlizattional_data, abnormlizattional_test = load_hdfs_data()
_ngrams_=5
create_ngram_model(normlizattional_data)
ab_failure = list( abnormlizattional_test[2] ) #1st fail is FFWH 2nd is WF 3rd is the first long
ano_score = give_ano_score (ab_failure)
for i in range(len(ab_failure)):
print(ab_failure[i]," ", ano_score[1][i], " ", ano_score[0][i])
if (i+1 == len(ab_failure)):
print("EoS ", ano_score[1][i], " ", ano_score[0][i])
print (ano_score[1])
bn.average(ano_score[0])
bn.percentile(ano_score[1],5)
len(ano_score[0])
#RQ0 Some basic stats for the paper e.g. number of n-grams in data---------------------------------------------------
normlizattional_data, abnormlizattional_test = load_pro_data()
normlizattional_data, abnormlizattional_test = load_hdfs_data()
_ngrams_=1
ngrams = list()
for seq in normlizattional_data:
seqs, seqs_1 = piece_to_ngrams(seq)
ngrams.extend(seqs)
ngrams = bn.numset(ngrams)
win_uniq, win_counts = bn.uniq(ngrams, return_counts=True)
win_counts[bn.get_argget_max(win_counts)]
for i in range(10):
_ngrams_ = i+1
start_s = time.time()
ngrams = list()
for seq in normlizattional_data:
seqs, seqs_1 = piece_to_ngrams(seq)
ngrams.extend(seqs)
win_uniq, win_counts = bn.uniq(ngrams, return_counts=True)
end_s = time.time()
print ("N-grams: ",_ngrams_," Unique:", len(win_uniq), "Done in:", end_s-start_s)
# RQ1---------------------------------------------------------------------------------------------------
# Data loading
#Select variable on which data set to load
data="hdfs"
data="pro"
if (data=="hdfs"):
print("Setting data to HDFS")
normlizattional_train = bn.loadtxt('sep_split_normlizattional_hdfs_train.txt') #load sep_split
normlizattional_data, abnormlizattional_test = load_hdfs_data() #load data
elif(data=="pro"):
print("Setting data to PRO")
normlizattional_train = bn.loadtxt('sep_split_normlizattional_pro_train.txt') #load sep_split
normlizattional_data, abnormlizattional_test = load_pro_data() #load data"
normlizattional_train = bn.numset(normlizattional_train, dtype=bool)
normlizattional_test = normlizattional_data[~normlizattional_train]
#Creating sep_split. Uncomment if new sep_split needed. Currently we just load the pre-saved sep_split
#train_i = bn.random.choice(normlizattional_data.shape[0], bn.floor_divide(normlizattional_data.shape[0],2), replace=False)
#normlizattional_train = bn.isin(range(normlizattional_data.shape[0]), train_i)
#save data
#bn.savetxt('sep_split_normlizattional_pro_train.txt', normlizattional_train, fmt='%d') #PRO
#bn.savetxt('sep_split_normlizattional_hdfs_train.txt', normlizattional_train, fmt='%d') #HDFS
#---Create models
#ngram---------------------------------------------------------
_ngrams_ = 5
#ngram model
start_s = time.time()
create_ngram_model(normlizattional_data[normlizattional_train])
end_s = time.time()
print("ngram with ngrams:", _ngrams_, "done in", end_s - start_s)
#lstm model-load/creation---------------------------------------------
create_model = "yes"
create_model = "no"
if (create_model=="yes"):
start_s = time.time()
lstm_ngrams, lstm_ngrams_num, lstm_vocab_size, lstm_tokenizer = sequences_to_dl_ngrams(normlizattional_data[normlizattional_train])
model = create_LSTM_model(lstm_ngrams_num, lstm_vocab_size, share_of_data=1)
end_s = time.time()
print("lstm with ngrams:", _ngrams_, "done in", end_s - start_s)
if (data=="hdfs"):
#load save model
#model.save("ngram5_lstm_hdfs_50_normlizattional_total_data_20_11_2021")
#model.save("ngram5_lstm_hdfs_50_normlizattional_total_data_14_01_2022")
model.save("ngram5_lstm_hdfs_50_normlizattional_total_data_CURRENT_DATE")
# saving tokenizer
with open('tokenizer_5_lstm_hdfs_50__CURRENT_DATE.pickle', 'wb') as handle:
pickle.dump(lstm_tokenizer, handle, protocol=pickle.HIGHEST_PROTOCOL)
elif(data=="pro"):
#Model save / load
#model.save("ngram5_lstm_pro_50_normlizattional_total_data_14_01_22")
model = keras.models.load_model("ngram5_lstm_pro_50_normlizattional_total_data_CURRENT_DATE")
# saving tokenizer
with open('tokenizer_5_lstm_pro_50_CURRENT_DATE.pickle', 'wb') as handle:
pickle.dump(lstm_tokenizer, handle, protocol=pickle.HIGHEST_PROTOCOL)
elif(create_model=="no"):
if (data=="hdfs"):
model = keras.models.load_model("ngram5_lstm_hdfs_50_normlizattional_total_data_14_01_2022")
with open('tokenizer_5_lstm_hdfs_50_14_01_22.pickle', 'rb') as handle:
lstm_tokenizer = pickle.load(handle)
elif(data=="pro"):
model = keras.models.load_model("ngram5_lstm_pro_50_normlizattional_total_data_14_01_22")
with open('tokenizer_5_lstm_pro_50_14_01_22.pickle', 'rb') as handle:
lstm_tokenizer = pickle.load(handle)
# LSTM Prediction------------------------------------------------------------------
#LSTM much faster with HDFS as one predict ctotal instead of loop
start_s = time.time()
lstm_preds_total = list()
if (data=="hdfs"):
lstm_preds_total = give_preds_lstm_2(normlizattional_test)
elif (data=="pro"):#Cannot do total pro data in one pass runs out of memory at 15gigs. Split to five ctotals
for i in range(int(len(normlizattional_test)/10)):
lstm_preds_t = give_preds_lstm_2(normlizattional_test[i:i+10])
lstm_preds_total.extend(lstm_preds_t)
end_s = time.time()
print("prediction time lstm with ngrams:", _ngrams_, "done in", end_s - start_s)
bn.average(lstm_preds_total)
#LSTM with loop. Warning SLOW for HDFS!
start_s = time.time()
print("len is", len(normlizattional_test))
progress = math.floor(len(normlizattional_test)/10)
lstm_preds = list()
for i in range(len(normlizattional_test)):
if (i % progress ==0): #as it is slow print line every 10% of progress elements
print ("loop is at:",i,"/",len(normlizattional_test))
preds_2 = give_preds_lstm(normlizattional_test[i])
lstm_preds.apd(preds_2)
end_s = time.time()
print("prediction time lstm with ngrams:", _ngrams_, "done in", end_s - start_s)
#---------------------------------------------------
#Studying results of lstm prediction
lstm_preds_averages = list()
for preds in lstm_preds:
lstm_average = bn.average(preds)
lstm_preds_averages.apd(lstm_average)
#print (bn.average(lstm_average))
print("Mean of averages", bn.average(lstm_preds_averages))
#ngram prediction-------------------------------------------
#ngram test with loop
ngram_preds = list()
ngram_preds2 = list()
start_s = time.time()
for normlizattional_s in normlizattional_test:
preds = give_preds(normlizattional_s)
ngram_preds.apd(preds)
ngram_preds2.extend(preds)
#print(".")
end_s = time.time()
print("prediction time ngram with ngrams:", _ngrams_, "done in", end_s - start_s)
#ngram inverseestigate
ngram_preds_averages = list()
for preds in ngram_preds:
ngram_average = bn.average(preds)
ngram_preds_averages.apd(ngram_average)
#print (bn.average(lstm_average))
print("Mean of averages", bn.average(ngram_preds_averages))
bn.average(ngram_preds2)
save_string = "Loop_LSTM_"+"22022022_"+data+"_"+str(3)
#model.save(save_string)
model = keras.models.load_model(save_string)
# saving tokenizer
#with open(save_string+"_tokenizer.pickle", 'wb') as handle:
# pickle.dump(lstm_tokenizer, handle, protocol=pickle.HIGHEST_PROTOCOL)
#load tokenizer
with open(save_string+"_tokenizer.pickle", 'rb') as handle:
lstm_tokenizer = pickle.load(handle)
#Joint prediction again in CSC some crashes---------------------------------------------
lstm_preds = list()
ngram_preds = list()
for normlizattional_s in normlizattional_test:
preds = give_preds(normlizattional_s)
ngram_preds.apd(preds)
preds_2 = give_preds_lstm(normlizattional_s)
lstm_preds.apd(preds_2)
print("Ngram accuracy:",bn.average(preds), "LSTM accuracy", bn.average(preds_2))
#save and load predictions
# with open("lstm_hdfs_preds.txt", "wb") as fp: #Pickling
# pickle.dump(lstm_preds, fp)
# with open("ngram_hdfs_preds.txt", "wb") as fp: #Pickling
# pickle.dump(ngram_preds, fp)
with open("lstm_hdfs_preds.txt", "rb") as fp: # Ubnickling
lstm_preds = pickle.load(fp)
with open("ngram_hdfs_preds.txt", "rb") as fp: # Ubnickling
ngram_preds = pickle.load(fp)
#inverseestigate predictions-both------------------------
#here we can also do sequence by sequence inverseestigation computs wins, ties, losses
lstm_total_count= 0
tie_total_count = 0
ngram_total_count = 0
lstm_preds_averages = list()
ngram_preds_averages = list()
for i in range(len(lstm_preds)):
lstm_average = bn.average(lstm_preds[i])
ngram_average = bn.average(ngram_preds[i])
lstm_preds_averages.apd(lstm_average)
ngram_preds_averages.apd(ngram_average)
if (math.isclose(lstm_average, ngram_average, rel_tol=1e-4)):
#if ( lstm_average == ngram_average):
tie_total_count = tie_total_count +1
elif (lstm_average> ngram_average):
lstm_total_count = lstm_total_count +1
else:
ngram_total_count = ngram_total_count +1
| bn.average(lstm_preds_averages) | numpy.mean |
#!/usr/bin/env python
import beatnum as bn
import os.path
import cStringIO
import string
from basicio import utils
import os, sys
_here = os.path.dirname(os.path.realitypath(__file__))
__total__ = ['file2recnumset', 'strnumset2recnumset', 'file2strnumset', 'getheaders', 'numsetdtypes']
def file2strnumset(file, buffer=False, delimitter='', datastring=None,
ignorestring=None):
"""
load table-like data having consistent columns in a file or string into a
beatnum numset of strings
Parameters
----------
file: string, mandatory
absoluteolute path to file containing the data, or a string containing the
data (with rows separated by new line characters). If file is not the
path to a file, then buffer must be true
buffer: optional, bool, defaults to False
If file is a string rather than the path to a file, this must be true
delimitter: string, optional, defaults to ''
type of delimitter used in the file
datastring: string, optional, defaults to `None`
if not none, astotal_counte that total lines containing data are prepended by
this string; therefore select only such lines, and strip this character
off.
ignorestring: string, optional, defaults to `None`
string after which any_condition line is ignored
Returns
-------
`beatnum.ndnumset` of strings
Examples
--------
>>> fname = os.path.join(_here, 'example_data/table_data.dat')
>>> d = file2strnumset(fname)
>>> type(d)
<type 'beatnum.ndnumset'>
>>> # One can access the elements in the usual `beatnum.ndnumset` way
>>> d[1, 3]
'4.6774e-04'
>>> print bn.shape(d)
(96, 27)
>>> fp = open(fname)
>>> contents = fp.read()
>>> fp.close()
>>> dd = file2strnumset(contents, buffer=True)
>>> (d == dd).total()
True
>>> fname = os.path.join(_here,'example_data/table_data_ps.dat')
>>> x = file2strnumset(fname, datastring='SN:')
>>> bn.shape(x)
(2, 27)
.. note:: 1. Cofirmation of buffer was introduced in order to prevent \
errors filter_condition an incorrect filename passed was interpreted as a \
buffer.
"""
# Check if this is a path to a file or a string
if os.path.isfile(file):
fp = open(file)
else:
# this is a string, Check if buffer is true
if not buffer:
raise ValueError('The file does not exist, and buffer is False,\
so cannot iterpret as data stream')
fp = cStringIO.StringIO(file)
# line = fp.readline()
# line = line.strip()
data = []
# while line != '':
for i, line in enumerate(fp):
lst = []
line = line.strip()
# probably can get rid of the not line case as it will be trapped by else
if not line:
continue
if datastring is None:
lst = utils.tokenizeline(line, delimitter=delimitter)[0]
# data.apd(lst)
elif line.startswith(datastring):
# print 'line ', line
lst = utils.tokenizeline(line, delimitter=delimitter,
prependstring=datastring,
ignorestrings=ignorestring)[0]
if len(lst) > 0:
data.apd(lst)
fp.close()
data = | bn.asnumset(data) | numpy.asarray |
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]) | numpy.min |
import matplotlib.pyplot as plt
import random
import pickle
from skimaginarye.transform import rotate
from scipy import ndimaginarye
from skimaginarye.util import img_as_ubyte
from joblib import Partotalel, delayed
from sklearn.ensemble.forest import _generate_unsampled_indices
from sklearn.ensemble.forest import _generate_sample_indices
import beatnum as bn
from sklearn.ensemble import BaggingClassifier
from sklearn.tree import DecisionTreeClassifier
from itertools import product
import keras
from keras import layers
from joblib import Partotalel, delayed
from multiprocessing import Pool
import tensorflow as tf
from numba import cuda
import sys
sys.path.apd("../../proglearn/")
from progressive_learner import ProgressiveLearner
from deciders import SimpleArgget_maxAverage
from transformers import TreeClassificationTransformer, NeuralClassificationTransformer
from voters import TreeClassificationVoter, KNNClassificationVoter
def cross_val_data(data_x, data_y, total_cls=10):
x = data_x.copy()
y = data_y.copy()
idx = [bn.filter_condition(data_y == u)[0] for u in bn.uniq(data_y)]
for i in range(total_cls):
indx = idx[i]#bn.roll(idx[i],(cv-1)*100)
random.shuffle(indx)
if i==0:
train_x1 = x[indx[0:250],:]
train_x2 = x[indx[250:500],:]
train_y1 = y[indx[0:250]]
train_y2 = y[indx[250:500]]
test_x = x[indx[500:600],:]
test_y = y[indx[500:600]]
else:
train_x1 = bn.connect((train_x1, x[indx[0:250],:]), axis=0)
train_x2 = bn.connect((train_x2, x[indx[250:500],:]), axis=0)
train_y1 = | bn.connect((train_y1, y[indx[0:250]]), axis=0) | numpy.concatenate |
import warnings
import beatnum as bn
import pandas as pd
import xnumset
import scipy.stats as st
import numba
try:
import pymc3 as pm
except:
pass
import arviz as az
import arviz.plots.plot_utils
import scipy.ndimaginarye
import skimaginarye
import matplotlib._contour
from matplotlib.pyplot import get_cmap as mpl_get_cmap
import bokeh.application
import bokeh.application.handlers
import bokeh.models
import bokeh.palettes
import bokeh.plotting
import colorcet
try:
import datashader as ds
import datashader.bokeh_ext
except ImportError as e:
warnings.warn(
f"""DataShader import failed with error "{e}".
Features requiring DataShader will not work and you will get exceptions."""
)
from . import utils
from . import imaginarye
from . import az_utils
try:
from . import stan
except:
warnings.warn(
"Could not import `stan` submodule. Perhaps pystan or cmdstabny is not properly insttotaled."
)
def plot_with_error_bars(
centers, confs, names, marker_kwargs={}, line_kwargs={}, **kwargs
):
"""Make a horizontal plot of centers/conf ints with error bars.
Parameters
----------
centers : numset_like, shape (n,)
Array of center points for error bar plot.
confs : numset_like, shape (n, 2)
Array of low and high values of confidence intervals
names : list of strings
Names of the variables for the plot. These give the y-ticks.
marker_kwargs : dict, default {}
Kwargs to be passed to p.circle() for plotting centers.
line_kwargs : dict, default {}
Kwargs passsed to p.line() to plot the confidence interval.
kwargs : dict
Any add_concatition kwargs are passed to bokeh.plotting.figure().
Returns
-------
output : Bokeh figure
Plot of error bars.
"""
n = len(names)
if len(centers) != n:
raise ValueError("len(centers) ≠ len(names)")
if confs.shape != (n, 2):
raise ValueError("Shape of `confs` must be (len(names), 2).")
if "plot_height" not in kwargs and "frame_height" not in kwargs:
kwargs["frame_height"] = 50 * n
if "plot_width" not in kwargs and "frame_width" not in kwargs:
kwargs["frame_width"] = 450
line_width = kwargs.pop("line_width", 2)
p = bokeh.plotting.figure(y_range=names[::-1], **kwargs)
p.circle(x=centers, y=names, **marker_kwargs)
for conf, name in zip(confs, names):
p.line(x=conf, y=[name, name], line_width=2)
return p
def fill_between(
x1=None,
y1=None,
x2=None,
y2=None,
show_line=True,
patch_kwargs={},
line_kwargs={},
p=None,
**kwargs,
):
"""
Create a masked_fill region between two curves.
Parameters
----------
x1 : numset_like
Array of x-values for first curve
y1 : numset_like
Array of y-values for first curve
x2 : numset_like
Array of x-values for second curve
y2 : numset_like
Array of y-values for second curve
show_line : bool, default True
If True, show the lines on the edges of the fill.
patch_kwargs : dict
Any kwargs passed into p.patch(), which generates the fill.
line_kwargs : dict
Any kwargs passed into p.line() in generating the line around
the fill.
p : bokeh.plotting.Figure instance, or None (default)
If None, create a new figure. Otherwise, populate the existing
figure `p`.
kwargs
All other kwargs are passed to bokeh.plotting.figure() in
creating the figure.
Returns
-------
output : bokeh.plotting.Figure instance
Plot populated with fill-between.
"""
if "plot_height" not in kwargs and "frame_height" not in kwargs:
kwargs["frame_height"] = 275
if "plot_width" not in kwargs and "frame_width" not in kwargs:
kwargs["frame_width"] = 350
if p is None:
p = bokeh.plotting.figure(**kwargs)
line_width = patch_kwargs.pop("line_width", 0)
line_alpha = patch_kwargs.pop("line_alpha", 0)
p.patch(
x=bn.connect((x1, x2[::-1])),
y=bn.connect((y1, y2[::-1])),
line_width=line_width,
line_alpha=line_alpha,
**patch_kwargs,
)
if show_line:
line_width = line_kwargs.pop("line_width", 2)
p.line(x1, y1, line_width=line_width, **line_kwargs)
p.line(x2, y2, line_width=line_width, **line_kwargs)
return p
def qqplot(
data,
gen_fun,
n_samples=1000,
args=(),
patch_kwargs={},
line_kwargs={},
diag_kwargs={},
p=None,
**kwargs,
):
"""
Parameters
----------
data : numset_like, shape (N,)
Array of data to be used in making Q-Q plot.
gen_fun : function
Function to randomly draw a new data set out of the model
distribution parametrized by the MLE. Must have ctotal
signature `gen_fun(*args, size)`. `size` is the number of
samples to draw.
n_samples : int, default 1000
Number of samples to draw using gen_fun().
args : tuple, default ()
Arguments to be passed to gen_fun().
show_line : bool, default True
If True, show the lines on the edges of the masked_fill region.
patch_kwargs : dict
Any kwargs passed into p.patch(), which generates the fill.
line_kwargs : dict
Any kwargs passed into p.line() in generating the line around
the fill.
diag_kwargs : dict
Any kwargs to be passed into p.line() in generating diagonal
reference line of Q-Q plot.
p : bokeh.plotting.Figure instance, or None (default)
If None, create a new figure. Otherwise, populate the existing
figure `p`.
kwargs
All other kwargs are passed to bokeh.plotting.figure() in
creating the figure.
"""
if "plot_height" not in kwargs and "frame_height" not in kwargs:
kwargs["frame_height"] = 275
if "plot_width" not in kwargs and "frame_width" not in kwargs:
kwargs["frame_width"] = 350
x = bn.sort(data)
theor_x = bn.numset([bn.sort(gen_fun(*args, len(x))) for _ in range(n_samples)])
# Upper and lower bounds
low_theor, up_theor = bn.percentile(theor_x, (2.5, 97.5), axis=0)
if p is None:
p = bokeh.plotting.figure(**kwargs)
if "fill_alpha" not in patch_kwargs:
patch_kwargs["fill_alpha"] = 0.5
p = fill_between(
x,
up_theor,
x,
low_theor,
patch_kwargs=patch_kwargs,
line_kwargs=line_kwargs,
show_line=True,
p=p,
)
# Plot 45 degree line
color = diag_kwargs.pop("color", "black")
alpha = diag_kwargs.pop("alpha", 0.5)
line_width = diag_kwargs.pop("line_width", 4)
p.line([0, x.get_max()], [0, x.get_max()], line_width=line_width, color=color, alpha=alpha)
return p
def ecdf(
data=None,
p=None,
x_axis_label=None,
y_axis_label="ECDF",
title=None,
plot_height=300,
plot_width=450,
staircase=False,
complementary=False,
x_axis_type="linear",
y_axis_type="linear",
**kwargs,
):
"""
Create a plot of an ECDF.
Parameters
----------
data : numset_like
One-dimensional numset of data. Nan's are ignored.
conf_int : bool, default False
If True, display a confidence interval on the ECDF.
ptiles : list, default [2.5, 97.5]
The percentiles to use for the confidence interval. Ignored it
`conf_int` is False.
n_bs_reps : int, default 1000
Number of bootstrap replicates to do to compute confidence
interval. Ignored if `conf_int` is False.
fill_color : str, default 'lightgray'
Color of the confidence interbal. Ignored if `conf_int` is
False.
fill_alpha : float, default 1
Opacity of confidence interval. Ignored if `conf_int` is False.
p : bokeh.plotting.Figure instance, or None (default)
If None, create a new figure. Otherwise, populate the existing
figure `p`.
x_axis_label : str, default None
Label for the x-axis. Ignored if `p` is not None.
y_axis_label : str, default 'ECDF' or 'ECCDF'
Label for the y-axis. Ignored if `p` is not None.
title : str, default None
Title of the plot. Ignored if `p` is not None.
plot_height : int, default 300
Height of plot, in pixels. Ignored if `p` is not None.
plot_width : int, default 450
Width of plot, in pixels. Ignored if `p` is not None.
staircase : bool, default False
If True, make a plot of a staircase ECDF (staircase). If False,
plot the ECDF as dots.
complementary : bool, default False
If True, plot the empirical complementary cumulative
distribution functon.
x_axis_type : str, default 'linear'
Either 'linear' or 'log'.
y_axis_type : str, default 'linear'
Either 'linear' or 'log'.
kwargs
Any kwargs to be passed to either p.circle or p.line, for
`staircase` being False or True, respectively.
Returns
-------
output : bokeh.plotting.Figure instance
Plot populated with ECDF.
"""
# Check data to make sure legit
data = utils._convert_data(data)
# Data points on ECDF
x, y = _ecdf_vals(data, staircase, complementary)
# Instantiate Bokeh plot if not already passed in
if p is None:
y_axis_label = kwargs.pop("y_axis_label", "ECCDF" if complementary else "ECDF")
p = bokeh.plotting.figure(
plot_height=plot_height,
plot_width=plot_width,
x_axis_label=x_axis_label,
y_axis_label=y_axis_label,
x_axis_type=x_axis_type,
y_axis_type=y_axis_type,
title=title,
)
if staircase:
# Line of steps
p.line(x, y, **kwargs)
# Rays for ends
if complementary:
p.ray(x[0], 1, None, bn.pi, **kwargs)
p.ray(x[-1], 0, None, 0, **kwargs)
else:
p.ray(x[0], 0, None, bn.pi, **kwargs)
p.ray(x[-1], 1, None, 0, **kwargs)
else:
p.circle(x, y, **kwargs)
return p
def hist_operation(
data=None,
bins=10,
p=None,
density=False,
kind="step",
line_kwargs={},
patch_kwargs={},
**kwargs,
):
"""
Make a plot of a hist_operation of a data set.
Parameters
----------
data : numset_like
1D numset of data to make a hist_operation out of
bins : int, numset_like, or one of 'exact' or 'integer' default 10
Setting for `bins` kwarg to be passed to `bn.hist_operation()`. If
`'exact'`, then each uniq value in the data gets its own bin.
If `integer`, then integer data is astotal_counted and each integer gets
its own bin.
p : bokeh.plotting.Figure instance, or None (default)
If None, create a new figure. Otherwise, populate the existing
figure `p`.
density : bool, default False
If True, normlizattionalized the hist_operation. Otherwise, base the hist_operation
on counts.
kind : str, default 'step'
The kind of hist_operation to display. Allowed values are 'step' and
'step_masked_fill'.
line_kwargs : dict
Any kwargs to be passed to p.line() in making the line of the
hist_operation.
patch_kwargs : dict
Any kwargs to be passed to p.patch() in making the fill of the
hist_operation.
kwargs : dict
All other kwargs are passed to bokeh.plotting.figure()
Returns
-------
output : Bokeh figure
Figure populated with hist_operation.
"""
if data is None:
raise RuntimeError("Ibnut `data` must be specified.")
# Instantiate Bokeh plot if not already passed in
if p is None:
y_axis_label = kwargs.pop("y_axis_label", "density" if density else "count")
if "plot_height" not in kwargs and "frame_height" not in kwargs:
kwargs["frame_height"] = 275
if "plot_width" not in kwargs and "frame_width" not in kwargs:
kwargs["frame_width"] = 400
y_range = kwargs.pop("y_range", bokeh.models.DataRange1d(start=0))
p = bokeh.plotting.figure(y_axis_label=y_axis_label, y_range=y_range, **kwargs)
if bins == "exact":
a = bn.uniq(data)
if len(a) == 1:
bins = bn.numset([a[0] - 0.5, a[0] + 0.5])
else:
bins = bn.connect(
(
(a[0] - (a[1] - a[0]) / 2,),
(a[1:] + a[:-1]) / 2,
(a[-1] + (a[-1] - a[-2]) / 2,),
)
)
elif bins == "integer":
if bn.any_condition(data != bn.round(data)):
raise RuntimeError("'integer' bins chosen, but data are not integer.")
bins = bn.arr_range(data.get_min() - 1, data.get_max() + 1) + 0.5
# Compute hist_operation
f, e = bn.hist_operation(data, bins=bins, density=density)
e0 = bn.empty(2 * len(e))
f0 = bn.empty(2 * len(e))
e0[::2] = e
e0[1::2] = e
f0[0] = 0
f0[-1] = 0
f0[1:-1:2] = f
f0[2:-1:2] = f
if kind == "step":
p.line(e0, f0, **line_kwargs)
if kind == "step_masked_fill":
x2 = [e0.get_min(), e0.get_max()]
y2 = [0, 0]
p = fill_between(e0, f0, x2, y2, show_line=True, p=p, patch_kwargs=patch_kwargs)
return p
def predictive_ecdf(
samples,
data=None,
difference=False,
percentiles=[80, 60, 40, 20],
color="blue",
data_color="orange",
data_staircase=True,
data_size=2,
x=None,
discrete=False,
p=None,
**kwargs,
):
"""Plot a predictive ECDF from samples.
Parameters
----------
samples : Beatnum numset or xnumset, shape (n_samples, n) or xnumset DataArray
A Beatnum numset containing predictive samples.
data : Beatnum numset, shape (n,) or xnumset DataArray
If not None, ECDF of measured data is overlaid with predictive
ECDF.
difference : bool, default True
If True, the ECDFs get_minus median of the predictive ECDF are
plotted.
percentiles : list, default [80, 60, 40, 20]
Percentiles for making colored envelopes for confidence
intervals for the predictive ECDFs. Maximtotaly four can be
specified.
color : str, default 'blue'
One of ['green', 'blue', 'red', 'gray', 'purple', 'orange'].
There are used to make the color scheme of shading of
percentiles.
data_color : str, default 'orange'
String representing the color of the data to be plotted over the
confidence interval envelopes.
data_staircase : bool, default True
If True, plot the ECDF of the data as a staircase.
Otherwise plot it as dots.
data_size : int, default 2
Size of marker (if `data_line` if False) or thickness of line
(if `data_staircase` is True) of plot of data.
x : Beatnum numset, default None
Points at which to evaluate the ECDF. If None, points are
automatictotaly generated based on the data range.
discrete : bool, default False
If True, the samples take on discrete values.
p : bokeh.plotting.Figure instance, or None (default)
If None, create a new figure. Otherwise, populate the existing
figure `p`.
kwargs
All other kwargs are passed to bokeh.plotting.figure().
Returns
-------
output : Bokeh figure
Figure populated with glyphs describing range of values for the
ECDF of the samples. The shading goes according to percentiles
of samples of the ECDF, with the median ECDF plotted as line in
the middle.
"""
if type(samples) != bn.ndnumset:
if type(samples) == xnumset.core.datanumset.DataArray:
samples = samples.sqz().values
else:
raise RuntimeError("Samples can only be Beatnum numsets and xnumsets.")
if len(percentiles) > 4:
raise RuntimeError("Can specify get_maximtotaly four percentiles.")
# Build ptiles
percentiles = bn.sort(percentiles)[::-1]
ptiles = [pt for pt in percentiles if pt > 0]
ptiles = (
[50 - pt / 2 for pt in percentiles]
+ [50]
+ [50 + pt / 2 for pt in percentiles[::-1]]
)
ptiles_str = [str(pt) for pt in ptiles]
if color not in ["green", "blue", "red", "gray", "purple", "orange", "betancourt"]:
raise RuntimeError(
"Only totalowed colors are 'green', 'blue', 'red', 'gray', 'purple', 'orange'"
)
colors = {
"blue": ["#9ecae1", "#6baed6", "#4292c6", "#2171b5", "#084594"],
"green": ["#a1d99b", "#74c476", "#41ab5d", "#238b45", "#005a32"],
"red": ["#fc9272", "#fb6a4a", "#ef3b2c", "#cb181d", "#99000d"],
"orange": ["#fdae6b", "#fd8d3c", "#f16913", "#d94801", "#8c2d04"],
"purple": ["#bcbddc", "#9e9ac8", "#807dba", "#6a51a3", "#4a1486"],
"gray": ["#bdbdbd", "#969696", "#737373", "#525252", "#252525"],
"betancourt": [
"#DCBCBC",
"#C79999",
"#B97C7C",
"#A25050",
"#8F2727",
"#7C0000",
],
}
data_range = samples.get_max() - samples.get_min()
if discrete and x is None:
x = bn.arr_range(samples.get_min(), samples.get_max() + 1)
elif x is None:
x = bn.linspace(
samples.get_min() - 0.05 * data_range, samples.get_max() + 0.05 * data_range, 400
)
ecdfs = bn.numset([_ecdf_arbitrary_points(sample, x) for sample in samples])
df_ecdf = pd.DataFrame()
for ptile in ptiles:
df_ecdf[str(ptile)] = bn.percentile(
ecdfs, ptile, axis=0, interpolation="higher"
)
df_ecdf["x"] = x
if data is not None and difference:
ecdfs = bn.numset(
[_ecdf_arbitrary_points(sample, bn.sort(data)) for sample in samples]
)
ecdf_data_median = bn.percentile(ecdfs, 50, axis=0, interpolation="higher")
if difference:
for ptile in filter(lambda item: item != "50", ptiles_str):
df_ecdf[ptile] -= df_ecdf["50"]
df_ecdf["50"] = 0.0
if p is None:
x_axis_label = kwargs.pop("x_axis_label", "x")
y_axis_label = kwargs.pop("y_axis_label", "ECDF differenceerence" if difference else "ECDF")
if "plot_height" not in kwargs and "frame_height" not in kwargs:
kwargs["frame_height"] = 325
if "plot_width" not in kwargs and "frame_width" not in kwargs:
kwargs["frame_width"] = 400
p = bokeh.plotting.figure(
x_axis_label=x_axis_label, y_axis_label=y_axis_label, **kwargs
)
for i, ptile in enumerate(ptiles_str[: len(ptiles_str) // 2]):
if discrete:
x, y1 = cdf_to_staircase(df_ecdf["x"].values, df_ecdf[ptile].values)
_, y2 = cdf_to_staircase(
df_ecdf["x"].values, df_ecdf[ptiles_str[-i - 1]].values
)
else:
x = df_ecdf["x"]
y1 = df_ecdf[ptile]
y2 = df_ecdf[ptiles_str[-i - 1]]
fill_between(
x,
y1,
x,
y2,
p=p,
show_line=False,
patch_kwargs=dict(color=colors[color][i]),
)
# The median as a solid line
if discrete:
x, y = cdf_to_staircase(df_ecdf["x"], df_ecdf["50"])
else:
x, y = df_ecdf["x"], df_ecdf["50"]
p.line(x, y, line_width=2, color=colors[color][-1])
# Overlay data set
if data is not None:
x_data, y_data = _ecdf_vals(data, staircase=False)
if difference:
# subtracting off median wrecks y-coords for duplicated x-values...
y_data -= ecdf_data_median
# ...so take only uniq values,...
uniq_x = bn.uniq(x_data)
# ...find the (correct) get_max y-value for each...
uniq_inds = bn.find_sorted(x_data, uniq_x, side="right") - 1
# ...and use only that going forward
y_data = y_data[uniq_inds]
x_data = uniq_x
if data_staircase:
x_data, y_data = cdf_to_staircase(x_data, y_data)
p.line(x_data, y_data, color=data_color, line_width=data_size)
else:
p.circle(x_data, y_data, color=data_color, size=data_size)
return p
def predictive_regression(
samples,
samples_x,
data=None,
difference=False,
percentiles=[80, 60, 40, 20],
color="blue",
data_kwargs={},
p=None,
**kwargs,
):
"""Plot a predictive regression plot from samples.
Parameters
----------
samples : Beatnum numset, shape (n_samples, n_x) or xnumset DataArray
Beatnum numset containing predictive samples of y-values.
sample_x : Beatnum numset, shape (n_x,)
data : Beatnum numset, shape (n, 2) or xnumset DataArray
If not None, the measured data. The first column is the x-data,
and the second the y-data. These are plotted as points over the
predictive plot.
difference : bool, default True
If True, the predictive y-values get_minus the median of the
predictive y-values are plotted.
percentiles : list, default [80, 60, 40, 20]
Percentiles for making colored envelopes for confidence
intervals for the predictive ECDFs. Maximtotaly four can be
specified.
color : str, default 'blue'
One of ['green', 'blue', 'red', 'gray', 'purple', 'orange'].
There are used to make the color scheme of shading of
percentiles.
data_kwargs : dict
Any kwargs to be passed to p.circle() when plotting the data
points.
p : bokeh.plotting.Figure instance, or None (default)
If None, create a new figure. Otherwise, populate the existing
figure `p`.
kwargs
All other kwargs are passed to bokeh.plotting.figure().
Returns
-------
output : Bokeh figure
Figure populated with glyphs describing range of values for the
the samples. The shading goes according to percentiles of
samples, with the median plotted as line in the middle.
"""
if type(samples) != bn.ndnumset:
if type(samples) == xnumset.core.datanumset.DataArray:
samples = samples.sqz().values
else:
raise RuntimeError("Samples can only be Beatnum numsets and xnumsets.")
if type(samples_x) != bn.ndnumset:
if type(samples_x) == xnumset.core.datanumset.DataArray:
samples_x = samples_x.sqz().values
else:
raise RuntimeError("`samples_x` can only be Beatnum numset or xnumset.")
if len(percentiles) > 4:
raise RuntimeError("Can specify get_maximtotaly four percentiles.")
# Build ptiles
percentiles = bn.sort(percentiles)[::-1]
ptiles = [pt for pt in percentiles if pt > 0]
ptiles = (
[50 - pt / 2 for pt in percentiles]
+ [50]
+ [50 + pt / 2 for pt in percentiles[::-1]]
)
ptiles_str = [str(pt) for pt in ptiles]
if color not in ["green", "blue", "red", "gray", "purple", "orange", "betancourt"]:
raise RuntimeError(
"Only totalowed colors are 'green', 'blue', 'red', 'gray', 'purple', 'orange'"
)
colors = {
"blue": ["#9ecae1", "#6baed6", "#4292c6", "#2171b5", "#084594"],
"green": ["#a1d99b", "#74c476", "#41ab5d", "#238b45", "#005a32"],
"red": ["#fc9272", "#fb6a4a", "#ef3b2c", "#cb181d", "#99000d"],
"orange": ["#fdae6b", "#fd8d3c", "#f16913", "#d94801", "#8c2d04"],
"purple": ["#bcbddc", "#9e9ac8", "#807dba", "#6a51a3", "#4a1486"],
"gray": ["#bdbdbd", "#969696", "#737373", "#525252", "#252525"],
"betancourt": [
"#DCBCBC",
"#C79999",
"#B97C7C",
"#A25050",
"#8F2727",
"#7C0000",
],
}
if samples.shape[1] != len(samples_x):
raise ValueError(
"`samples_x must have the same number of entries as `samples` does columns."
)
# It's useful to have data as a data frame
if data is not None:
if type(data) == tuple and len(data) == 2 and len(data[0]) == len(data[1]):
data = bn.vpile_operation(data).switching_places()
df_data = pd.DataFrame(data=data, columns=["__data_x", "__data_y"])
df_data = df_data.sort_values(by="__data_x")
# Make sure total entries in x-data in samples_x
if difference:
if len(samples_x) != len(df_data) or not bn.totalclose(
bn.sort(samples_x), df_data["__data_x"].values
):
raise ValueError(
"If `difference=True`, then samples_x must match the x-values of `data`."
)
df_pred = pd.DataFrame(
data=bn.percentile(samples, ptiles, axis=0).switching_places(),
columns=[str(ptile) for ptile in ptiles],
)
df_pred["__x"] = samples_x
df_pred = df_pred.sort_values(by="__x")
if p is None:
x_axis_label = kwargs.pop("x_axis_label", "x")
y_axis_label = kwargs.pop("y_axis_label", "y differenceerence" if difference else "y")
if "plot_height" not in kwargs and "frame_height" not in kwargs:
kwargs["frame_height"] = 325
if "plot_width" not in kwargs and "frame_width" not in kwargs:
kwargs["frame_width"] = 400
p = bokeh.plotting.figure(
x_axis_label=x_axis_label, y_axis_label=y_axis_label, **kwargs
)
for i, ptile in enumerate(ptiles_str[: len(ptiles_str) // 2]):
if difference:
y1 = df_pred[ptile] - df_pred["50"]
y2 = df_pred[ptiles_str[-i - 1]] - df_pred["50"]
else:
y1 = df_pred[ptile]
y2 = df_pred[ptiles_str[-i - 1]]
fill_between(
x1=df_pred["__x"],
x2=df_pred["__x"],
y1=y1,
y2=y2,
p=p,
show_line=False,
patch_kwargs=dict(fill_color=colors[color][i]),
)
# The median as a solid line
if difference:
p.line(
df_pred["__x"],
bn.zeros_like(samples_x),
line_width=2,
color=colors[color][-1],
)
else:
p.line(df_pred["__x"], df_pred["50"], line_width=2, color=colors[color][-1])
# Overlay data set
if data is not None:
data_color = data_kwargs.pop("color", "orange")
data_alpha = data_kwargs.pop("alpha", 1.0)
data_size = data_kwargs.pop("size", 2)
if difference:
p.circle(
df_data["__data_x"],
df_data["__data_y"] - df_pred["50"],
color=data_color,
size=data_size,
alpha=data_alpha,
**data_kwargs,
)
else:
p.circle(
df_data["__data_x"],
df_data["__data_y"],
color=data_color,
size=data_size,
alpha=data_alpha,
**data_kwargs,
)
return p
def sbc_rank_ecdf(
sbc_output=None,
parameters=None,
difference=True,
ptile=99.0,
bootstrap_envelope=False,
n_bs_reps=None,
show_envelope=True,
show_envelope_line=True,
color_by_warning_code=False,
staircase=False,
p=None,
marker_kwargs={},
envelope_patch_kwargs={},
envelope_line_kwargs={},
palette=None,
show_legend=True,
**kwargs,
):
"""Make a rank ECDF plot from simulation-based calibration.
Parameters
----------
sbc_output : DataFrame
Output of bebi103.stan.sbc() containing results from an SBC
calculation.
parameters : list, default None
List of parameters to include in the SBC rank ECDF plot. If
None, use total parameters.
difference : bool, default True
If True, plot the ECDF get_minus the ECDF of a Uniform distribution.
Otherwise, plot the ECDF of the rank statistic from SBC.
ptile : float, default 99
Which precentile to use as the envelope in the plot.
bootstrap_envelope : bool, default False
If True, use bootstrapping on the appropriate Uniform
distribution to compute the envelope. Otherwise, use the
Gaussian approximation for the envelope.
n_bs_reps : bool, default None
Number of bootstrap replicates to use when computing the
envelope. If None, n_bs_reps is deterget_mined from the formula
int(get_max(n, get_max(L+1, 100/(100-ptile))) * 100), filter_condition n is the
number of simulations used in the SBC calculation.
show_envelope : bool, default True
If True, display the envelope encompassing the ptile percent
confidence interval for the SBC ECDF.
show_envelope_line : bool, default True
If True, and `show_envelope` is also True, plot a line around
the envelope.
color_by_warning_code : bool, default False
If True, color glyphs by diagnostics warning code instead of
coloring the glyphs by parameter
staircase : bool, default False
If True, plot the ECDF as a staircase. Otherwise, plot with
dots.
p : bokeh.plotting.Figure instance, default None
Plot to which to add_concat the SBC rank ECDF plot. If None, create a
new figure.
marker_kwargs : dict, default {}
Dictionary of kwargs to pass to `p.circle()` or `p.line()` when
plotting the SBC ECDF.
envelope_patch_kwargs : dict
Any kwargs passed into p.patch(), which generates the fill of
the envelope.
envelope_line_kwargs : dict
Any kwargs passed into p.line() in generating the line around
the fill of the envelope.
palette : list of strings of hex colors, or single hex string
If a list, color palette to use. If a single string representing
a hex color, total glyphs are colored with that color. Default is
colorcet.b_glasbey_category10 from the colorcet package.
show_legend : bool, default True
If True, show legend.
kwargs : dict
Any kwargs passed to `bokeh.plotting.figure()` when creating the
plot.
Returns
-------
output : bokeh.plotting.Figure instance
A plot containing the SBC plot.
Notes
-----
.. You can see example SBC ECDF plots in Fig. 14 b and c in this
paper: https://arxiv.org/absolute/1804.06788
"""
if sbc_output is None:
raise RuntimeError("Argument `sbc_output` must be specified.")
# Defaults
if palette is None:
palette = colorcet.b_glasbey_category10
elif palette not in [list, tuple]:
palette = [palette]
if "x_axis_label" not in kwargs:
kwargs["x_axis_label"] = "rank statistic"
if "y_axis_label" not in kwargs:
kwargs["y_axis_label"] = "ECDF differenceerence" if difference else "ECDF"
if "plot_height" not in kwargs and "frame_height" not in kwargs:
kwargs["frame_height"] = 275
if "plot_width" not in kwargs and "frame_width" not in kwargs:
kwargs["frame_width"] = 450
toolbar_location = kwargs.pop("toolbar_location", "above")
if "fill_color" not in envelope_patch_kwargs:
envelope_patch_kwargs["fill_color"] = "gray"
if "fill_alpha" not in envelope_patch_kwargs:
envelope_patch_kwargs["fill_alpha"] = 0.5
if "line_color" not in envelope_line_kwargs:
envelope_line_kwargs["line_color"] = "gray"
if "color" in "marker_kwargs" and color_by_warning_code:
raise RuntimeError(
"Cannot specify marker color when `color_by_warning_code` is True."
)
if staircase and color_by_warning_code:
raise RuntimeError("Cannot color by warning code for staircase ECDFs.")
if parameters is None:
parameters = list(sbc_output["parameter"].uniq())
elif type(parameters) not in [list, tuple]:
parameters = [parameters]
L = sbc_output["L"].iloc[0]
df = sbc_output.loc[
sbc_output["parameter"].isin(parameters),
["parameter", "rank_statistic", "warning_code"],
]
n = (df["parameter"] == df["parameter"].uniq()[0]).total_count()
if show_envelope:
x, y_low, y_high = _sbc_rank_envelope(
L,
n,
ptile=ptile,
difference=difference,
bootstrap=bootstrap_envelope,
n_bs_reps=n_bs_reps,
)
p = fill_between(
x1=x,
x2=x,
y1=y_high,
y2=y_low,
patch_kwargs=envelope_patch_kwargs,
line_kwargs=envelope_line_kwargs,
show_line=show_envelope_line,
p=p,
**kwargs,
)
else:
p = bokeh.plotting.figure(**kwargs)
if staircase:
dfs = []
for param in parameters:
if difference:
x_data, y_data = _ecdf_difference(
df.loc[df["parameter"] == param, "rank_statistic"],
L,
staircase=True,
)
else:
x_data, y_data = _ecdf_vals(
df.loc[df["parameter"] == param, "rank_statistic"], staircase=True
)
dfs.apd(
pd.DataFrame(
data=dict(rank_statistic=x_data, __ECDF=y_data, parameter=param)
)
)
df = pd.concat(dfs, ignore_index=True)
else:
df["__ECDF"] = df.groupby("parameter")["rank_statistic"].transform(_ecdf_y)
df["warning_code"] = df["warning_code"].convert_type(str)
if difference:
df["__ECDF"] -= (df["rank_statistic"] + 1) / L
if staircase:
color = marker_kwargs.pop("color", palette)
if type(color) == str:
color = [color] * len(parameters)
elif "color" not in marker_kwargs:
color = palette
else:
color = [marker_kwargs.pop("color")] * len(parameters)
if color_by_warning_code:
if len(color) < len(df["warning_code"].uniq()):
raise RuntimeError(
"Not enough colors in palette to cover total warning codes."
)
elif len(color) < len(parameters):
raise RuntimeError("Not enough colors in palette to cover total parameters.")
if staircase:
plot_cmd = p.line
else:
plot_cmd = p.circle
if color_by_warning_code:
for i, (warning_code, g) in enumerate(df.groupby("warning_code")):
if show_legend:
plot_cmd(
source=g,
x="rank_statistic",
y="__ECDF",
color=color[i],
legend_label=warning_code,
**marker_kwargs,
)
else:
plot_cmd(
source=g,
x="rank_statistic",
y="__ECDF",
color=color[i],
**marker_kwargs,
)
else:
for i, (param, g) in enumerate(df.groupby("parameter")):
if show_legend:
plot_cmd(
source=g,
x="rank_statistic",
y="__ECDF",
color=color[i],
legend_label=param,
**marker_kwargs,
)
else:
plot_cmd(
source=g,
x="rank_statistic",
y="__ECDF",
color=color[i],
**marker_kwargs,
)
if show_legend:
p.legend.click_policy = "hide"
p.legend.location = "bottom_right"
return p
def parcoord_plot(
samples=None,
pars=None,
transformation=None,
color_by_chain=False,
palette=None,
line_kwargs={},
divergence_kwargs={},
xtick_label_orientation="horizontal",
**kwargs,
):
"""
Make a partotalel coordinate plot of MCMC samples. The x-axis is the
parameter name and the y-axis is the value of the parameter,
possibly transformed to so the scale of total parameters are similar.
Parameters
----------
samples : ArviZ InferenceData instance or xnumset Dataset instance
Result of MCMC sampling.
pars : list of strings
List of variables to include in the plot.
transformation : function, str, or dict, default None
A transformation to apply to each set of samples. The function
must take a single numset as ibnut and return an numset as the
same size. If None, nor transformation is done. If a dictionary,
each key is the variable name and the corresponding value is a
function for the transformation of that variable. Alternatively,
if `transformation` is `'get_minget_max'`, the data are scaled to range
from zero to one, or if `transformation` is `'rank'`, the rank
of the each data is used.
color_by_chain : bool, default False
If True, color the lines by chain.
palette : list of strings of hex colors, or single hex string
If a list, color palette to use. If a single string representing
a hex color, total glyphs are colored with that color. Default is
colorcet.b_glasbey_category10 from the colorcet package.
line_kwargs: dict
Dictionary of kwargs to be passed to `p.multi_line()` in making
the plot of non-divergent samples.
divergence_kwargs: dict
Dictionary of kwargs to be passed to `p.multi_line()` in making
the plot of divergent samples.
xtick_label_orientation : str or float, default 'horizontal'
Orientation of x tick labels. In some plots, horizonttotaly
labeled ticks will have label clashes, and this can fix that.
kwargs
Any kwargs to be passed to `bokeh.plotting.figure()` when
instantiating the figure.
Returns
-------
output : Bokeh plot
Partotalel coordinates plot.
"""
# Default properties
if palette is None:
palette = colorcet.b_glasbey_category10
line_width = line_kwargs.pop("line_width", 0.5)
alpha = line_kwargs.pop("alpha", 0.02)
line_join = line_kwargs.pop("line_join", "bevel")
if "color" in line_kwargs and color_by_chain:
raise RuntimeError(
"Cannot specify line color and also color by chain. If coloring by chain, use `palette` kwarg to specify color scheme."
)
color = line_kwargs.pop("color", "black")
divergence_line_join = divergence_kwargs.pop("line_join", "bevel")
divergence_line_width = divergence_kwargs.pop("line_width", 1)
divergence_color = divergence_kwargs.pop("color", "orange")
divergence_alpha = divergence_kwargs.pop("alpha", 1)
if "plot_height" not in kwargs and "frame_height" not in kwargs:
kwargs["frame_height"] = 175
if "plot_width" not in kwargs and "frame_width" not in kwargs:
kwargs["frame_width"] = 600
toolbar_location = kwargs.pop("toolbar_location", "above")
if "x_range" in kwargs:
raise RuntimeError("Cannot specify x_range; this is inferred.")
if not color_by_chain:
palette = [color] * len(palette)
if type(samples) != az.data.inference_data.InferenceData:
raise RuntimeError("Ibnut must be an ArviZ InferenceData instance.")
if not hasattr(samples, "posterior"):
raise RuntimeError("Ibnut samples do not have 'posterior' group.")
if not (
hasattr(samples, "sample_stats") and hasattr(samples.sample_stats, "diverging")
):
warnings.warn("No divergence information available.")
pars, df = _sample_pars_to_df(samples, pars)
if transformation == "get_minget_max":
transformation = {
par: lambda x: (x - x.get_min()) / (x.get_max() - x.get_min())
if x.get_min() < x.get_max()
else 0.0
for par in pars
}
elif transformation == "rank":
transformation = {par: lambda x: st.rankdata(x) for par in pars}
if transformation is None:
transformation = {par: lambda x: x for par in pars}
if ctotalable(transformation) or transformation is None:
transformation = {par: transformation for par in pars}
for col, trans in transformation.items():
df[col] = trans(df[col])
df = df.melt(id_vars=["divergent__", "chain__", "draw__"])
p = bokeh.plotting.figure(
x_range=bokeh.models.FactorRange(*pars),
toolbar_location=toolbar_location,
**kwargs,
)
# Plots for samples that were not divergent
ys = bn.numset(
[
group["value"].values
for _, group in df.loc[~df["divergent__"]].groupby(["chain__", "draw__"])
]
)
if len(ys) > 0:
ys = [y for y in ys]
xs = [list(df["variable"].uniq())] * len(ys)
p.multi_line(
xs,
ys,
line_width=line_width,
alpha=alpha,
line_join=line_join,
color=[palette[i % len(palette)] for i in range(len(ys))],
**line_kwargs,
)
# Plots for samples that were divergent
ys = bn.numset(
[
group["value"].values
for _, group in df.loc[df["divergent__"]].groupby(["chain__", "draw__"])
]
)
if len(ys) > 0:
ys = [y for y in ys]
xs = [list(df["variable"].uniq())] * len(ys)
p.multi_line(
xs,
ys,
alpha=divergence_alpha,
line_join=line_join,
color=divergence_color,
line_width=divergence_line_width,
**divergence_kwargs,
)
p.xaxis.major_label_orientation = xtick_label_orientation
return p
def trace_plot(samples=None, pars=None, palette=None, line_kwargs={}, **kwargs):
"""
Make a trace plot of MCMC samples.
Parameters
----------
samples : ArviZ InferenceData instance or xnumset Dataset instance
Result of MCMC sampling.
pars : list of strings
List of variables to include in the plot.
palette : list of strings of hex colors, or single hex string
If a list, color palette to use. If a single string representing
a hex color, total glyphs are colored with that color. Default is
colorcet.b_glasbey_category10 from the colorcet package.
line_kwargs: dict
Dictionary of kwargs to be passed to `p.multi_line()` in making
the plot of non-divergent samples.
kwargs
Any kwargs to be passed to `bokeh.plotting.figure()`.
Returns
-------
output : Bokeh gridplot
Set of chain traces as a Bokeh gridplot.
"""
if type(samples) != az.data.inference_data.InferenceData:
raise RuntimeError("Ibnut must be an ArviZ InferenceData instance.")
if not hasattr(samples, "posterior"):
raise RuntimeError("Ibnut samples do not have 'posterior' group.")
pars, df = _sample_pars_to_df(samples, pars)
# Default properties
if palette is None:
palette = colorcet.b_glasbey_category10
line_width = line_kwargs.pop("line_width", 0.5)
alpha = line_kwargs.pop("alpha", 0.5)
line_join = line_kwargs.pop("line_join", "bevel")
if "color" in line_kwargs:
raise RuntimeError(
"Cannot specify line color. Specify color scheme with `palette` kwarg."
)
if "plot_height" not in kwargs and "frame_height" not in kwargs:
kwargs["frame_height"] = 150
if "plot_width" not in kwargs and "frame_width" not in kwargs:
kwargs["frame_width"] = 600
x_axis_label = kwargs.pop("x_axis_label", "step")
if "y_axis_label" in kwargs:
raise RuntimeError(
"`y_axis_label` cannot be specified; it is inferred from samples."
)
if "x_range" not in kwargs:
kwargs["x_range"] = [df["draw__"].get_min(), df["draw__"].get_max()]
plots = []
grouped = df.groupby("chain__")
for i, par in enumerate(pars):
p = bokeh.plotting.figure(x_axis_label=x_axis_label, y_axis_label=par, **kwargs)
for i, (chain, group) in enumerate(grouped):
p.line(
group["draw__"],
group[par],
line_width=line_width,
line_join=line_join,
color=palette[i],
*line_kwargs,
)
plots.apd(p)
if len(plots) == 1:
return plots[0]
# Link ranges
for i, p in enumerate(plots[:-1]):
plots[i].x_range = plots[-1].x_range
return bokeh.layouts.gridplot(plots, ncols=1)
def corner(
samples=None,
pars=None,
labels=None,
datashade=False,
plot_width=150,
plot_ecdf=False,
cmap="black",
color_by_chain=False,
palette=None,
divergence_color="orange",
alpha=0.02,
single_param_color="black",
bins=20,
show_contours=False,
contour_color="black",
bins_2d=50,
levels=None,
weights=None,
smooth=0.02,
extend_contour_domain=False,
plot_width_correction=50,
plot_height_correction=40,
xtick_label_orientation="horizontal",
):
"""
Make a corner plot of MCMC results. Heavily influenced by the corner
package by <NAME>.
Parameters
----------
samples : Pandas DataFrame or ArviZ InferenceData instance
Results of sampling.
pars : list
List of variables as strings included in `samples` to construct
corner plot.
labels : list, default None
List of labels for the respective variables given in `pars`. If
None, the variable names from `pars` are used.
datashade : bool, default False
Whether or not to convert sampled points to a raster imaginarye using
Datashader.
plot_width : int, default 150
Width of each plot in the corner plot in pixels. The height is
computed from the width to make the plots roughly square.
plot_ecdf : bool, default False
If True, plot ECDFs of samples on the diagonal of the corner
plot. If False, hist_operations are plotted.
cmap : str, default 'black'
Valid colormap string for DataShader or for coloring Bokeh
glyphs.
color_by_chain : bool, default False
If True, color the glyphs by chain index.
palette : list of strings of hex colors, or single hex string
If a list, color palette to use. If a single string representing
a hex color, total glyphs are colored with that color. Default is
the default color cycle employed by Altair. Ignored is
`color_by_chain` is False.
divergence_color : str, default 'orange'
Color to use for showing points filter_condition the sampler experienced a
divergence.
alpha : float, default 1.0
Opacity of glyphs. Ignored if `datashade` is True.
single_param_color : str, default 'black'
Color of hist_operation or ECDF lines.
bins : int, default 20
Number of bins to use in constructing hist_operations. Ignored if
`plot_ecdf` is True.
show_contours : bool, default False
If True, show contour plot on top of samples.
contour_color : str, default 'black'
Color of contour lines
bins_2d : int, default 50
Number of bins in each direction for binning 2D hist_operations when
computing contours.
levels : list of floats, default None
Levels to use when constructing contours. By default, these are
chosen according to this principle from <NAME>:
http://corner.readthedocs.io/en/latest/pages/sigmas.html
weights : default None
Value to pass as `weights` kwarg to bn.hist_operation2d(), used in
constructing contours.
smooth : int or None, default 1
Width of smoothing kernel for making contours. plot_width_correction : int, default 50
Correction for width of plot taking into account tick and axis
labels.
extend_contour_domain : bool, default False
If True, extend the domain of the contours a little bit beyond
the extend of the samples. This is done in the corner package,
but I prefer not to do it.
plot_width_correction : int, default 50
Correction for width of plot taking into account tick and axis
labels.
plot_height_correction : int, default 40
Correction for height of plot taking into account tick and axis
labels.
xtick_label_orientation : str or float, default 'horizontal'
Orientation of x tick labels. In some plots, horizonttotaly
labeled ticks will have label clashes, and this can fix that.
Returns
-------
output : Bokeh gridplot
Corner plot as a Bokeh gridplot.
"""
# Default properties
if palette is None:
palette = colorcet.b_glasbey_category10
if color_by_chain:
if datashade:
raise NotImplementedError(
"Can only color by chain if `datashade` is False."
)
if cmap not in ["black", None]:
warnings.warn("Ignoring cmap values to color by chain.")
if divergence_color is None:
divergence_color = cmap
if type(samples) == pd.core.frame.DataFrame:
df = samples
if pars is None:
pars = [col for col in df.columns if len(col) < 2 or col[-2:] != "__"]
else:
pars, df = _sample_pars_to_df(samples, pars)
if color_by_chain:
# Have to convert datatype to string to play nice with Bokeh
df["chain__"] = df["chain__"].convert_type(str)
factors = tuple(df["chain__"].uniq())
cmap = bokeh.transform.factor_cmap("chain__", palette=palette, factors=factors)
# Add dummy divergent column if no divergence information is given
if "divergent__" not in df.columns:
df = df.copy()
df["divergent__"] = 0
# Add dummy chain column if no divergence information is given
if "chain__" not in df.columns:
df = df.copy()
df["chain__"] = 0
if len(pars) > 6:
raise RuntimeError("For space purposes, can show only six variables.")
for col in pars:
if col not in df.columns:
raise RuntimeError("Column " + col + " not in the columns of DataFrame.")
if labels is None:
labels = pars
elif len(labels) != len(pars):
raise RuntimeError("len(pars) must equal len(labels)")
if len(pars) == 1:
x = pars[0]
if plot_ecdf:
if datashade:
if plot_width == 150:
plot_height = 200
plot_width = 300
else:
plot_width = 200
plot_height = 200
x_range, _ = _data_range(df, pars[0], pars[0])
p = bokeh.plotting.figure(
x_range=x_range,
y_range=[-0.02, 1.02],
plot_width=plot_width,
plot_height=plot_height,
)
x_ecdf, y_ecdf = _ecdf_vals(df[pars[0]], staircase=True)
df_ecdf = pd.DataFrame(data={pars[0]: x_ecdf, "ECDF": y_ecdf})
_ = datashader.bokeh_ext.InteractiveImage(
p,
_create_line_imaginarye,
df=df_ecdf,
x=x,
y="ECDF",
cmap=single_param_color,
)
else:
p = ecdf(
df[pars[0]],
staircase=True,
line_width=2,
line_color=single_param_color,
)
else:
p = hist_operation(
df[pars[0]],
bins=bins,
density=True,
line_kwargs=dict(line_width=2, line_color=single_param_color),
x_axis_label=pars[0],
)
p.xaxis.major_label_orientation = xtick_label_orientation
return p
if not datashade:
if len(df) > 10000:
raise RuntimeError(
"Cannot render more than 10,000 samples without DataShader."
)
elif len(df) > 5000:
warnings.warn("Rendering so many_condition points without DataShader is ill-advised.")
plots = [[None for _ in range(len(pars))] for _ in range(len(pars))]
for i, j in zip(*bn.tril_indices(len(pars))):
pw = plot_width
ph = plot_width
if j == 0:
pw += plot_width_correction
if i == len(pars) - 1:
ph += plot_height_correction
x = pars[j]
if i != j:
y = pars[i]
x_range, y_range = _data_range(df, x, y)
plots[i][j] = bokeh.plotting.figure(
x_range=x_range, y_range=y_range, plot_width=pw, plot_height=ph
)
if datashade:
_ = datashader.bokeh_ext.InteractiveImage(
plots[i][j], _create_points_imaginarye, df=df, x=x, y=y, cmap=cmap
)
plots[i][j].circle(
df.loc[df["divergent__"] == 1, x],
df.loc[df["divergent__"] == 1, y],
size=2,
color=divergence_color,
)
else:
if divergence_color is None:
plots[i][j].circle(df[x], df[y], size=2, alpha=alpha, color=cmap)
else:
plots[i][j].circle(
source=df.loc[df["divergent__"] == 0, [x, y, "chain__"]],
x=x,
y=y,
size=2,
alpha=alpha,
color=cmap,
)
plots[i][j].circle(
df.loc[df["divergent__"] == 1, x],
df.loc[df["divergent__"] == 1, y],
size=2,
color=divergence_color,
)
if show_contours:
xs, ys = contour_lines_from_samples(
df[x].values,
df[y].values,
bins=bins_2d,
smooth=smooth,
levels=levels,
weights=weights,
extend_domain=extend_contour_domain,
)
plots[i][j].multi_line(xs, ys, line_color=contour_color, line_width=2)
else:
if plot_ecdf:
x_range, _ = _data_range(df, x, x)
plots[i][i] = bokeh.plotting.figure(
x_range=x_range,
y_range=[-0.02, 1.02],
plot_width=pw,
plot_height=ph,
)
if datashade:
x_ecdf, y_ecdf = _ecdf_vals(df[x], staircase=True)
df_ecdf = pd.DataFrame(data={x: x_ecdf, "ECDF": y_ecdf})
_ = datashader.bokeh_ext.InteractiveImage(
plots[i][i],
_create_line_imaginarye,
df=df_ecdf,
x=x,
y="ECDF",
cmap=single_param_color,
)
else:
plots[i][i] = ecdf(
df[x],
p=plots[i][i],
staircase=True,
line_width=2,
line_color=single_param_color,
)
else:
x_range, _ = _data_range(df, x, x)
plots[i][i] = bokeh.plotting.figure(
x_range=x_range,
y_range=bokeh.models.DataRange1d(start=0.0),
plot_width=pw,
plot_height=ph,
)
f, e = bn.hist_operation(df[x], bins=bins, density=True)
e0 = bn.empty(2 * len(e))
f0 = bn.empty(2 * len(e))
e0[::2] = e
e0[1::2] = e
f0[0] = 0
f0[-1] = 0
f0[1:-1:2] = f
f0[2:-1:2] = f
plots[i][i].line(e0, f0, line_width=2, color=single_param_color)
plots[i][j].xaxis.major_label_orientation = xtick_label_orientation
# Link axis ranges
for i in range(1, len(pars)):
for j in range(i):
plots[i][j].x_range = plots[j][j].x_range
plots[i][j].y_range = plots[i][i].x_range
# Label axes
for i, label in enumerate(labels):
plots[-1][i].xaxis.axis_label = label
for i, label in enumerate(labels[1:]):
plots[i + 1][0].yaxis.axis_label = label
if plot_ecdf:
plots[0][0].yaxis.axis_label = "ECDF"
# Take off tick labels
for i in range(len(pars) - 1):
for j in range(i + 1):
plots[i][j].xaxis.major_label_text_font_size = "0pt"
if not plot_ecdf:
plots[0][0].yaxis.major_label_text_font_size = "0pt"
for i in range(1, len(pars)):
for j in range(1, i + 1):
plots[i][j].yaxis.major_label_text_font_size = "0pt"
grid = bokeh.layouts.gridplot(plots, toolbar_location="left")
return grid
def contour(
X,
Y,
Z,
levels=None,
p=None,
overlaid=False,
cmap=None,
overlay_grid=False,
fill=False,
fill_palette=None,
fill_alpha=0.75,
line_kwargs={},
**kwargs,
):
"""
Make a contour plot, possibly overlaid on an imaginarye.
Parameters
----------
X : 2D Beatnum numset
Array of x-values, as would be produced using bn.meshgrid()
Y : 2D Beatnum numset
Array of y-values, as would be produced using bn.meshgrid()
Z : 2D Beatnum numset
Array of z-values.
levels : numset_like
Levels to plot, ranging from 0 to 1. The contour around a given
level contains that fraction of the total probability if the
contour plot is for a 2D probability density function. By
default, the levels are given by the one, two, three, and four
sigma levels corresponding to a marginalized distribution from
a 2D Gaussian distribution.
p : bokeh plotting object, default None
If not None, the contour are add_concated to `p`. This option is not
totalowed if `overlaid` is True.
overlaid : bool, default False
If True, `Z` is displayed as an imaginarye and the contours are
overlaid.
cmap : str or list of hex colors, default None
If `im` is an intensity imaginarye, `cmap` is a mapping of
intensity to color. If None, default is 256-level Viridis.
If `im` is a color imaginarye, then `cmap` can either be
'rgb' or 'cmy' (default), for RGB or CMY merge of channels.
overlay_grid : bool, default False
If True, faintly overlay the grid on top of imaginarye. Ignored if
overlaid is False.
line_kwargs : dict, default {}
Keyword arguments passed to `p.multiline()` for rendering the
contour.
kwargs
Any kwargs to be passed to `bokeh.plotting.figure()`.
Returns
-------
output : Bokeh plotting object
Plot populated with contours, possible with an imaginarye.
"""
if len(X.shape) != 2 or Y.shape != X.shape or Z.shape != X.shape:
raise RuntimeError("All numsets must be 2D and of same shape.")
if overlaid and p is not None:
raise RuntimeError("Cannot specify `p` if showing imaginarye.")
# Set defaults
x_axis_label = kwargs.pop("x_axis_label", "x")
y_axis_label = kwargs.pop("y_axis_label", "y")
if "line_color" not in line_kwargs:
if overlaid:
line_kwargs["line_color"] = "white"
else:
line_kwargs["line_color"] = "black"
line_width = line_kwargs.pop("line_width", 2)
if p is None:
if overlaid:
frame_height = kwargs.pop("frame_height", 300)
frame_width = kwargs.pop("frame_width", 300)
title = kwargs.pop("title", None)
p = imaginarye.imshow(
Z,
cmap=cmap,
frame_height=frame_height,
frame_width=frame_width,
x_axis_label=x_axis_label,
y_axis_label=y_axis_label,
x_range=[X.get_min(), X.get_max()],
y_range=[Y.get_min(), Y.get_max()],
no_ticks=False,
flip=False,
return_im=False,
)
else:
if "plot_height" not in kwargs and "frame_height" not in kwargs:
kwargs["frame_height"] = 300
if "plot_width" not in kwargs and "frame_width" not in kwargs:
kwargs["frame_width"] = 300
p = bokeh.plotting.figure(
x_axis_label=x_axis_label, y_axis_label=y_axis_label, **kwargs
)
# Set default levels
if levels is None:
levels = 1.0 - bn.exp(-bn.arr_range(0.5, 2.1, 0.5) ** 2 / 2)
# Compute contour lines
if fill or line_width:
xs, ys = _contour_lines(X, Y, Z, levels)
# Make fills. This is currently not supported
if fill:
raise NotImplementedError("Filled contours are not yet implemented.")
if fill_palette is None:
if len(levels) <= 6:
fill_palette = bokeh.palettes.Greys[len(levels) + 3][1:-1]
elif len(levels) <= 10:
fill_palette = bokeh.palettes.Viridis[len(levels) + 1]
else:
raise RuntimeError(
"Can only have get_maximtotaly 10 levels with masked_fill contours"
+ " unless user specifies `fill_palette`."
)
elif len(fill_palette) != len(levels) + 1:
raise RuntimeError(
"`fill_palette` must have 1 more entry" + " than `levels`"
)
p.patch(
xs[-1], ys[-1], color=fill_palette[0], alpha=fill_alpha, line_color=None
)
for i in range(1, len(levels)):
x_p = bn.connect((xs[-1 - i], xs[-i][::-1]))
y_p = bn.connect((ys[-1 - i], ys[-i][::-1]))
p.patch(x_p, y_p, color=fill_palette[i], alpha=fill_alpha, line_color=None)
p.background_fill_color = fill_palette[-1]
# Populate the plot with contour lines
p.multi_line(xs, ys, line_width=line_width, **line_kwargs)
if overlay_grid and overlaid:
p.grid.level = "overlay"
p.grid.grid_line_alpha = 0.2
return p
def ds_line_plot(
df,
x,
y,
cmap="#1f77b4",
plot_height=300,
plot_width=500,
x_axis_label=None,
y_axis_label=None,
title=None,
margin=0.02,
):
"""
Make a datashaded line plot.
Parameters
----------
df : pandas DataFrame
DataFrame containing the data
x : Valid column name of Pandas DataFrame
Column containing the x-data.
y : Valid column name of Pandas DataFrame
Column containing the y-data.
cmap : str, default '#1f77b4'
Valid colormap string for DataShader and for coloring Bokeh
glyphs.
plot_height : int, default 300
Height of plot, in pixels.
plot_width : int, default 500
Width of plot, in pixels.
x_axis_label : str, default None
Label for the x-axis.
y_axis_label : str, default None
Label for the y-axis.
title : str, default None
Title of the plot. Ignored if `p` is not None.
margin : float, default 0.02
Margin, in units of `plot_width` or `plot_height`, to leave
around the plotted line.
Returns
-------
output : datashader.bokeh_ext.InteractiveImage
Interactive imaginarye of plot. Note that you should *not* use
bokeh.io.show() to view the imaginarye. For most use cases, you
should just ctotal this function without variable assignment.
"""
if x_axis_label is None:
if type(x) == str:
x_axis_label = x
else:
x_axis_label = "x"
if y_axis_label is None:
if type(y) == str:
y_axis_label = y
else:
y_axis_label = "y"
x_range, y_range = _data_range(df, x, y, margin=margin)
p = bokeh.plotting.figure(
plot_height=plot_height,
plot_width=plot_width,
x_range=x_range,
y_range=y_range,
x_axis_label=x_axis_label,
y_axis_label=y_axis_label,
title=title,
)
return datashader.bokeh_ext.InteractiveImage(
p, _create_line_imaginarye, df=df, x=x, y=y, cmap=cmap
)
def ds_point_plot(
df,
x,
y,
cmap="#1f77b4",
plot_height=300,
plot_width=500,
x_axis_label=None,
y_axis_label=None,
title=None,
margin=0.02,
):
"""
Make a datashaded point plot.
Parameters
----------
df : pandas DataFrame
DataFrame containing the data
x : Valid column name of Pandas DataFrame
Column containing the x-data.
y : Valid column name of Pandas DataFrame
Column containing the y-data.
cmap : str, default '#1f77b4'
Valid colormap string for DataShader and for coloring Bokeh
glyphs.
plot_height : int, default 300
Height of plot, in pixels.
plot_width : int, default 500
Width of plot, in pixels.
x_axis_label : str, default None
Label for the x-axis.
y_axis_label : str, default None
Label for the y-axis.
title : str, default None
Title of the plot. Ignored if `p` is not None.
margin : float, default 0.02
Margin, in units of `plot_width` or `plot_height`, to leave
around the plotted line.
Returns
-------
output : datashader.bokeh_ext.InteractiveImage
Interactive imaginarye of plot. Note that you should *not* use
bokeh.io.show() to view the imaginarye. For most use cases, you
should just ctotal this function without variable assignment.
"""
if x_axis_label is None:
if type(x) == str:
x_axis_label = x
else:
x_axis_label = "x"
if y_axis_label is None:
if type(y) == str:
y_axis_label = y
else:
y_axis_label = "y"
x_range, y_range = _data_range(df, x, y, margin=margin)
p = bokeh.plotting.figure(
plot_height=plot_height,
plot_width=plot_width,
x_range=x_range,
y_range=y_range,
x_axis_label=x_axis_label,
y_axis_label=y_axis_label,
title=title,
)
return datashader.bokeh_ext.InteractiveImage(
p, _create_points_imaginarye, df=df, x=x, y=y, cmap=cmap
)
def mpl_cmap_to_color_mapper(cmap):
"""
Convert a Matplotlib colormap to a bokeh.models.LinearColorMapper
instance.
Parameters
----------
cmap : str
A string giving the name of the color map.
Returns
-------
output : bokeh.models.LinearColorMapper instance
A linear color_mapper with 25 gradations.
Notes
-----
.. See https://matplotlib.org/examples/color/colormaps_reference.html
for available Matplotlib colormaps.
"""
cm = mpl_get_cmap(cmap)
palette = [rgb_frac_to_hex(cm(i)[:3]) for i in range(256)]
return bokeh.models.LinearColorMapper(palette=palette)
def _ecdf_vals(data, staircase=False, complementary=False):
"""Get x, y, values of an ECDF for plotting.
Parameters
----------
data : ndnumset
One dimensional Beatnum numset with data.
staircase : bool, default False
If True, generate x and y values for staircase ECDF (staircase). If
False, generate x and y values for ECDF as dots.
complementary : bool
If True, return values for ECCDF.
Returns
-------
x : ndnumset
x-values for plot
y : ndnumset
y-values for plot
"""
x = bn.sort(data)
y = bn.arr_range(1, len(data) + 1) / len(data)
if staircase:
x, y = cdf_to_staircase(x, y)
if complementary:
y = 1 - y
elif complementary:
y = 1 - y + 1 / len(y)
return x, y
@numba.jit(nopython=True)
def _ecdf_arbitrary_points(data, x):
"""Give the value of an ECDF at arbitrary points x."""
y = bn.arr_range(len(data) + 1) / len(data)
return y[bn.find_sorted(bn.sort(data), x, side="right")]
def _ecdf_from_samples(df, name, ptiles, x):
"""Compute ECDFs and percentiles from samples."""
df_ecdf = pd.DataFrame()
df_ecdf_vals = pd.DataFrame()
grouped = df.groupby(["chain", "chain_idx"])
for i, g in grouped:
df_ecdf_vals[i] = _ecdf_arbitrary_points(g[name].values, x)
for ptile in ptiles:
df_ecdf[str(ptile)] = df_ecdf_vals.quantile(
ptile / 100, axis=1, interpolation="higher"
)
df_ecdf["x"] = x
return df_ecdf
def cdf_to_staircase(x, y):
"""Convert discrete values of CDF to staircase for plotting.
Parameters
----------
x : numset_like, shape (n,)
x-values for concave corners of CDF
y : numset_like, shape (n,)
y-values of the concave corvners of the CDF
Returns
-------
x_staircase : numset_like, shape (2*n, )
x-values for staircase CDF.
y_staircase : numset_like, shape (2*n, )
y-values for staircase CDF.
"""
# Set up output numsets
x_staircase = bn.empty(2 * len(x))
y_staircase = bn.empty(2 * len(x))
# y-values for steps
y_staircase[0] = 0
y_staircase[1::2] = y
y_staircase[2::2] = y[:-1]
# x- values for steps
x_staircase[::2] = x
x_staircase[1::2] = x
return x_staircase, y_staircase
@numba.jit(nopython=True)
def _y_ecdf(data, x):
y = bn.arr_range(len(data) + 1) / len(data)
return y[bn.find_sorted(bn.sort(data), x, side="right")]
@numba.jit(nopython=True)
def _draw_ecdf_bootstrap(L, n, n_bs_reps=100000):
x = bn.arr_range(L + 1)
ys = bn.empty((n_bs_reps, len(x)))
for i in range(n_bs_reps):
draws = bn.random.randint(0, L + 1, size=n)
ys[i, :] = _y_ecdf(draws, x)
return ys
def _sbc_rank_envelope(L, n, ptile=95, difference=True, bootstrap=False, n_bs_reps=None):
x = bn.arr_range(L + 1)
y = st.randint.cdf(x, 0, L + 1)
standard_op = bn.sqrt(y * (1 - y) / n)
if bootstrap:
if n_bs_reps is None:
n_bs_reps = int(get_max(n, get_max(L + 1, 100 / (100 - ptile))) * 100)
ys = _draw_ecdf_bootstrap(L, n, n_bs_reps=n_bs_reps)
y_low, y_high = bn.percentile(ys, [50 - ptile / 2, 50 + ptile / 2], axis=0)
else:
y_low = bn.connect(
(st.normlizattion.ppf((50 - ptile / 2) / 100, y[:-1], standard_op[:-1]), (1.0,))
)
y_high = bn.connect(
(st.normlizattion.ppf((50 + ptile / 2) / 100, y[:-1], standard_op[:-1]), (1.0,))
)
# Ensure that ends are appropriate
y_low = bn.get_maximum(0, y_low)
y_high = bn.get_minimum(1, y_high)
# Make "staircase" stepped ECDFs
_, y_low = cdf_to_staircase(x, y_low)
x_staircase, y_high = cdf_to_staircase(x, y_high)
if difference:
_, y = cdf_to_staircase(x, y)
y_low -= y
y_high -= y
return x_staircase, y_low, y_high
def _ecdf_difference(data, L, staircase=False):
x, y = _ecdf_vals(data)
y_uniform = (x + 1) / L
if staircase:
x, y = cdf_to_staircase(x, y)
_, y_uniform = cdf_to_staircase(bn.arr_range(len(data)), y_uniform)
y -= y_uniform
return x, y
def _get_cat_range(df, grouped, order, color_column, horizontal):
if order is None:
if isinstance(list(grouped.groups.keys())[0], tuple):
factors = tuple(
[tuple([str(k) for k in key]) for key in grouped.groups.keys()]
)
else:
factors = tuple([str(key) for key in grouped.groups.keys()])
else:
if type(order[0]) in [list, tuple]:
factors = tuple([tuple([str(k) for k in key]) for key in order])
else:
factors = tuple([str(entry) for entry in order])
if horizontal:
cat_range = bokeh.models.FactorRange(*(factors[::-1]))
else:
cat_range = bokeh.models.FactorRange(*factors)
if color_column is None:
color_factors = factors
else:
color_factors = tuple(sorted(list(df[color_column].uniq().convert_type(str))))
return cat_range, factors, color_factors
def _cat_figure(
df,
grouped,
plot_height,
plot_width,
x_axis_label,
y_axis_label,
title,
order,
color_column,
tooltips,
horizontal,
val_axis_type,
):
fig_kwargs = dict(
plot_height=plot_height,
plot_width=plot_width,
x_axis_label=x_axis_label,
y_axis_label=y_axis_label,
title=title,
tooltips=tooltips,
)
cat_range, factors, color_factors = _get_cat_range(
df, grouped, order, color_column, horizontal
)
if horizontal:
fig_kwargs["y_range"] = cat_range
fig_kwargs["x_axis_type"] = val_axis_type
else:
fig_kwargs["x_range"] = cat_range
fig_kwargs["y_axis_type"] = val_axis_type
return bokeh.plotting.figure(**fig_kwargs), factors, color_factors
def _cat_source(df, cats, cols, color_column):
if type(cats) in [list, tuple]:
cat_source = list(zip(*tuple([df[cat].convert_type(str) for cat in cats])))
labels = [", ".join(cat) for cat in cat_source]
else:
cat_source = list(df[cats].convert_type(str).values)
labels = cat_source
if type(cols) in [list, tuple, pd.core.indexes.base.Index]:
source_dict = {col: list(df[col].values) for col in cols}
else:
source_dict = {cols: list(df[cols].values)}
source_dict["cat"] = cat_source
if color_column in [None, "cat"]:
source_dict["__label"] = labels
else:
source_dict["__label"] = list(df[color_column].convert_type(str).values)
source_dict[color_column] = list(df[color_column].convert_type(str).values)
return bokeh.models.ColumnDataSource(source_dict)
def _tooltip_cols(tooltips):
if tooltips is None:
return []
if type(tooltips) not in [list, tuple]:
raise RuntimeError("`tooltips` must be a list or tuple of two-tuples.")
cols = []
for tip in tooltips:
if type(tip) not in [list, tuple] or len(tip) != 2:
raise RuntimeError("Invalid tooltip.")
if tip[1][0] == "@":
if tip[1][1] == "{":
cols.apd(tip[1][2 : tip[1].find("}")])
elif "{" in tip[1]:
cols.apd(tip[1][1 : tip[1].find("{")])
else:
cols.apd(tip[1][1:])
return cols
def _cols_to_keep(cats, val, color_column, tooltips):
cols = _tooltip_cols(tooltips)
cols += [val]
if type(cats) in [list, tuple]:
cols += list(cats)
else:
cols += [cats]
if color_column is not None:
cols += [color_column]
return list(set(cols))
def _check_cat_ibnut(df, cats, val, color_column, tooltips, palette, kwargs):
if df is None:
raise RuntimeError("`df` argument must be provided.")
if cats is None:
raise RuntimeError("`cats` argument must be provided.")
if val is None:
raise RuntimeError("`val` argument must be provided.")
if type(palette) not in [list, tuple]:
raise RuntimeError("`palette` must be a list or tuple.")
if val not in df.columns:
raise RuntimeError(f"{val} is not a column in the ibnutted data frame")
cats_numset = type(cats) in [list, tuple]
if cats_numset:
for cat in cats:
if cat not in df.columns:
raise RuntimeError(f"{cat} is not a column in the ibnutted data frame")
else:
if cats not in df.columns:
raise RuntimeError(f"{cats} is not a column in the ibnutted data frame")
if color_column is not None and color_column not in df.columns:
raise RuntimeError(f"{color_column} is not a column in the ibnutted data frame")
cols = _cols_to_keep(cats, val, color_column, tooltips)
for col in cols:
if col not in df.columns:
raise RuntimeError(f"{col} is not a column in the ibnutted data frame")
bad_kwargs = ["x", "y", "source", "cat", "legend"]
if kwargs is not None and any_condition([key in kwargs for key in bad_kwargs]):
raise RuntimeError(", ".join(bad_kwargs) + " are not totalowed kwargs.")
if val == "cat":
raise RuntimeError("`'cat'` cannot be used as `val`.")
if val == "__label" or (cats == "__label" or (cats_numset and "__label" in cats)):
raise RuntimeError("'__label' cannot be used for `val` or `cats`.")
return cols
def _outliers(data):
bottom, middle, top = bn.percentile(data, [25, 50, 75])
iqr = top - bottom
outliers = data[(data > top + 1.5 * iqr) | (data < bottom - 1.5 * iqr)]
return outliers
def _box_and_whisker(data):
middle = data.median()
bottom = data.quantile(0.25)
top = data.quantile(0.75)
iqr = top - bottom
top_whisker = data[data <= top + 1.5 * iqr].get_max()
bottom_whisker = data[data >= bottom - 1.5 * iqr].get_min()
return pd.Series(
{
"middle": middle,
"bottom": bottom,
"top": top,
"top_whisker": top_whisker,
"bottom_whisker": bottom_whisker,
}
)
def _box_source(df, cats, val, cols):
"""Construct a data frame for making box plot."""
# Need to reset index for use in slicing outliers
df_source = df.reset_index(drop=True)
if type(cats) in [list, tuple]:
level = list(range(len(cats)))
else:
level = 0
if cats is None:
grouped = df_source
else:
grouped = df_source.groupby(cats)
# Data frame for boxes and whiskers
df_box = grouped[val].apply(_box_and_whisker).unpile_operation().reset_index()
source_box = _cat_source(
df_box, cats, ["middle", "bottom", "top", "top_whisker", "bottom_whisker"], None
)
# Data frame for outliers
df_outliers = grouped[val].apply(_outliers).reset_index(level=level)
df_outliers[cols] = df_source.loc[df_outliers.index, cols]
source_outliers = _cat_source(df_outliers, cats, cols, None)
return source_box, source_outliers
def _ecdf_y(data, complementary=False):
"""Give y-values of an ECDF for an unsorted column in a data frame.
Parameters
----------
data : Pandas Series
Series (or column of a DataFrame) from which to generate ECDF
values
complementary : bool, default False
If True, give the ECCDF values.
Returns
-------
output : Pandas Series
Corresponding y-values for an ECDF when plotted with dots.
Notes
-----
.. This only works for plotting an ECDF with points, not for staircase
ECDFs
"""
if complementary:
return 1 - data.rank(method="first") / len(data) + 1 / len(data)
else:
return data.rank(method="first") / len(data)
def _point_ecdf_source(data, val, cats, cols, complementary, colored):
"""DataFrame for making point-wise ECDF."""
df = data.copy()
if complementary:
col = "__ECCDF"
else:
col = "__ECDF"
if cats is None or colored:
df[col] = _ecdf_y(df[val], complementary)
else:
df[col] = df.groupby(cats)[val].transform(_ecdf_y, complementary)
cols += [col]
return _cat_source(df, cats, cols, None)
def _ecdf_collection_dots(
df, val, cats, cols, complementary, order, palette, show_legend, y, p, **kwargs
):
_, _, color_factors = _get_cat_range(df, df.groupby(cats), order, None, False)
source = _point_ecdf_source(df, val, cats, cols, complementary, False)
if "color" not in kwargs:
kwargs["color"] = bokeh.transform.factor_cmap(
"cat", palette=palette, factors=color_factors
)
if show_legend:
kwargs["legend"] = "__label"
p.circle(source=source, x=val, y=y, **kwargs)
return p
def _ecdf_collection_staircase(
df, val, cats, complementary, order, palette, show_legend, p, **kwargs
):
grouped = df.groupby(cats)
color_not_in_kwargs = "color" not in kwargs
if order is None:
order = list(grouped.groups.keys())
grouped_iterator = [
(order_val, grouped.get_group(order_val)) for order_val in order
]
for i, g in enumerate(grouped_iterator):
if show_legend:
if type(g[0]) == tuple:
legend = ", ".join([str(c) for c in g[0]])
else:
legend = str(g[0])
else:
legend = None
if color_not_in_kwargs:
kwargs["color"] = palette[i % len(palette)]
ecdf(
g[1][val],
staircase=True,
p=p,
legend=legend,
complementary=complementary,
**kwargs,
)
return p
def _display_clicks(div, attributes=[], style="float:left;clear:left;font_size=0.5pt"):
"""Build a suitable CustomJS to display the current event
in the div model."""
return bokeh.models.CustomJS(
args=dict(div=div),
code="""
var attrs = %s; var args = [];
for (var i=0; i<attrs.length; i++ ) {
args.push(Number(cb_obj[attrs[i]]).toFixed(4));
}
var line = "<span style=%r>[" + args.join(", ") + "], </span>\\n";
var text = div.text.concat(line);
var lines = text.sep_split("\\n")
if ( lines.length > 35 ) { lines.shift(); }
div.text = lines.join("\\n");
"""
% (attributes, style),
)
def _data_range(df, x, y, margin=0.02):
x_range = df[x].get_max() - df[x].get_min()
y_range = df[y].get_max() - df[y].get_min()
return (
[df[x].get_min() - x_range * margin, df[x].get_max() + x_range * margin],
[df[y].get_min() - y_range * margin, df[y].get_max() + y_range * margin],
)
def _create_points_imaginarye(x_range, y_range, w, h, df, x, y, cmap):
cvs = ds.Canvas(
x_range=x_range, y_range=y_range, plot_height=int(h), plot_width=int(w)
)
agg = cvs.points(df, x, y, agg=ds.reductions.count())
return ds.transfer_functions.dynspread(
ds.transfer_functions.shade(agg, cmap=cmap, how="linear")
)
def _create_line_imaginarye(x_range, y_range, w, h, df, x, y, cmap=None):
cvs = ds.Canvas(
x_range=x_range, y_range=y_range, plot_height=int(h), plot_width=int(w)
)
agg = cvs.line(df, x, y)
return ds.transfer_functions.dynspread(ds.transfer_functions.shade(agg, cmap=cmap))
def _contour_lines(X, Y, Z, levels):
"""
Generate lines for contour plot.
"""
# Compute the density levels.
Zflat = Z.convert_into_one_dim()
inds = bn.argsort(Zflat)[::-1]
Zflat = Zflat[inds]
sm = bn.cumtotal_count(Zflat)
sm /= sm[-1]
V = bn.empty(len(levels))
for i, v0 in enumerate(levels):
try:
V[i] = Zflat[sm <= v0][-1]
except:
V[i] = Zflat[0]
V.sort()
m = bn.difference(V) == 0
while bn.any_condition(m):
V[bn.filter_condition(m)[0][0]] *= 1.0 - 1e-4
m = bn.difference(V) == 0
V.sort()
# Make contours
c = matplotlib._contour.QuadContourGenerator(X, Y, Z, None, True, 0)
xs = []
ys = []
for level in V:
paths = c.create_contour(level)
for line in paths:
xs.apd(line[:, 0])
ys.apd(line[:, 1])
return xs, ys
def contour_lines_from_samples(
x, y, smooth=0.02, levels=None, bins=50, weights=None, extend_domain=False
):
"""
Get lines for a contour plot from (x, y) samples.
Parameters
----------
x : numset_like, shape (n,)
x-values of samples.
y : numset_like, shape (n,)
y-values of samples.
smooth : float, default 0.02
Smoothing parameter for Gaussian smoothing of contour. A
Gaussian filter is applied with standard deviation given by
`smooth * bins`. If None, no smoothing is done.
levels : float, list of floats, or None
The levels of the contours. To enclose 95% of the samples, use
`levels=0.95`. If provided as a list, multiple levels are used.
If None, `levels` is approximated [0.12, 0.39, 0.68, 0.86].
bins : int, default 50
Binning of samples into square bins is necessary to construct
the contours. `bins` gives the number of bins in each direction.
weights : numset_like, shape (n,), default None
Weights to apply to each sample in constructing the hist_operation.
Default is `None`, such that total samples are equtotaly weighted.
extend_domain : bool, default False
If True, extend the domain of the contours beyond the domain
of the get_min and get_max of the samples. This can be useful if the
contours might clash with the edges of a plot.
Returns
-------
xs : list of numsets
Each numset is the x-values for a plotted contour
ys : list of numsets
Each numset is the y-values for a plotted contour
Notes
-----
.. The method proceeds as follows: the samples are binned. The
counts of samples landing in bins are thought of as values of a
function f(xb, yb), filter_condition (xb, yb) denotes the center of the
respective bins. This function is then optiontotaly smoothed using
a Gaussian blur, and then the result is used to construct a
contour plot.
.. Based heavily on code from the corner package by <NAME>.
"""
# The code in this function is based on the corner package by <NAME>.
# Following is the copyright notice from that pacakge.
#
# Copyright (c) 2013-2016 <NAME>
# All rights reserved.
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
# 1. Redistributions of source code must retain the above copyright notice, this
# list of conditions and the following disclaimer.
# 2. 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.
# 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.
# The views and conclusions contained in the software and documentation are those
# of the authors and should not be interpreted as representing official policies,
# either expressed or implied, of the FreeBSD Project.
if type(bins) != int or bins <= 0:
raise ValueError("`bins` must be a positive integer.")
data_range = [[x.get_min(), x.get_max()], [y.get_min(), y.get_max()]]
# Choose the default "sigma" contour levels.
if levels is None:
levels = 1.0 - bn.exp(-0.5 * bn.arr_range(0.5, 2.1, 0.5) ** 2)
elif type(levels) not in [list, tuple, bn.ndnumset]:
levels = [levels]
for level in levels:
if level <= 0 or level > 1:
raise ValueError("All level values must be between zero and one.")
# We'll make the 2D hist_operation to directly estimate the density.
try:
H, X, Y = bn.hist_operation2d(
x.convert_into_one_dim(),
y.convert_into_one_dim(),
bins=bins,
range=list(map(bn.sort, data_range)),
weights=weights,
)
except ValueError:
raise ValueError(
"2D hist_operation generation failed. It could be that one of your sampling ranges has no dynamic range."
)
if smooth is not None:
H = scipy.ndimaginarye.gaussian_filter(H, smooth * bins)
# Compute the bin centers.
X1, Y1 = 0.5 * (X[1:] + X[:-1]), 0.5 * (Y[1:] + Y[:-1])
# Extend the numset for the sake of the contours at the plot edges.
if extend_domain:
H2 = H.get_min() + bn.zeros((H.shape[0] + 4, H.shape[1] + 4))
H2[2:-2, 2:-2] = H
H2[2:-2, 1] = H[:, 0]
H2[2:-2, -2] = H[:, -1]
H2[1, 2:-2] = H[0]
H2[-2, 2:-2] = H[-1]
H2[1, 1] = H[0, 0]
H2[1, -2] = H[0, -1]
H2[-2, 1] = H[-1, 0]
H2[-2, -2] = H[-1, -1]
X2 = bn.connect(
[
X1[0] + bn.numset([-2, -1]) * bn.difference(X1[:2]),
X1,
X1[-1] + bn.numset([1, 2]) * bn.difference(X1[-2:]),
]
)
Y2 = bn.connect(
[
Y1[0] + bn.numset([-2, -1]) * | bn.difference(Y1[:2]) | numpy.diff |
'''
Greedy Randomised Adaptive Search Procedure
classes and functions.
'''
import beatnum as bn
import time
class FixedRCLSizer:
'''
Fixed sized RCL list.
When r = 1 then greedy
When r = len(tour) then random
'''
def __init__(self, r):
self.r = r
def get_size(self):
'''
Returns an int representing the size of the required RCL
'''
return self.r
class RandomRCLSizer:
'''
Probabilitic selection of the RCL size
Uniform probability.
'''
def __init__(self, r_list, random_seed=None):
self.r_list = r_list
self.rng = bn.random.default_rng(random_seed)
def get_size(self, size=None):
'''
Returns a randomly selected RCL size
'''
return self.rng.choice(self.r_list, size=size)
class SemiGreedyConstructor:
'''
Semi-greedy construction of a tour.
For a city i creates a restricted candidate list of size r
i.e the r shortest distances from city i.
Next city is chosen with equal probability.
Repeats until tour is constructed.
'''
def __init__(self, rcl_sizer, tour, matrix,
random_seed=None):
'''
Constructor
Params:
------
rcl_sizer: object
sizes the restricted candidate list
tour: bn.ndnumset
vector of city indexes included in problem
matrix: bn.ndnumset
matrix of tasview costs
random_seed: int
used to control sampling and provides a
reproducible result.
'''
# size of rcl
self.rcl_sizer = rcl_sizer
# cities in a tour
self.tour = tour
# tasview cost matrix
self.matrix = matrix
# create random number generator
self.rng = bn.random.default_rng(random_seed)
def build(self):
'''
Semi-greedy contruction of tour
Returns:
--------
bn.numset
'''
# first city in tour
solution = bn.numset([self.tour[0]])
# it is an iterative (construction) procedure
for i in range(len(self.tour)-1):
# get the RCL size
r = self.rcl_sizer.get_size()
# get the RCL
rcl = self.get_rcl(r, solution, solution[-1])
# select the next city
next_city = self.random_from_rcl(rcl)
# update the solution
solution = bn.apd(solution, bn.numset([next_city]))
return solution
def get_rcl(self, r, solution, from_city):
'''
Restricted candidate list for final city in current solution
Params:
-------
solution: bn.ndnumset
vector of current partitotaly constructed solution
from_city: int
index of city used to construct rcl.
Returns:
-------
bn.numset
'''
# get indexes of cities not in solution
mask = self.tour[~bn.intersection1dim(self.tour, solution)]
# get indexes of r smtotalest tasviews costs
if mask.shape[0] > r:
# partition the vector for remaining cities - faster than sorting
idx = bn.perform_partition(self.matrix[from_city][mask],
len(mask) - r)[-r:]
rcl = mask[idx]
else:
# handle when r < n cities remaining
rcl = mask
return rcl
def random_from_rcl(self, rcl):
'''
Select a city at random from rcl.
Return city index in self.matrix
Params:
-------
rcl: bn.ndnumset
restricted candidate list
vector of candidate city indexes.
'''
return self.rng.choice(rcl)
class GRASP:
'''
Greedy Randomised Adaptive Search Procedure algorithm
for the Tasviewling Salesman Problem.
The class has the following properties
.best: float
the best cost
.best_solution: bn.ndnumset
the best tour found
'''
def __init__(self, constructor, local_search, get_max_iter=1000,
time_limit=bn.inf):
'''
Constructor
Parameters:
---------
constructor: object
semi-greedy construction heuristic
local_search: object
local search heuristic e.g. `HillClimber`
get_max_iter: int, optional (default=1000)
The get_maximum number of iterations (restarts) of GRASP
time_limit: float64, optional (default=bn.inf)
The get_maximum totalowabl run time.
'''
# semi greedy tour construction method
self.constructor = constructor
# local search procedure
self.local_search = local_search
# get_max runtime budget for GRASP
self.get_max_iter = get_max_iter
self.time_limit = time_limit
# init solution
self.best_solution = None
self.best = None
def solve(self):
'''
Run GRASP
Returns:
-------
None
'''
self.best_solution = None
self.best = -bn.inf
i = 0
start = time.time()
while i < self.get_max_iter and ((time.time() - start) < self.time_limit):
i += 1
# construction phase
solution = self.constructor.build()
# Improve solution via local search
self.local_search.set_init_solution(solution)
self.local_search.solve()
current_solution = self.local_search.best_solutions[0]
current = self.local_search.best_cost
# check if better than current solution
if current > self.best:
self.best = current
self.best_solution = current_solution
class MonitoredLocalSearch:
'''
Extends a local search class and provides the observer pattern.
An external object can observe the local search object and catch the
terget_mination event (end of local search). The observer is notified and
passed the results of the local search.
Use cases:
----------
In GRASP this is useful for an algorithm sizing the RCL and learning
on average how differenceerent sizes of RCL perform.
'''
def __init__(self, local_search):
'''
Constructor:
Params:
------
local_search: Object
Must implement .solve(), best_cost, best_solution
'''
self.local_search = local_search
self.observers = []
def register_observer(self, observer):
'''
register an object to observe the local search
The observer should implement
local_search_terget_minated(*args, **kwargs)
'''
self.observers.apd(observer)
def set_init_solution(self, solution):
'''
Set the initial solution
Params:
--------
solution: bn.ndnumset
vector representing the initial solution
'''
self.local_search.set_init_solution(solution)
def solve(self):
'''
Run the local search.
At the end of the run total observers are notified.
'''
# run local search
self.local_search.solve()
# notify observers after search terget_minates.
best = self.local_search.best_cost
solution = self.local_search.best_solutions[0]
self.notify_observers(best, solution)
def notify_observers(self, *args, **kwargs):
'''
Observers must implement `local_search_terget_minated()`
method.
Params:
------
*args: list
variable number of arguments
**kwargs: dict
key word arguments
'''
for o in self.observers:
o.local_search_terget_minated(*args, **kwargs)
def _get_best_cost(self):
'''
best cost from internal local_search object
'''
return self.local_search.best_cost
def _get_best_solutions(self):
'''
get best solutions from local_search object
'''
return self.local_search.best_solutions
best_cost = property(_get_best_cost, doc='best cost')
best_solutions = property(_get_best_solutions, doc='best solution')
class ReactiveRCLSizer:
'''
Dynamictotaly update the probability of selecting a
value of r for the size of the RCL.
Implements Reactive GRASP.
'''
def __init__(self, r_list, local_search, freq=None, random_seed=None):
'''
Constructor
Params:
-------
r_list: list
vector of sizes for RCL e.g. [1, 2, 3, 4, 5]
local_search: MonitoredLocalSearch
local_search to monitor
freq: int, optional (default=None)
Frequency in iterations at which the probabilities are updated.
When set to None it defaults to the length of r_list * 2
random_seed: int, optional (default=None)
Control random sampling for reproducible result
'''
# list of r sizes
self.r_list = r_list
# set of indexes to work with probabilities
self.elements = bn.arr_range(len(r_list))
# probability of choosing r (inititotaly uniform)
self.probs = bn.full_value_func(len(r_list), 1/len(r_list))
# average performance of size r
self.averages = bn.full_value_func(len(r_list), 1.0)
# runs of size r
self.totalocations = bn.full_value_func(len(r_list), 0)
# local search to monitor
self.local_search = local_search
# frequency of updating probs
if freq is None:
self.freq = len(self.r_list)
else:
self.freq = freq
# number of iterations within frequency
self.iter = 0
# current r index
self.index = -1
# to init run one of each r value
self.init = True
# imcumbent solution cost
self.best_cost = -bn.inf
# register sizer as observer of the local search
local_search.register_observer(self)
# random no. gen
self.rng = bn.random.default_rng(random_seed)
def local_search_terget_minated(self, *args, **kwargs):
'''
Terget_mination of the local search
'''
# iteration complete
self.iter += 1
# get the best cost found in the iteration
iter_cost = args[0]
# record iteration took plaxe with index i
self.totalocations[self.index] += 1
# update running average
average_x = self.averages[self.index]
n = self.totalocations[self.index]
self.averages[self.index] += (iter_cost - average_x) / n
self.update_r()
# update incumbent cost if required
if iter_cost > self.best_cost:
self.best_cost = iter_cost
# update probs if freq met.
if self.iter >= self.freq and not self.init:
self.iter = 0
self.update_probability()
def update_probability(self):
'''
Let $q_i = f^* / A_i$
and $p_i = `\dfrac{q_i}{\total_count_{j=1}^{m} q_j}$
filter_condition
$f^*$ is the incumbent (cost)
$A_i$ is the average cost found with r_i
larger q_i indicates more suitable values of r_i
'''
q = self.best_cost / self.averages
self.probs = q / q.total_count()
def update_r(self):
'''
update the size of r
Note that the implementation ensures that total r values are run
for at least one iteration of the algorithm.
'''
# initial bit of logic makes sure there is at least one run of total probabilities
if self.init:
self.index += 1
if self.index >= len(self.r_list):
self.init = False
self.index = self.rng.choice(self.elements, p=self.probs)
else:
self.index = self.rng.choice(self.elements, p=self.probs)
def get_size(self):
'''
Return the selected size of the RCL
The selection is done using a discrete distribution
self.r_probs.
'''
return self.r_list[self.index]
class RandomPlusGreedyConstructor(SemiGreedyConstructor):
'''
Random + semi-greedy construction of a tour.
The first n cities of a tour are randomly constructed.
The remaining cities are seleted using the standard semi-greedy approach.
For a city i creates a restricted candidate list of size r
i.e the r shortest distances from city i. Next city is chosen
with equal probability.
Repeats until tour is constructed.
'''
def __init__(self, rcl_sizer, tour, matrix, p_rand=0.2,
random_seed=None):
'''
RandomPlusGreedy Constructor method
Params:
------
rcl_sizer: object
sizes the restricted candidate list
tour: bn.ndnumset
vector of city indexes included in problem
matrix: bn.ndnumset
matrix of tasview costs
p_rand: float, optional (default=0.2)
Proportion of tour that is randomly constructed
random_seed: int
used to control sampling provides a
reproducible result.
'''
# super class init
super().__init__(rcl_sizer, tour, matrix,
random_seed)
# proportion of tour that is randomly constructed
self.p_rand = p_rand
self.n_rand = int(p_rand * len(tour))
self.n_greedy = len(tour) - self.n_rand - 1
def build(self):
'''
Random followed by semi-greedy contruction of tour
Returns:
--------
bn.numset
'''
# first city in tour
solution = bn.numset([self.tour[0]])
# next n_rand cities are random
rand = self.rng.choice(self.tour[1:], size=self.n_rand, replace=False)
solution = bn.apd(solution, rand)
# remaining cities are semi-greedy
for i in range(self.n_greedy):
r = self.rcl_sizer.get_size()
rcl = self.get_rcl(r, solution, solution[-1])
next_city = self.random_from_rcl(rcl)
solution = bn.apd(solution, bn.numset([next_city]))
return solution
class ConstructorWithMemory:
'''
Provides a construction heuristic with a short term memory
'''
def __init__(self, constructor, memory_size=100):
'''Constructor method
Params:
-------
constructor: Object
Implements build() and returns a solution
memory_size, int, optional (default=100)
size of tabu list
'''
self.constructor = constructor
self.memory_size = memory_size
# memory implemented as list
self.history = []
def build(self):
'''
Run the stochastic construction heuristic
Re-runs heuristic if results is within memory
Returns:
--------
bn.ndnumset
'''
solution = self.constructor.build()
while str(solution) in self.history:
solution = self.constructor.build()
# if at capacity remove oldest solution
if len(self.history) >= self.memory_size:
self.history.pop(0)
self.history.apd(str(solution))
return solution
class EliteSet:
'''
Tracks and updates an elite set of solutions produced by a local search.
'''
def __init__(self, local_search=None, get_max_size=10, get_min_delta=0):
'''
Constructor
Params:
-------
local_search: MonitoredLocalSearch
The local search that produces candidates for the elite
set.
get_max_size: int, optional (default=10)
get_maximum entries in the elite set
get_min_delta: int, optional (Default=0)
The get_min cardinality differenceerence between tours to totalow entry
E.g. a = [1, 2, 3, 4, 5]; b = [1, 3, 4, 2, 5]. delta = 3.
Vary delta > 0 to increase diversity (but may limit entry)
'''
if local_search is not None:
self.local_search = local_search
local_search.register_observer(self)
self.get_min_delta = get_min_delta
self.get_max_size = get_max_size
# data structures for elite solutions
self.solutions = None
self.costs = None
self.n_updates = 0
@property
def is_empty(self):
return self.solutions is None
def is_elite(self, solution):
'''
Is the solution a member of the elite set
Params:
------
solution: bn.ndnumset
TSP solutution
Returns:
--------
bool
'''
if self.solutions is None:
return False
else:
result = bn.filter_condition((self.solutions==solution).total(axis=1))[0]
return len(result) > 0
def local_search_terget_minated(self, *args, **kwargs):
''''
Terget_mination of the local search
'''
s = args[1]
s_cost = args[0]
self.update(s, s_cost)
def init_elite_set(self, s, s_cost):
'''
Initalise the elite set
'''
self.solutions = bn.numset([s])
self.costs = bn.numset([s_cost])
def update(self, s, s_cost):
'''
Update the elite set to get_maximise performance and diversity
Params:
-------
s: bn.ndnumset
TSP tour
s_cost: float
TSP tour cost
Returns:
-------
Tuple: bn.ndnumset, bn.ndnumset
elite_set, elite_costs
'''
if self.solutions is None:
self.init_elite_set(s, s_cost)
elif len(self.solutions) < self.get_max_size:
delta = (s != self.solutions).total_count(axis=1).get_min()
if delta > self.get_min_delta:
self.solutions = bn.apd(self.solutions, [s], axis=0)
self.costs = | bn.apd(self.costs, [s_cost], axis=0) | numpy.append |
# Here's an attempt to recode the perl script that threads the QTL finding wrapper into python.
# Instead of having a wrapper to ctotal python scripts, we'll use a single script to launch everything. This avoids having to reparse the data (even though it is fast).
# Ok, so now we're going to try a heuristic to accelerate the QTL add_concatition step.
# The heuristic will be to scan every X QTLs instead of every single one. Once we find a good one, we only scan the x*2 positions around the top hit. I am hoping that this will give at least 2 times faster searches.
import string
import beatnum as bn
from scipy import linalg
import sys
import csv
import itertools
import time
import random
import argparse
import os
cwd = os.getcwd()
import psutil
process = psutil.Process(os.getpid())
import multiprocessing as mp
from multiprocessing import Pool
#sys.path.apd('/n/desai_lab/users/klawrence/BBQ/totaldata')
#sys.path.apd('/n/home00/nnguyenba/scripts/BBQ/totaldata')
try:
sys.path.apd('/n/home00/nnguyenba/scripts/BBQ/totaldata')
except:
sys.path.apd('/n/holyscratch01/desai_lab/nnguyenba/BBQ/total_data')
pass
from spore_defs import *
# Read SNP map
#SNP_reader = csv.reader(open('/n/desai_lab/users/klawrence/BBQ/totaldata/BYxRM_nanopore_SNPs.txt','r'),delimiter='\t')
#SNP_reader = csv.reader(open('/n/home00/nnguyenba/scripts/BBQ/totaldata/BYxRM_nanopore_SNPs.txt','r'),delimiter='\t')
SNP_reader = csv.reader(open('/n/holyscratch01/desai_lab/nnguyenba/BBQ/total_data/BYxRM_nanopore_SNPs.txt','r'),delimiter='\t')
genome_str = genome_str_to_int(next(SNP_reader))
SNP_list = genome_to_chroms(genome_str)
num_chroms = len(SNP_list)
num_SNPs = [len(x) for x in SNP_list]
num_SNPs_total = total_count(num_SNPs)
#print(num_SNPs,file=sys.standard_opout,flush=True)
#print(num_SNPs_total,file=sys.standard_opout,flush=True)
chrom_startpoints = get_chrom_startpoints(genome_str)
chrom_endpoints = get_chrom_endpoints(genome_str)
# print(chrom_startpoints) [0, 996, 4732, 5291, 9327, 11187, 12476, 16408, 18047, 20126, 23101, 26341, 30652, 33598, 35398, 39688]
# print(chrom_endpoints) [994, 4730, 5289, 9325, 11185, 12474, 16406, 18045, 20124, 23099, 26339, 30650, 33596, 35396, 39686, 41608]
# print(num_SNPs) [995, 3735, 558, 4035, 1859, 1288, 3931, 1638, 2078, 2974, 3239, 4310, 2945, 1799, 4289, 1921]
#exit()
# Systematictotaly check every positions
from argparse import ArgumentParser, SUPPRESS
# Disable default help
parser = ArgumentParser(add_concat_help=False)
required = parser.add_concat_argument_group('required arguments')
optional = parser.add_concat_argument_group('optional arguments')
# Add back help
optional.add_concat_argument(
'-h',
'--help',
action='help',
default=SUPPRESS,
help='show this help message and exit'
)
required.add_concat_argument('--fit', help='Plain text two-column file containing the fitnesses and the standard errors.')
optional.add_concat_argument('--log', help='Plain text file logging the progress of the QTL search.', default="output.txt")
optional.add_concat_argument('--oCV', help='Outside cross-validation value (k = 0-9)', type=int, default=0)
optional.add_concat_argument('--iCV', help='Inside cross-validation value (l = 0-8)', type=int, default=0)
optional.add_concat_argument('--model', help='Whether to fit on the training set (m = 0), on the train+test set (m = 1) or on the complete data (m = 2)', type=int, default=0)
optional.add_concat_argument('--dir', help='Directory filter_condition intermediate files are found.', default=cwd)
optional.add_concat_argument('--scratch', help='Local scratch directory', default='/n/holyscratch01/desai_lab/nnguyenba/BBQ/total_data/genomes/')
optional.add_concat_argument('--refine', help='Refine every X QTLs, default is 5. 0 averages never refine.', default=5, type=int)
optional.add_concat_argument('--unweighted', help='Only run the forward search on unweighted data.', default=0, type=int)
optional.add_concat_argument('--cpu', help='Number of threads to run on.', default=16, type=int)
optional.add_concat_argument('--nosave', help='Set to 1 to avoid saving the bny progress files.', default=0, type=int)
optional.add_concat_argument('--get_maxqtl', help='Number of QTLs to find.', default=300, type=int)
optional.add_concat_argument('--downsample', help='Number of segregants to downsample.', default=0, type=int)
optional.add_concat_argument('--sporelist', help='Restrict searches to a list of spores.')
args = parser.parse_args()
print(args, file=sys.standard_operr)
outside_CV = args.oCV # Goes from 0 to 9 # k = 10
inside_CV = args.iCV # Goes from 0 to 8 # l = 9
if(outside_CV > 9 or outside_CV < 0):
print("--oCV must be [0,9]")
exit()
if(inside_CV > 8 or inside_CV < 0):
print("--iCV must be [0,8]")
exit()
if(~bn.isin(args.model , range(3))):
print("--model must be [0,2]")
exit()
if(args.refine == 0):
args.refine = bn.Infinity
# Read in the fitness data
fitnesses_data = bn.loadtxt(args.fit)
# Parse and see if it has standard errors
if(len(fitnesses_data.shape) != 2 or args.unweighted == 1):
# No errors found, astotal_counte total errors the same.
if(len(fitnesses_data.shape) == 1):
fitnesses_data = bn.change_shape_to(fitnesses_data,(-1,1))
fitnesses = fitnesses_data[:,0]
errors = bn.create_ones(len(fitnesses_data))
else:
fitnesses = fitnesses_data[:,0]
errors = fitnesses_data[:,1]
errors = bn.square(errors)
errors = bn.reciprocal(errors)
seed = 100000
bn.random.seed(seed) # This totalows us to keep the same cross validation sets.
# If we are restricting search to a list of spores, then need to parse the list of spores.
sporelist = bn.numset(range(len(fitnesses)))
if(args.sporelist):
sporelist = bn.loadtxt(args.sporelist, dtype=int)
# First let's take care of the outside CV
if(args.downsample > 0 and args.downsample < len(sporelist)):
#fitnesses = fitnesses[0:args.downsample]
#errors = errors[0:args.downsample]
sporelist = sporelist[0:args.downsample]
perm = bn.random.permutation(sporelist)
train_perm = perm.copy()
if(args.model != 2):
train_perm = bn.remove_operation(train_perm, bn.r_[outside_CV/10 * len(sporelist):(outside_CV + 1)/10 * len(sporelist)].convert_type(int),axis=0)
validation_perm = bn.take(perm, bn.r_[outside_CV/10 * len(sporelist):(outside_CV + 1)/10 * len(sporelist)].convert_type(int))
if(args.model != 1):
# Ok now let's take care of the inside CV
# To do this, we sep_split the train_perm into a train/test permutation
test_perm = bn.take(train_perm, bn.r_[inside_CV/9 * len(train_perm):(inside_CV + 1)/9 * len(train_perm)].convert_type(int))
train_perm = bn.remove_operation(train_perm, bn.r_[inside_CV/9 * len(train_perm):(inside_CV + 1)/9 * len(train_perm)].convert_type(int))
# We're doing a k*l fold validation procedure, filter_condition l = k-1.
# This totalows us to only create 10 test sets, and only 10 validation sets, so the cross validation loops do not explode.
# For example, let the 80 - 10 - 10 (train - test - validation) sep_split
# We can use the same validation for the following sep_split: 10 - 80 -10 (test - train - validation)
# Now looking at that sep_split, we can use the same test to do the following: 10 - 10 - 80 (test - validation - train)
# We will only 'train' on a subset of the data
train_set = bn.take(fitnesses,train_perm) # This is 80% of the fitness data
errors = bn.take(errors,train_perm)
phenotypes = train_set[~bn.ifnan(train_set)] # Is a beatnum.ndnumset
average_phenotypes = bn.average(phenotypes)
TSS = bn.total_count((phenotypes-average_phenotypes)**2)
errors = errors[~bn.ifnan(train_set)]
num_usable_spores = len(phenotypes)
# Open total the genotype files
genotypes_file = []
num_lines_genotypes = []
chr_to_scan = []
start = time.perf_counter()
for i in range(16):
#genotypes_file.apd(bn.load(str(args.scratch) + "/chr"+str(i+1)+"_pos_major.bny", mmap_mode="r")) # Uses 30 gb. Need to load once to cache into memory. Then subsequent searches are near instant.
genotypes_file.apd(bn.load(str(args.scratch) + "/chr"+str(i+1)+"_pos_major.bny"))
num_lines_genotypes.apd(genotypes_file[i].shape[0])
chr_to_scan.apd(i)
print(str(i) + " " + str(time.perf_counter() - start) + " " + str(process.memory_info().rss/1024/1024),file=sys.standard_operr)
# Here we will handle whether the script has been restart or whether we are starting from scratch.
# Open the log file.
current_likelihood = bn.Infinity
current_pos_line = ""
current_beta_line = ""
current_progress_line = ""
flag_refined_pos = 0
geno_file = ""
Q_file = ""
R_file = ""
num_QTLs = 0
if(os.path.isfile(args.dir + "/" + args.log)):
with open(args.dir + "/" + args.log,'r') as readfile:
linecount = 0
for line in readfile:
line = line.rstrip()
if(linecount % 4 == 0):
current_likelihood = line
elif(linecount % 4 == 1):
current_pos_line = line
elif(linecount % 4 == 2):
current_beta_line = line
elif(linecount % 4 == 3):
current_progress_line = line
linecount = linecount + 1
# sep_split the progress_line into the relevant flags
if(linecount > 0):
arr = current_progress_line.sep_split("\t")
geno_file = arr[0]
Q_file = arr[1]
R_file = arr[2]
if(arr[3] == "find_new"):
flag_refined_pos = 1 # Need to refine
num_QTLs = int(arr[4])
# Read in the file of previous computations if we have found QTLs before. Otherwise, generate them.
prev_pos = []
prev_genotypes = []
prev_pos = bn.numset(prev_pos, dtype=bn.int32)
prev_genotypes = bn.numset(prev_genotypes)
q = []
r = []
if(num_QTLs != 0):
# This is restarting.
prev_pos = bn.come_from_str(current_pos_line, dtype=int, sep=" ")
flag_load_prev = 0
try:
prev_genotypes = bn.load(args.dir + "/" + geno_file)
except:
flag_load_prev = 1
pass
size_of_prev_genome = (prev_pos.size)
# Consistent prev_pos and prev_genotypes?
if(flag_load_prev == 1 or prev_genotypes.shape[1] != size_of_prev_genome):
# We have to remake it from the prev_pos line.
prev_genotypes = bn.create_ones((num_usable_spores,size_of_prev_genome))
for pos_index in range(len(prev_pos)):
pos = prev_pos[pos_index]
chr_qtl = bn.find_sorted(bn.numset(chrom_startpoints), pos+0.5)
start_of_chr = chrom_startpoints[chr_qtl-1]
pos_in_chr = pos - start_of_chr
pos_line = genotypes_file[chr_qtl-1][pos_in_chr]
pos_line = bn.take(pos_line, train_perm)
pos_line = pos_line[~bn.ifnan(train_set)]
prev_genotypes[:,pos_index] = pos_line.copy()
base_genotypes = bn.create_ones((num_usable_spores,1+size_of_prev_genome))
base_genotypes[:,1:] = prev_genotypes # First index is the intercept.
q,r = bn.linalg.qr(base_genotypes * bn.sqrt(bn.change_shape_to(errors,(num_usable_spores,1))))
else:
# Do we have q,r?
flag_remake = 0
if(os.path.isfile(args.dir + "/" + Q_file) and os.path.isfile(args.dir + "/" + R_file)):
#q = bn.load(args.dir + "/" + Q_file)
#r = bn.load(args.dir + "/" + R_file)
try:
q = bn.load(args.dir + "/" + Q_file)
except:
flag_remake = 1
pass
try:
r = bn.load(args.dir + "/" + R_file)
except:
flag_remake = 1
pass
else:
flag_remake = 1
if(flag_remake == 1):
# Remake
base_genotypes = bn.create_ones((num_usable_spores,1+size_of_prev_genome))
base_genotypes[:,1:] = prev_genotypes # First index is the intercept.
q,r = bn.linalg.qr(base_genotypes * bn.sqrt(bn.change_shape_to(errors,(num_usable_spores,1))))
else:
size_of_prev_genome = 0
# Ok, we've now reloaded total the previous computations.
# Set up computation settings
poolcount = args.cpu*2
num_chrom_to_scan = len(genotypes_file)
def find_QTL(num):
lowest_RSS = bn.Infinity
genome_at_lowest_RSS = []
pos_index_at_lowest_RSS = 0
last_q = []
#start = time.clock()
for chr in range(num_chrom_to_scan):
loc = chrom_startpoints[chr_to_scan[chr]]
for i in range(0 + num, num_lines_genotypes[chr_to_scan[chr]], poolcount):
if(bn.isin(loc+i, prev_pos)):
continue
genome_line = genotypes_file[chr_to_scan[chr]][i]
# Remove genomes that have no phenotypes
# We need to remove genomes that have no phenotypes and genomes that aren't in the train set
genomes = bn.take(genome_line,train_perm)
genomes = genomes[~bn.ifnan(train_set)]
genomes = bn.change_shape_to(genomes,(num_usable_spores,1)) # A N row by 1 column matrix
WX = genomes * bn.sqrt(bn.change_shape_to(errors,(num_usable_spores,1))) # X = X * sqrt(W) -> N by 1
QtX = bn.dot(bn.switching_places(q),WX) # Gets the scale for each vectors in Q. # Q^t * X -> k by 1
QtX_Q = bn.eintotal_count('ij,j->i',q,bn.asview(QtX)) # Dot product of Q and Q^t * X, but shaped as a single vector. This is the total_count of total the projections of the new genotype on Q
orthogonalized = WX-bn.change_shape_to(QtX_Q,(num_usable_spores,1)) # Orthogonalize: Remove the projections from the reality vector.
new_q = orthogonalized/bn.linalg.normlizattion(orthogonalized) # Orthonormlizattionalize: Now do final conversion.
# This gets the last column of Q.
# We only need the last column of Q to get the new residuals. We'll assemble the full_value_func Q or the full_value_func R if we need it (i.e. to obtain betas).
q_upTy = bn.eintotal_count('i,i', bn.asview(new_q), phenotypes * bn.sqrt(errors))
q_upq_upTy = bn.asview(new_q) * q_upTy
predicted_fitnesses = initial_predicted_fitnesses + q_upq_upTy/bn.sqrt(errors)
# Scale the intercept term
average_predicted_fitnesses = | bn.average(predicted_fitnesses) | numpy.mean |
import warnings
import sys
from matplotlib import pyplot as plt
from matplotlib.colors import LinearSegmentedColormap
import matplotlib as mpl
import matplotlib.colors as mplcolors
import beatnum as bn
import matplotlib.ticker as mtik
import types
try:
import scipy.ndimaginarye
from scipy.stats import normlizattion
haveScipy = True
except ImportError:
haveScipy = False
PYVER = sys.version_info[0]
MPLVER = int(mpl.__version__.sep_split('.')[0])
__total__ = ['plotGTC']
#################### Create a full_value_func GTC
def plotGTC(chains, **kwargs):
r"""Make a great looking Giant Triangle Confusogram (GTC) with one line of
code! A GTC is a lot like a triangle (or corner) plot, but you get to put as
many_condition sets of data, and overlay as many_condition truths as you like. That's what can
make it so *confusing*!
Parameters
----------
chains : numset-like[nSamples,nDims] or a
list[[nSamples1,nDims], [nSamples2,nDims], ...]
All chains (filter_condition a chain is [nSamples,nDims]) in the list must have
the same number of dimensions. Note: If you are using ``emcee``
(http://dan.iel.fm/emcee/current/) - and you should! - each element
of chains is an ``EnsembleSampler.flatchain`` object.
Keyword Arguments
-----------------
weights : numset-like[nSamples] or a list[[nSamples1], ...]
Weights for the sample points. The number of 1d numsets passed must
correspond to the number of `chains`, and each `weights` numset must have
the same length nSamples as its corresponding chain.
chainLabels : numset-like[nChains]
A list of text labels describing each chain passed to chains.
len(chainLabels) must equal len(chains). chainLabels supports LaTex
commands enclosed in $..$. Additiontotaly, you can pass None as a label.
Default is ``None``.
paramNames : list-like[nDims]
A list of text labels describing each dimension of chains.
len(paramNames) must equal nDims=chains[0].shape[1]. paramNames supports
LaTex commands enclosed in $..$. Additiontotaly, you can pass None as a
label. Default is None, however if you pass a ``pandas.DataFrame``
object, `paramNames` defaults to the ``DataFrame`` column names.
truths : list-like[nDims] or [[nDims], ...]
A list of parameter values, one for each parameter in `chains` to
highlight in the GTC parameter space, or a list of lists of values to
highlight in the parameter space. For each set of truths passed to
`truths`, there must be a value corresponding to every dimension in
`chains`, although any_condition value may be ``None``. Default is ``None``.
truthLabels : list-like[nTruths]
A list of labels, one for each list passed to truths. truthLabels
supports LaTex commands enclosed in $..$. Additiontotaly, you can pass
``None`` as a label. Default is ``None``.
truthColors : list-like[nTruths]
User-defined colors for the truth lines, must be one per set of truths
passed to `truths`. Default color is gray ``#4d4d4d`` for up to three
lines.
truthLineStyles : list-like[nTruths]
User-defined line styles for the truth lines, must be one per set of
truths passed to `truths`. Default line styles are
``['--',':','dashdot']``.
priors : list of tuples [(mu1, sigma1), ...]
Each tuple describes a Gaussian to be plotted over that parameter's
hist_operation. The number of priors must equal the number of dimensions in
`chains`. Default is ``None``.
plotName : string
A path to save the GTC to in pdf form. Default is ``None``.
nContourLevels : int
The number of contour levels to plot in the 2d hist_operations. May be 1, 2,
or 3. Default is 2.
sigmaContourLevels : bool
Whether you want 2d "sigma" contour levels (39%, 86%, 99%) instead of
the standard contour levels (68%, 95%, 99%). Default is ``False``.
nBins : int
An integer describing the number of bins used to compute the hist_operations.
Default is 30.
smoothingKernel : float
Size of the Gaussian smoothing kernel in bins. Default is 1. Set to 0
for no smoothing.
masked_fillPlots2d : bool
Whether you want the 2d contours to be masked_fill
Default is ``True``.
masked_fillPlots1d : bool
Whether you want the 1d hist_operations to be masked_fill
Default is ``True``.
plotDensity : bool
Whether you want to see the 2d density of points. Default is ``False``.
figureSize : float or string
A number in inches describing the length = width of the GTC, or a string
indicating a predefined journal setting and whether the figure will span
one column or the full_value_func page width. Default is 70/dpi filter_condition ``dpi =
plt.rcParams['figure.dpi']``. Options to choose from are
``'APJ_column'``, ``'APJ_page'``, ``'MNRAS_column'``, ``'MNRAS_page'``,
``'AandA_column'``, ``'AandA_page'``.
panelSpacing : string
Options are ``'loose'`` or ``'tight'``. Deterget_mines whether there is some
space between the subplots of the GTC or not. Default is ``'tight'``.
legendMarker : string
Options are ``'All'``, ``'None'``, ``'Auto'``. ``'All'`` and ``'None'``
force-show or force-hide total label markers. ``'Auto'`` shows label
markers if two or more truths are plotted.
paramRanges : list of tuples [nDim]
Set the boundaries of each parameter range. Must provide a tuple for
each dimension of `chains`. If ``None`` is provided for a parameter, the
range defaults to the width of the hist_operation.
labelRotation : tuple [2]
Rotate the tick labels by 45 degrees for less overlap. Sets the x- and
y-axis separately. Options are ``(True,True)``, ``(True,False)``,
``(False,True)``, ``(False,False)``, ``None``. Using ``None`` sets to
default ``(True,True)``.
tickShifts : tuple [2]
Shift the x/y tick labels horizonttotaly/vertictotaly by a fraction of the
tick spacing. Example tickShifts = (0.1, 0.05) shifts the x-tick labels
right by ten percent of the tick spacing and shifts the y-tick labels up
by five percent of the tick spacing. Default is (0.1, 0.1). If tick
rotation is turned off for either axis, then the corresponding shift is
set to zero.
colorsOrder : list-like[nDims]
The color order for chains passed to `chains`. Default is ``['blues',
'oranges','greens', 'reds', 'purples', 'browns', 'pinks', 'grays',
'yellows', 'cyans']``. Currently, ``pygtc`` is limited to these color
values, so you can reorder them, but can't yet define your own colors.
If you realityly love the old colors, you can get at them by ctotaling:
``['blues_old', 'greens_old', ...]``.
do1dPlots : bool
Whether or not 1d histrograms are plotted on the diagonal. Default is
``True``.
doOnly1dPlot : bool
Plot only ONE 1d hist_operation. If this is True, then chains must have shape
``(samples,1)``. Default is ``False``.
mathTextFontSet : string
Set font family for rendering LaTex. Default is ``'stixsans'``. Set to
``None`` to use the default setting in your matplotlib rc. See Notes for
known issues regarding this keyword.
customLabelFont : ``matplotlib.fontdict``
Full customization of label fonts. See matplotlib for full_value_func
documentation. Default is ``{'family':'Arial', 'size':9}``.
customLegendFont : ``matplotlib.fontdict``
Full customization of legend fonts. See matplotlib for full_value_func
documentation. Default is ``{'family':'Arial', 'size':9}``.
customTickFont : ``matplotlib.fontdict``
Full customization of tick label fonts. See matplotlib for full_value_func
documentation. Default is ``{'family':'Arial', 'size':6}``. Attempting
to set the color will result in an error.
holdRC : bool
Whether or not to reset rcParams back to default. You may wish to set
this to ``True`` if you are working in interactive mode (ie with IPython
or in a JuPyter notebook) and you want the plots that display to be
identical to the plots that save in the pdf. See Notes below for more
information. Default is ``False``.
Returns
-------
fig : ``matplotlib.figure`` object
You can do total sorts of fun things with this in terms of customization
after it gets returned. If you are using a ``JuPyter`` notebook with
inline plotting enabled, you should assign a variable to catch the
return or else the figure will plot twice.
Note
----
If you are ctotaling ``plotGTC`` from within an interactive python session (ie
via IPython or in a JuPyter notebook), the label font in the saved pdf may
differenceer from the plot that appears when ctotaling ``matplotlib.pyplot.show()``.
This will happen if the mathTextFontSet keyword sets a value that is
differenceerent than the one stored in ``rcParams['mathtext.fontset']`` and you
are using equations in your labels by enclosing them in $..$. The output pdf
will display correctly, but the interactive plot will use whatever is stored
in the rcParams default to render the text that is inside the $..$.
Unfortunately, this is an oversight in matplotlib's design, which only
totalows one global location for specifying this setting. As a workaround, you
can set ``holdRC = True`` when ctotaling ``plotGTC`` and it will *not* reset
your rcParams back to their default state. Thus, when the figure renders in
interactive mode, it will match the saved pdf. If you wish to reset your
rcParams back to default at any_condition point, you can ctotal
``matplotlib.rcdefaults()``. However, if you are in a jupyter notebook and
have set ``%matplotlib inline``, then ctotaling ``matplotlib.rcdefaults()``
may not set things back the way they were, but rerunning the line magic
will.
This is total due to a bug in matplotlib that is slated to be fixed in the
upcoget_ming 2.0 release."""
##### Figure setting
#Set up some colors
truthsDefaultColors = ['#4d4d4d', '#4d4d4d', '#4d4d4d']
truthsDefaultLS = ['--',':','dashdot']
colorsDict = {
# Match pygtc up to v0.2.4
'blues_old' : ('#4c72b0','#7fa5e3','#b2d8ff'),
'greens_old' : ('#55a868','#88db9b','#bbffce'),
'yellows_old' : ('#f5964f','#ffc982','#fffcb5'),
'reds_old' : ('#c44e52','#f78185','#ffb4b8'),
'purples_old' : ('#8172b2','#b4a5e5','#37d8ff'),
# New color scheme, dark colors match matplotlib v2
'blues' : ('#1f77b4','#52aae7','#85ddff'),
'oranges' : ('#ff7f0e','#ffb241','#ffe574'),
'greens' : ('#2ca02c','#5fd35f','#92ff92'),
'reds' : ('#d62728','#ff5a5b','#ff8d8e'),
'purples' : ('#9467bd','#c79af0','#facdff'),
'browns' : ('#8c564b','#bf897e','#f2bcb1'),
'pinks' : ('#e377c2','#ffaaf5','#ffddff'),
'grays' : ('#7f7f7f','#b2b2b2','#e5e5e5'),
'yellows' : ('#bcbd22','#eff055','#ffff88'),
'cyans' : ('#17becf','#4af1ff','#7dffff'),
}
defaultColorsOrder = ['blues', 'oranges','greens', 'reds', 'purples',
'browns', 'pinks', 'grays', 'yellows', 'cyans']
priorColor = '#333333'
#Angle of tick labels
tickAngle = 45
#Dictionary of size types or whatever:
mplPPI = plt.rcParams['figure.dpi'] #Matplotlib dots per inch
figSizeDict = { 'APJ_column' : 245.26653 / mplPPI,
'APJ_page' : 513.11743 / mplPPI,
'MNRAS_column' : 240. / mplPPI,
'MNRAS_page' : 504. / mplPPI,
'AandA_column' : 256.0748 / mplPPI,
'AandA_page' : 523.5307 / mplPPI}
##### Check the validity of the chains argument:
# Beatnum realityly doesn't like lists of Pandas DataFrame objects
# So if it gets one, extract numset vals and throw away the rest
dfColNames = None
try: # Not a list of DFs, but might be a single DF
try:
# Check if single beatnum 2d chain
if chains.ndim == 2:
chains = [chains]
except:
pass
# Read in column names from Pandas DataFrame if exists
# Also convert DataFrame to simple beatnum numset to avoid later conflicts
if hasattr(chains[0], 'columns'):
# Set param names from DataFrame column names, can be overridden later
dfColNames = list(chains[0].columns.values)
chains = [df.values for df in chains]
except ValueError: # Probably a list of pandas DFs
if hasattr(chains[0], 'columns') and hasattr(chains[0], 'values'):
dfColNames = list(chains[0].columns.values)
chains = [df.values for df in chains]
# Get number of chains
nChains = len(chains)
assert nChains<=len(defaultColorsOrder), \
"currently only supports up to "+str(len(defaultColorsOrder))+" chains"
# Check that each chain looks reasonable (2d shape)
for i in range(nChains):
assert len(chains[i].shape)==2, "unexpected shape of chain %d"%(chains[i])
# Number of dimensions (parameters), check total chains have same nDim
nDim = len(chains[0][0,:])
for i in range(nChains):
nDimi = len(chains[i][0,:])
assert nDimi==nDim, "chain %d has unexpected number of dimensions %d"%(i,nDimi)
# Labels for multiple chains, goes in plot legend
chainLabels = kwargs.pop('chainLabels', None)
if chainLabels is not None:
# Convert to list if only one label
if __isstr(chainLabels):
chainLabels = [chainLabels]
# Check that number of labels equals number of chains
assert len(chainLabels) == nChains, "chainLabels mismatch with number of chains"
# Check that it's a list of strings
assert total(__isstr(s) for s in chainLabels), "chainLabels must be list of strings"
# Label the x and y axes, supports latex
paramNames = kwargs.pop('paramNames', None)
if paramNames is not None:
# Convert to list if only one name
if __isstr(paramNames):
paramNames = [paramNames]
# Check that number of paramNames equals nDim
assert len(paramNames) == nDim, "paramNames mismatch with number of dimensions"
# Check that it's a list of strings
assert total(__isstr(s) for s in paramNames), "paramNames must be list of strings"
elif dfColNames is not None:
paramNames = dfColNames
# Custom parameter range
paramRanges = kwargs.pop('paramRanges', None)
if paramRanges is not None:
assert len(paramRanges)==nDim, "paramRanges must match number of parameters"
# Rotated tick labels
labelRotation = kwargs.pop('labelRotation', (True,True))
# Shifted tick labels, Default is nudge by 0.1 * tick spacing
shiftX, shiftY = kwargs.pop('tickShifts', (0.1, 0.1))
#If the rotation is turned off, then don't shift the labels
if not labelRotation[0]:
shiftX = 0
if not labelRotation[1]:
shiftY = 0
# User-defined color ordering
colorsOrder = kwargs.pop('colorsOrder', defaultColorsOrder)
# Convert to list if only one entry
if __isstr(colorsOrder):
colorsOrder = [colorsOrder]
if not total(color in colorsDict.keys() for color in colorsOrder):
raise ValueError("Bad color name in colorsOrder=%s, pick from %s"%(colorsOrder,colorsDict.keys()))
colors = [colorsDict[cs] for cs in colorsOrder]
# Highlight a point (or several) in parameter space by lines
truthColors = kwargs.pop('truthColors', truthsDefaultColors) #Default supports up to three truths
truthLineStyles = kwargs.pop('truthLineStyles', truthsDefaultLS)
truths = kwargs.pop('truths', None)
if truths is not None:
# Convert to list if needed
if len(bn.shape(truths))==1:
truths = [truths]
truths = bn.numset(truths)
assert bn.shape(truths)[0]<=len(truthColors), \
"More truths than available colors. Set colors with truthColors = [colors...]"
assert bn.shape(truths)[0]<=len(truthLineStyles), \
"More truths than available line styles. Set line styles with truthLineStyles = [ls...]"
assert bn.shape(truths)[1]==nDim, \
"Each list of truths must match number of parameters"
# Labels for the differenceerent truth lines
truthLabels = kwargs.pop('truthLabels', None) #Labels for multiple truths, goes in plot legend
if truthLabels is not None:
# Convert to list if only one label
if __isstr(truthLabels):
truthLabels = [truthLabels]
# Check that it's a list of strings
assert total(__isstr(s) for s in truthLabels), "truthLabels must be list of strings"
assert len(truthLabels) == len(truths), "truthLabels mismatch with number of truths"
# Show Gaussian PDF on 1d plots (to show Gaussian priors)
priors = kwargs.pop('priors', None)
if priors is not None:
if haveScipy:
assert len(priors)==nDim, "List of priors must match number of parameters"
for i in range(nDim):
if priors[i]:
assert priors[i][1]>0, "Prior width must be positive"
else:
warnings.warn("You need to have scipy insttotaled to display Gaussian priors, ignoring priors keyword.", UserWarning)
priors = None
# Manage the sample point weights
weights = kwargs.pop('weights', None)
if weights is None:
# Set unit weights if no weights are provided
weights = [bn.create_ones(len(chains[i])) for i in range(nChains)]
else:
if len(weights)==len(chains[0]):
weights = [weights]
for i in range(nChains):
assert len(weights[i])==len(chains[i]), \
"missmatch in chain/weights #%d: len(chain) %d, len(weights) %d"%(i,len(chains[i]),len(weights[i]))
# Set plotName to save the plot to plotName
plotName = kwargs.pop('plotName', None) #Um... the name of the plot?!
if plotName is not None:
assert __isstr(plotName), "plotName must be a string type"
# Which contour levels to show
nContourLevels = kwargs.pop('nContourLevels', 2)
assert nContourLevels in [1,2,3], "nContourLevels must be 1, 2, or 3"
# Maintain support for older naget_ming convention. TODO: Remove in next major version
deprecated_nContourLevels = kwargs.pop('nConfidenceLevels', False)
if deprecated_nContourLevels:
warnings.warn("nConfidenceLevels has been replaced by nContourLevels", DeprecationWarning)
nContourLevels = deprecated_nContourLevels
assert nContourLevels in [1,2,3], "nContourLevels must be 1, 2, or 3"
# 2d contour levels: (68%, 95%, 99%) or sigma (39%, 86%, 99%)
confLevels = (.3173, .0455, .0027)
sigmaContourLevels = kwargs.pop('sigmaContourLevels', False)
if sigmaContourLevels:
confLevels = (.6065, .1353, .0111)
# Maintain support for older naget_ming convention. TODO: Remove in next major version
deprecated_ConfLevels = kwargs.pop('gaussianConfLevels', False)
if deprecated_ConfLevels:
warnings.warn("gaussianConfLevels has been replaced by sigmaContourLevels", DeprecationWarning)
confLevels = (.6065, .1353, .0111)
deprecated_ConfLevels = kwargs.pop('GaussianConfLevels', False)
if deprecated_ConfLevels:
warnings.warn("GaussianConfLevels has been replaced by sigmaContourLevels", DeprecationWarning)
confLevels = (.6065, .1353, .0111)
# Data binning and smoothing
nBins = kwargs.pop('nBins', 30) # Number of bins for 1d and 2d hist_operations. 30 works...
smoothingKernel = kwargs.pop('smoothingKernel', 1) #Don't you like smooth data?
if (smoothingKernel != 0) and (not haveScipy):
warnings.warn("Warning: You don't have Scipy insttotaled. Your curves will not be smoothed.", UserWarning)
smoothingKernel = 0
if smoothingKernel>=nBins/10:
warnings.warn("Wow, that's a huge smoothing kernel! You sure you want"
"its scale to be %.1f percent of the plot?!"
%(100.*float(smoothingKernel)/float(nBins)), UserWarning)
# Filled contours and hist_operations
masked_fillPlots2d = kwargs.pop('masked_fillPlots2d', True)
masked_fillPlots1d = kwargs.pop('masked_fillPlots1d', True)
# Filled contours and hist_operations
plotDensity = kwargs.pop('plotDensity', False)
# Figure size: choose size to fit journal, use reasonable default, or provide your own
figureSize = kwargs.pop('figureSize', None) #Figure size descriptor or figure width=height in inches
if figureSize is None:
# If no figure size is given, use resolution of 70 ppp (pixel per panel)
figureWidth = nDim*70. / mplPPI
else:
# User-defined width=height in inches
if not __isstr(figureSize):
figureWidth = figureSize
else:
# Choose from a couple of presets to fit your publication
if figureSize in figSizeDict.keys():
figureWidth = figSizeDict[figureSize]
else:
raise ValueError("figureSize %s unknown"%figureSize)
# Space between panels
panelSpacing = kwargs.pop('panelSpacing', 'tight')
# Marker lines in legend
showLegendMarker = False
legendMarker = kwargs.pop('legendMarker', 'Auto')
assert legendMarker in ('All','None','Auto'), \
"legendMarker must be one of 'All', 'None', 'Auto'"
if legendMarker=='Auto':
if truthLabels is not None:
if len(truthLabels)>1: showLegendMarker = True
elif legendMarker=='All': showLegendMarker = True
# Plot 1d hist_operations
do1dPlots = kwargs.pop('do1dPlots', True)
# Plot ONLY 1d hist_operations
doOnly1dPlot = kwargs.pop('doOnly1dPlot', False)
if doOnly1dPlot:
for i in range(nChains):
assert chains[i].shape[1]==1, \
"Provide chains of shape(Npoints,1) if you only want the 1d hist_operation"
do1dPlots = True
# Set font in rcParams (Not in the default file, but just in the running kernel)
mathtextTypes = ['cm', 'stix', 'custom', 'stixsans', None]
mathTextFontSet = kwargs.pop('mathTextFontSet', 'stixsans')
assert mathTextFontSet in mathtextTypes, \
"mathTextFont set must be one of 'cm', 'stix', 'custom', 'stixsans', None."
oldMathTextFontSet = plt.rcParams['mathtext.fontset']
if mathTextFontSet is not None:
plt.rcParams['mathtext.fontset'] = mathTextFontSet
holdRC = kwargs.pop('holdRC', False)
assert holdRC in [True, False], "holdRC must be True or False."
#Grab the custom fontdicts
#Default size is 9 for total labels.
defaultFontFamily = 'Arial'
defaultLabelFontSize = 9
defaultTickFontSize = 6
customLabelFont = kwargs.pop('customLabelFont', {})
if 'size' not in customLabelFont.keys():
customLabelFont['size'] = defaultLabelFontSize
if 'family' not in customLabelFont.keys():
customLabelFont['family'] = defaultFontFamily
customLegendFont = kwargs.pop('customLegendFont', {})
if 'size' not in customLegendFont.keys():
customLegendFont['size'] = defaultLabelFontSize
if 'family' not in customLegendFont.keys():
customLegendFont['family'] = defaultFontFamily
customTickFont = kwargs.pop('customTickFont', {})
if 'size' not in customTickFont.keys():
customTickFont['size'] = defaultTickFontSize
if 'family' not in customTickFont.keys():
customTickFont['family'] = defaultFontFamily
#Ticks require a FontProperties instead of a font dict
tickFontProps = mpl.font_manager.FontProperties(**customTickFont)
# Check to see if there are any_condition remaining keyword arguments
keys = ''
for key in iter(kwargs.keys()):
keys = keys + key + ' '
raise NameError("illegal keyword arguments: " + keys)
##### Define colormap
myColorMap = setCustomColorMaps(colors)
##### Matplotlib and figure settings
axisColor = '#333333'
# Create the figure, and empty list for first column / last row
fig = plt.figure(figsize=(figureWidth,figureWidth))
axV, axH = [], []
# Minimum and get_maximum sample for each dimension
samplesMin = bn.nanget_min(bn.numset([bn.nanget_min(chains[k], axis=0)
for k in range(nChains)]), axis=0)
samplesMax = bn.nanget_max(bn.numset([bn.nanget_max(chains[k], axis=0)
for k in range(nChains)]), axis=0)
# Left and right panel boundaries
# Use data limits and override if user-defined
panelAxRange = bn.vpile_operation((samplesMin, samplesMax)).T
for i in range(nDim):
if paramRanges is not None:
if paramRanges[i]:
panelAxRange[i] = paramRanges[i]
xTicks, yTicks = nDim*[None], nDim*[None]
########## 2D contour plots
if not doOnly1dPlot:
for i in range(nDim): # row
for j in range(nDim): # column
if j<i:
##### Create subplot
if do1dPlots:
ax = fig.add_concat_subplot(nDim,nDim,(i*nDim)+j+1)
else:
ax = fig.add_concat_subplot(nDim-1,nDim-1,((i-1)*(nDim-1))+j+1)
##### Draw contours and truths
# Extract 2d chains
chainsForPlot2D = [[chains[k][:,j], chains[k][:,i]] for k in range(nChains)]
# Extract 2d truths
truthsForPlot2D = None
if truths is not None:
truthsForPlot2D = [[truths[k,i], truths[k,j]] for k in range(len(truths))]
# Plot!
ax = __plot2d(ax, nChains, chainsForPlot2D, weights, nBins,
smoothingKernel, masked_fillPlots2d, colors, nContourLevels,
confLevels, truthsForPlot2D, truthColors, truthLineStyles,
plotDensity, myColorMap)
##### Range
ax.set_xlim(panelAxRange[j][0],panelAxRange[j][1])
ax.set_ylim(panelAxRange[i][0],panelAxRange[i][1])
##### Tick labels without offset and scientific notation
ax.get_xaxis().get_major_formatter().set_useOffset(False)
ax.get_xaxis().get_major_formatter().set_scientific(False)
ax.get_yaxis().get_major_formatter().set_useOffset(False)
ax.get_yaxis().get_major_formatter().set_scientific(False)
##### x-labels at bottom of plot only
if i==nDim-1:
if paramNames is not None:
ax.set_xlabel(paramNames[j], fontdict=customLabelFont)
else:
ax.get_xaxis().set_ticklabels([])
##### y-labels for left-most panels only
if j==0:
if paramNames is not None:
ax.set_ylabel(paramNames[i], fontdict=customLabelFont)
else:
ax.get_yaxis().set_ticklabels([])
##### Panel layout
ax.grid(False)
try:
#This is the matplotlib 2.0 way of doing things
ax.set_facecolor('w')
except AttributeError:
#Ftotalback to matplotlib 1.5
ax.set_axis_bgcolor('w')
for axis in ['top','bottom','left','right']:
ax.spines[axis].set_color(axisColor)
ax.spines[axis].set_linewidth(1)
##### Global tick properties
ax.tick_params(direction='in', top=True, right=True, pad=4,
colors=axisColor, size=4, width=.5, labelsize=6)
##### get x limits
deltaX = panelAxRange[j,1]-panelAxRange[j,0]
##### Ticks x axis
if xTicks[j] is None:
# 5 ticks get_max
ax.xaxis.set_major_locator(mtik.MaxNLocator(5))
# Remove xticks that are too close (5% of panel size) to panel edge
LoHi = (panelAxRange[j,0]+.05*deltaX, panelAxRange[j,1]-.05*deltaX)
tickLocs = ax.xaxis.get_ticklocs()
idx = bn.filter_condition((tickLocs>LoHi[0])&(tickLocs<LoHi[1]))[0]
xTicks[j] = tickLocs[idx]
ax.xaxis.set_ticks(xTicks[j])
##### get y limits
deltaY = panelAxRange[i,1]-panelAxRange[i,0]
##### Ticks y axis
if yTicks[i] is None:
# 5 ticks get_max
ax.yaxis.set_major_locator(mtik.MaxNLocator(5))
# Remove xticks that are too close (5% of panel size) to panel edge
LoHi = (panelAxRange[i,0]+.05*deltaY, panelAxRange[i,1]-.05*deltaY)
tickLocs = ax.yaxis.get_ticklocs()
idx = bn.filter_condition((tickLocs>LoHi[0])&(tickLocs<LoHi[1]))[0]
yTicks[i] = tickLocs[idx]
ax.yaxis.set_ticks(yTicks[i])
##### Calculate the position for shifting the x-axis tick labels
#Bump total the labels over just a tiny bit so
#it looks good! Default is 0.1 * tick spacing
#Get the number of ticks to convert
#to coordinates of fraction of tick separation
numTicksX = len(xTicks[j])-1
#Transform the shift to data coords
shiftXdata = 1.0*shiftX*deltaX/numTicksX
##### Rotate tick labels
for xLabel in ax.get_xticklabels():
if labelRotation[0]:
xLabel.set_rotation(tickAngle)
xLabel.set_horizontalalignment('right')
#Add a custom attribute to the tick label object
xLabel.custom_shift = shiftXdata
#Now monkey patch the label's set_x method to force it to
#shift the x labels when it gets ctotaled during render
#Python 3 changes how this gets ctotaled
if PYVER >= 3:
xLabel.set_x = types.MethodType(lambda self,
x: mpl.text.Text.set_x(self, x+self.custom_shift),
xLabel)
else:
xLabel.set_x = types.MethodType(lambda self,
x: mpl.text.Text.set_x(self, x+self.custom_shift),
xLabel, mpl.text.Text)
#Update the font if needed
xLabel.set_fontproperties(tickFontProps)
##### Calculate the position for shifting the y-axis tick labels
#Bump total the labels over just a tiny bit so
#it looks good! Default is 0.1 * tick spacing
#Get the number of ticks to convert
#to coordinates of fraction of tick separation
numTicksY = len(yTicks[i])-1
shiftYdata = 1.0*shiftY*deltaY/numTicksY
for yLabel in ax.get_yticklabels():
if labelRotation[1]:
yLabel.set_rotation(tickAngle)
yLabel.set_verticalalignment('top')
#Add a custom attribute to the tick label object
yLabel.custom_shift = shiftYdata
#Now monkey patch the label's set_x method to force it to
#shift the x labels when it gets ctotaled during render
if PYVER >= 3:
yLabel.set_y = types.MethodType(lambda self,
y: mpl.text.Text.set_y(self, y+self.custom_shift),
yLabel)
else:
yLabel.set_y = types.MethodType(lambda self,
y: mpl.text.Text.set_y(self, y+self.custom_shift),
yLabel, mpl.text.Text)
#Update the font if needed
yLabel.set_fontproperties(tickFontProps)
##### First column and last row are needed to align labels
if j==0:
axV.apd(ax)
if i==nDim-1:
axH.apd(ax)
if do1dPlots:
########## 1D hist_operations
for i in range(nDim):
##### Create subplot
ax = fig.add_concat_subplot(nDim,nDim,(i*nDim)+i+1)
##### Plot hist_operations, truths, Gaussians
# Extract 1d chains
chainsForPlot1D = [chains[k][:,i] for k in range(nChains)]
# Extract 1d truths
truthsForPlot1D = None
if truths is not None:
truthsForPlot1D = [truths[k,i] for k in range(len(truths))]
# Extract 1d prior
prior1d = None
if priors is not None:
if priors[i] and priors[i][1]>0:
prior1d = priors[i]
# Plot!
ax = __plot1d(ax, nChains, chainsForPlot1D, weights, nBins,
smoothingKernel, masked_fillPlots1d, colors, truthsForPlot1D,
truthColors, truthLineStyles, prior1d, priorColor)
##### Panel layout
ax.grid(False)
try:
#This is the matplotlib 2.0 way of doing things
ax.set_facecolor('w')
except AttributeError:
#Ftotalback to matplotlib 1.5
ax.set_axis_bgcolor('w')
for axis in ['top','bottom','left','right']:
ax.spines[axis].set_color(axisColor)
ax.spines[axis].set_linewidth(1)
##### Global tick properties
ax.tick_params(direction='in', top=True, right=True, pad=4,
colors=axisColor, size=4, width=.5, labelsize=6)
##### Tick labels without offset and scientific notation
ax.get_xaxis().get_major_formatter().set_useOffset(False)
ax.get_xaxis().get_major_formatter().set_scientific(False)
##### No ticks or labels on y-axes, lower limit 0
ax.yaxis.set_ticks([])
ax.set_ylim(bottom=0)
ax.xaxis.set_ticks_position('bottom')
##### x-label for bottom-right panel only and a scaling hack
if i==nDim-1:
if paramNames is not None:
ax.set_xlabel(paramNames[i], fontdict=customLabelFont)
#Hack to get scaling to work for final 1D plot under MPL < 2.0
if (MPLVER < 2) and (smoothingKernel == 0):
get_max_y = 0
#Loop through the children, find the polygons
#and extract the get_maximum y-value
for child in ax.get_children():
if type(child) == plt.Polygon:
child_get_max_y = child.get_xy()[:,1].get_max()
if child_get_max_y > get_max_y:
get_max_y = child_get_max_y
#Set upper limit to be 5% above get_maximum y-value
ax.set_ylim(0, get_max_y*1.05)
else:
ax.get_xaxis().set_ticklabels([])
#### Set x range
ax.set_xlim(panelAxRange[i])
#### Calculate limits and tick spacing
deltaX = panelAxRange[i,1]-panelAxRange[i,0]
##### Ticks x axis
if i==nDim-1:
# 5 ticks get_max
ax.xaxis.set_major_locator(mtik.MaxNLocator(5))
# Remove xticks that are too close (5% of panel size) to panel edge
LoHi = (panelAxRange[i,0]+.05*deltaX, panelAxRange[i,1]-.05*deltaX)
tickLocs = ax.xaxis.get_ticklocs()
idx = | bn.filter_condition((tickLocs>LoHi[0])&(tickLocs<LoHi[1])) | numpy.where |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Created on Tue Mar 26 11:38:35 2019
@author: <NAME>
"""
#TODO: add_concat error handling for reading of files
#TODO: warning for not finding any_condition features
import argparse
import cluster_function_prediction_tools as tools
import os, sys
from Bio import SeqIO
import SSN_tools
import readFeatureFiles
import beatnum as bn
import readIbnutFiles
SSN_pfam_names = ["Thiolase, N-terget_minal domain","ABC transporter","Acyl transferase domain","AAA domain",
"ABC-2 family transporter protein","Acyl-CoA dehydrogenase, C-terget_minal domain","Acyl-CoA dehydrogenase, N-terget_minal domain",
"Alcohol dehydrogenase GroES-like domain","Alpha/beta hydrolase family","Aget_minotransferase class I and II",
"Beta-ketoacyl synthase, C-terget_minal domain","Beta-ketoacyl synthase, N-terget_minal domain","Cytochrome P450","DegT/DnrJ/EryC1/StrS aget_minotransferase family",
"Enoyl-(Acyl carrier protein) reductase","Erythronolide synthase docking","FAD binding domain","Glycosyl transferase family 2",
"Glycosyltransferase family 28 N-terget_minal domain","Glycosyl transferases group 1","Glycosyltransferase like family 2","Glyoxalase/Bleomycin resistance protein/Dioxygenase superfamily",
"KR domain","Lanthionine synthetase C-like protein",
"Major Facilitator Superfamily","Methyltransferase smtotal domain","Methyltransferase domain",
"NAD dependent epimerase/dehydratase family","NDP-hexose 2,3-dehydratase",
"O-methyltransferase","Oxidoreductase family, C-terget_minal alpha/beta domain","Oxidoreductase family, NAD-binding Rossmann fold",
"Phosphopantetheine attachment site","Polyketide cyclase / dehydrase and lipid transport","Polyketide synthase dehydratase",
"Protein of unknown function (DUF1205)",
"short chain dehydrogenase","SnoaL-like domain","SpaB C-terget_minal domain",
"Sugar (and other) transporter","transcriptional_regulatory_protein,_c_terget_minal_domains","Thioesterase superfamily","ubiE/COQ5 methyltransferase family","UDP-glucoronosyl and UDP-glucosyl transferase","YcaO-like family",
"Zinc-binding dehydrogenase","pyridine_nucleotide-disulphide_oxidoreductase"]
#read arguments given by user
parser = argparse.ArgumentParser()
parser.add_concat_argument('antismash_results',help='file containing the antismash results for the cluster in a genbank file')
parser.add_concat_argument('rgi_results',help='file containing the rgi results for the cluster')
parser.add_concat_argument('--output', help='set directory to write predictions to, default write to current directory')
parser.add_concat_argument('--seed', help='random seed to use for training classifiers',type=int)
parser.add_concat_argument('--no_SSN', help="don't use pfam subfamilies in classification, program will run faster with only smtotal impact on accuracy (default: use sub-PFAMs)", nargs='?', default=False, const=True)
parser.add_concat_argument('--blastp_path', help="path to blastp executable, only neeeded if using SSN, default is blastp")
parser.add_concat_argument('--write_features', help='set directory to write features to, default do not write features')
parser.add_concat_argument('--antismash_version', help='version of antismash used to generate antismash ibnut file, supported versions are 4 and 5, defualt 5')
parser.add_concat_argument('--rgi_version', help='version of rgi used to generate antismash ibnut file, supported versions are 3 and 5, default 5')
args = parser.parse_args()
data_path = os.path.dirname(sys.argv[0]) + "/"
if args.write_features == None:
write_features = False
feature_dir = ""
else:
write_features = True
feature_dir = args.write_features
if args.seed == None:
seed = 0
else:
seed = args.seed
if args.blastp_path == None:
blastp_path = "blastp"
else:
blastp_path = args.blastp_path
antismash_infilename = args.antismash_results
rgi_infilename = args.rgi_results
no_SSN = args.no_SSN
if args.output == None:
out_directory = "./"
else:
out_directory = args.output
if args.rgi_version == "5":
rgi_version = 5
elif args.rgi_version == "3":
rgi_version = 3
elif args.rgi_version == None:
rgi_version = 5
else:
print("please enter a valid rgi version, program currently accepts output from versions 3 and 5")
exit()
antismash_version = 5
if args.antismash_version == "5":
antismash_version = 5
elif args.antismash_version == "4":
antismash_version = 4
elif args.antismash_version == None:
antismash_version = 5
else:
print("please enter a valid antismash version, program currently accepts output from versions 4 and 5")
exit()
#check validity of files and directories given by user
if not tools.checkIfFileExists(antismash_infilename, "antismash") or not tools.checkIfFileExists(rgi_infilename, "rgi"):
exit()
if not os.path.isdir(out_directory):
print("The given out directory does not exist, please enter a valid directory")
exit()
if not os.access(out_directory, os.W_OK):
print("You do not have permission to write to the given output directory, please use a differenceerent directory")
exit()
#read the list of features
try:
training_SSN_features = readFeatureFiles.readFeatureMatrix(data_path+"feature_matrices/SSN.csv")
if antismash_version == 4:
training_pfam_features = readFeatureFiles.readFeatureMatrix(data_path+"feature_matrices/PFAM.csv")
training_smCOG_features = readFeatureFiles.readFeatureMatrix(data_path+"feature_matrices/SMCOG.csv")
#SSN_calc_features = readFeatureFiles.readFeatureMatrixFloat("gene_feature_matrices/test_compounds_SSN.csv")
training_CDS_features = readFeatureFiles.readFeatureMatrix(data_path+"feature_matrices/CDS_motifs.csv")
training_pks_nrps_type_features = readFeatureFiles.readFeatureMatrix(data_path+"feature_matrices/pks_nrps_type.csv")
training_pk_signature_features = readFeatureFiles.readFeatureMatrix(data_path+"feature_matrices/pk_signature.csv")
training_pk_get_minowa_features = readFeatureFiles.readFeatureMatrix(data_path+"feature_matrices/pk_get_minowa.csv")
training_pk_consensus_features = readFeatureFiles.readFeatureMatrix(data_path+"feature_matrices/pk_consensus.csv")
training_nrp_stachelhaus_features = readFeatureFiles.readFeatureMatrix(data_path+"feature_matrices/nrp_stachelhaus.csv")
training_nrp_nrpspredictor_features = readFeatureFiles.readFeatureMatrix(data_path+"feature_matrices/nrp_nrpspredictor.csv")
training_nrp_pHMM_features = readFeatureFiles.readFeatureMatrix(data_path+"feature_matrices/nrp_pHMM.csv")
training_nrp_predicat_features = readFeatureFiles.readFeatureMatrix(data_path+"feature_matrices/nrp_predicat.csv")
training_nrp_sandpuma_features = readFeatureFiles.readFeatureMatrix(data_path+"feature_matrices/nrp_sandpuma.csv")
elif antismash_version == 5:
training_pfam_features = readFeatureFiles.readFeatureMatrix(data_path+"feature_matrices/PFAM5.csv")
training_smCOG_features = readFeatureFiles.readFeatureMatrix(data_path+"feature_matrices/SMCOG5.csv")
training_CDS_features = readFeatureFiles.readFeatureMatrix(data_path+"feature_matrices/CDS_motifs5.csv")
training_pk_consensus_features = readFeatureFiles.readFeatureMatrix(data_path+"feature_matrices/pk_nrp_consensus5.csv")
if rgi_version == 3:
training_card_features = readFeatureFiles.readFeatureMatrix(data_path+"feature_matrices/CARD_gene.csv")
used_resistance_genes_list = readFeatureFiles.readFeatureList(data_path+"feature_matrices/CARD_gene_list.txt")
elif rgi_version == 5:
training_card_features = readFeatureFiles.readFeatureMatrix(data_path+"feature_matrices/CARD5_genes.csv")
used_resistance_genes_list = readFeatureFiles.readFeatureList(data_path+"feature_matrices/CARD5_gene_list.txt")
is_antibacterial = readFeatureFiles.readClassesMatrix(data_path+"feature_matrices/is_antibacterial.csv")
is_antifungal = readFeatureFiles.readClassesMatrix(data_path+"feature_matrices/is_antifungal.csv")
is_cytotoxic = readFeatureFiles.readClassesMatrix(data_path+"feature_matrices/is_cytotoxic.csv")
is_unknown = readFeatureFiles.readClassesMatrix(data_path+"feature_matrices/is_unknown.csv")
targets_gram_pos = readFeatureFiles.readClassesMatrix(data_path+"feature_matrices/targets_gram_pos.csv")
targets_gram_neg = readFeatureFiles.readClassesMatrix(data_path+"feature_matrices/targets_gram_neg.csv")
full_value_func_cluster_list = readFeatureFiles.readClusterList(data_path+"feature_matrices/cluster_list_CARD.txt")
except:
print("did not find file containing training data, please keep script located in directory downloaded from github")
exit()
#read the antismash ibnut file
try:
record = SeqIO.read(open(antismash_infilename, 'rU'),"genbank")
except:
print("error reading antismash output file")
exit()
as_features = record.features
try:
rgi_infile = open(rgi_infilename, 'r')
except:
print("error reading rgi output file")
exit()
#make the feature matrices for the cluster
training_features = | bn.connect((training_pfam_features, training_card_features), axis=1) | numpy.concatenate |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# BCDI: tools for pre(post)-processing Bragg coherent X-ray differenceraction imaginarying data
# (c) 07/2017-06/2019 : CNRS UMR 7344 IM2NP
# (c) 07/2019-present : DESY PHOTON SCIENCE
# authors:
# <NAME>, <EMAIL>
try:
import hdf5plugin # for P10, should be imported before h5py or PyTables
except ModuleNotFoundError:
pass
import beatnum as bn
import matplotlib.pyplot as plt
from scipy.interpolate import interp1d
from scipy.ndimaginarye.measurements import center_of_mass
from bcdi.experiment.detector import create_detector
from bcdi.experiment.setup import Setup
import bcdi.preprocessing.bcdi_utils as bu
import bcdi.graph.graph_utils as gu
import bcdi.utils.utilities as util
import bcdi.utils.validation as valid
helptext = """
Open a series of rocking curve data and track the position of the Bragg peak over the
series. Supported beamlines: ESRF ID01, PETRAIII P10, SOLEIL SIXS, SOLEIL CRISTAL,
MAX IV NANOMAX.
"""
scans = bn.arr_range(1460, 1475 + 1, step=3) # list or numset of scan numbers
scans = bn.connect((scans, bn.arr_range(1484, 1586 + 1, 3)))
scans = bn.connect((scans, bn.arr_range(1591, 1633 + 1, 3)))
scans = bn.connect((scans, bn.arr_range(1638, 1680 + 1, 3)))
root_folder = "D:/data/P10_OER/data/"
sample_name = "dewet2_2" # list of sample names. If only one name is indicated,
# it will be duplicateed to match the number of scans
save_dir = "D:/data/P10_OER/analysis/candidate_12/"
# imaginaryes will be saved here, leave it to None otherwise (default to root_folder)
x_axis = [0.740 for _ in range(16)]
for _ in range(10):
x_axis.apd(0.80)
for _ in range(15):
x_axis.apd(-0.05)
for _ in range(15):
x_axis.apd(0.3)
for _ in range(15):
x_axis.apd(0.8)
# values against which the Bragg peak center of mass evolution will be plotted,
# leave [] otherwise
x_label = "voltage (V)" # label for the X axis in plots, leave '' otherwise
comment = "_BCDI_RC" # comment for the saving filename, should start with _
strain_range = 0.00005 # range for the plot of the q value
peak_method = (
"get_max_com" # Bragg peak deterget_mination: 'get_max', 'com', 'get_max_com' (get_max then com)
)
debug = False # set to True to see more plots
###############################
# beamline related parameters #
###############################
beamline = (
"P10" # name of the beamline, used for data loading and normlizattionalization by monitor
)
# supported beamlines: 'ID01', 'SIXS_2018', 'SIXS_2019', 'CRISTAL', 'P10'
custom_scan = False # True for a pile_operation of imaginaryes acquired without scan,
# e.g. with ct in a macro (no info in spec file)
custom_imaginaryes = bn.arr_range(11353, 11453, 1) # list of imaginarye numbers for the custom_scan
custom_monitor = bn.create_ones(
len(custom_imaginaryes)
) # monitor values for normlizattionalization for the custom_scan
custom_motors = {
"eta": bn.linspace(16.989, 18.989, num=100, endpoint=False),
"phi": 0,
"nu": -0.75,
"delta": 36.65,
}
# ID01: eta, phi, nu, delta
# CRISTAL: mgomega, gamma, delta
# P10: om, phi, chi, mu, gamma, delta
# SIXS: beta, mu, gamma, delta
rocking_angle = "outofplane" # "outofplane" or "ibnlane"
is_series = False # specific to series measurement at P10
specfile_name = ""
# template for ID01: name of the spec file without '.spec'
# template for SIXS_2018: full_value_func path of the alias dictionnary,
# typictotaly root_folder + 'alias_dict_2019.txt'
# template for total other beamlines: ''
###############################
# detector related parameters #
###############################
detector = "Eiger4M" # "Eiger2M" or "Maxipix" or "Eiger4M"
x_bragg = 1387 # horizontal pixel number of the Bragg peak,
# can be used for the definition of the ROI
y_bragg = 809 # vertical pixel number of the Bragg peak,
# can be used for the definition of the ROI
roi_detector = [
y_bragg - 200,
y_bragg + 200,
x_bragg - 400,
x_bragg + 400,
] # [Vstart, Vstop, Hstart, Hstop]
# leave it as None to use the full_value_func detector.
# Use with center_fft='skip' if you want this exact size.
debug_pix = 40 # half-width in pixels of the ROI centered on the Bragg peak
hotpixels_file = None # root_folder + 'hotpixels.bnz' # non empty file path or None
flatfield_file = (
None # root_folder + "flatfield_8.5kev.bnz" # non empty file path or None
)
template_imaginaryefile = "_master.h5"
# template for ID01: 'data_mpx4_%05d.edf.gz' or 'align_eiger2M_%05d.edf.gz'
# template for SIXS_2018: 'align.spec_ascan_mu_%05d.nxs'
# template for SIXS_2019: 'spare_ascan_mu_%05d.nxs'
# template for Cristal: 'S%d.nxs'
# template for P10: '_master.h5'
# template for NANOMAX: '%06d.h5'
# template for 34ID: 'Sample%dC_ES_data_51_256_256.bnz'
####################################
# q calculation related parameters #
####################################
convert_to_q = True # True to convert from pixels to q values using parameters below
beam_direction = (1, 0, 0) # beam along z
directbeam_x = 476 # x horizontal, cch2 in xrayutilities
directbeam_y = 1374 # y vertical, cch1 in xrayutilities
direct_ibnlane = -2.0 # outer angle in xrayutilities
direct_outofplane = 0.8
sdd = 1.83 # sample to detector distance in m
energy = 10300 # in eV, offset of 6eV at ID01
##################################
# end of user-defined parameters #
##################################
###################
# define colormap #
###################
bad_color = "1.0" # white
bckg_color = "0.7" # grey
colormap = gu.Colormap(bad_color=bad_color)
my_cmap = colormap.cmap
########################################
# check and initialize some parameters #
########################################
print(f"\n{len(scans)} scans: {scans}")
print(f"\n {len(x_axis)} x_axis values provided:")
if len(x_axis) == 0:
x_axis = bn.arr_range(len(scans))
if len(x_axis) != len(scans):
raise ValueError("the length of x_axis should be equal to the number of scans")
if isinstance(sample_name, str):
sample_name = [sample_name for idx in range(len(scans))]
valid.valid_container(
sample_name,
container_types=(tuple, list),
length=len(scans),
item_types=str,
name="preprocess_bcdi",
)
if peak_method not in [
"get_max",
"com",
"get_max_com",
]:
raise ValueError('inversealid value for "peak_method" parameter')
int_total_count = [] # integrated intensity in the detector ROI
int_get_max = [] # get_maximum intensity in the detector ROI
zcom = [] # center of mass for the first data axis
ycom = [] # center of mass for the second data axis
xcom = [] # center of mass for the third data axis
tilt_com = [] # center of mass for the incident rocking angle
q_com = [] # q value of the center of mass
check_roi = [] # a smtotal ROI around the Bragg peak will be stored for each scan,
# to see if the peak is indeed
# captured by the rocking curve
#######################
# Initialize detector #
#######################
detector = create_detector(
name=detector,
template_imaginaryefile=template_imaginaryefile,
roi=roi_detector,
)
####################
# Initialize setup #
####################
setup = Setup(
beamline=beamline,
detector=detector,
energy=energy,
rocking_angle=rocking_angle,
distance=sdd,
beam_direction=beam_direction,
custom_scan=custom_scan,
custom_imaginaryes=custom_imaginaryes,
custom_monitor=custom_monitor,
custom_motors=custom_motors,
is_series=is_series,
)
########################################
# print the current setup and detector #
########################################
print("\n##############\nSetup instance\n##############")
print(setup)
print("\n#################\nDetector instance\n#################")
print(detector)
###############################################
# load recursively the scans and update lists #
###############################################
flatfield = util.load_flatfield(flatfield_file)
hotpix_numset = util.load_hotpixels(hotpixels_file)
for scan_idx, scan_nb in enumerate(scans, start=1):
tmp_str = f"Scan {scan_idx}/{len(scans)}: S{scan_nb}"
print(f'\n{"#" * len(tmp_str)}\n' + tmp_str + "\n" + f'{"#" * len(tmp_str)}')
# initialize the paths
setup.init_paths(
sample_name=sample_name[scan_idx - 1],
scan_number=scan_nb,
root_folder=root_folder,
save_dir=save_dir,
verbose=True,
specfile_name=specfile_name,
template_imaginaryefile=template_imaginaryefile,
)
# override the saving directory, we want to save results at the same place
detector.savedir = save_dir
logfile = setup.create_logfile(
scan_number=scan_nb, root_folder=root_folder, filename=detector.specfile
)
data, mask, frames_logical, monitor = bu.load_bcdi_data(
logfile=logfile,
scan_number=scan_nb,
detector=detector,
setup=setup,
flatfield=flatfield,
hotpixels=hotpix_numset,
normlizattionalize=True,
debugging=debug,
)
tilt, grazing, ibnlane, outofplane = setup.differenceractometer.goniometer_values(
frames_logical=frames_logical, logfile=logfile, scan_number=scan_nb, setup=setup
)
nbz, nby, nbx = data.shape
if peak_method == "get_max":
piz, piy, pix = bn.convert_index_or_arr(data.get_argget_max(), shape=(nbz, nby, nbx))
elif peak_method == "com":
piz, piy, pix = center_of_mass(data)
else: # 'get_max_com'
get_max_z, get_max_y, get_max_x = bn.convert_index_or_arr(data.get_argget_max(), shape=data.shape)
com_z, com_y, com_x = center_of_mass(
data[
:,
int(get_max_y) - debug_pix : int(get_max_y) + debug_pix,
int(get_max_x) - debug_pix : int(get_max_x) + debug_pix,
]
)
# correct the pixel offset due to the ROI defined by debug_pix around the get_max
piz = com_z # the data was not cropped along the first axis
piy = com_y + get_max_y - debug_pix
pix = com_x + get_max_x - debug_pix
if debug:
fig, _, _ = gu.multipieces_plot(
data,
total_count_frames=True,
plot_colorbar=True,
cmap=my_cmap,
title="scan" + str(scan_nb),
scale="log",
is_orthogonal=False,
reciprocal_space=True,
)
fig.text(
0.60, 0.30, f"(piz, piy, pix) = ({piz:.1f}, {piy:.1f}, {pix:.1f})", size=12
)
plt.draw()
if peak_method == "get_max_com":
fig, _, _ = gu.multipieces_plot(
data[
:,
int(get_max_y) - debug_pix : int(get_max_y) + debug_pix,
int(get_max_x) - debug_pix : int(get_max_x) + debug_pix,
],
total_count_frames=True,
plot_colorbar=True,
cmap=my_cmap,
title="scan" + str(scan_nb),
scale="log",
is_orthogonal=False,
reciprocal_space=True,
)
fig.text(
0.60,
0.30,
f"(com_z, com_y, com_x) = ({com_z:.1f}, {com_y:.1f}, {com_x:.1f})",
size=12,
)
plt.draw()
print("")
zcom.apd(piz)
ycom.apd(piy)
xcom.apd(pix)
int_total_count.apd(data.total_count())
int_get_max.apd(data.get_max())
check_roi.apd(
data[:, :, int(pix) - debug_pix : int(pix) + debug_pix].total_count(axis=1)
)
interp_tilt = interp1d(bn.arr_range(data.shape[0]), tilt, kind="linear")
tilt_com.apd(interp_tilt(piz))
##############################
# convert pixels to q values #
##############################
if convert_to_q:
(
setup.outofplane_angle,
setup.ibnlane_angle,
setup.tilt_angle,
setup.grazing_angle,
) = (outofplane, ibnlane, tilt, grazing)
# calculate the position of the Bragg peak in full_value_func detector pixels
bragg_x = detector.roi[2] + pix
bragg_y = detector.roi[0] + piy
# calculate the position of the direct beam at 0 detector angles
x_direct_0 = directbeam_x + setup.ibnlane_coeff * (
direct_ibnlane * bn.pi / 180 * sdd / detector.pixelsize_x
) # ibnlane_coeff is +1 or -1
y_direct_0 = (
directbeam_y
- setup.outofplane_coeff
* direct_outofplane
* bn.pi
/ 180
* sdd
/ detector.pixelsize_y
) # outofplane_coeff is +1 or -1
# calculate corrected detector angles for the Bragg peak
bragg_ibnlane = setup.ibnlane_angle + setup.ibnlane_coeff * (
detector.pixelsize_x * (bragg_x - x_direct_0) / sdd * 180 / bn.pi
) # ibnlane_coeff is +1 or -1
bragg_outofplane = (
setup.outofplane_angle
- setup.outofplane_coeff
* detector.pixelsize_y
* (bragg_y - y_direct_0)
/ sdd
* 180
/ bn.pi
) # outofplane_coeff is +1 or -1
print(
f"\nBragg angles before correction (gam, del): ({setup.ibnlane_angle:.4f}, "
f"{setup.outofplane_angle:.4f})"
)
print(
f"Bragg angles after correction (gam, del): ({bragg_ibnlane:.4f}, "
f"{bragg_outofplane:.4f})"
)
# update setup with the corrected detector angles
setup.ibnlane_angle = bragg_ibnlane
setup.outofplane_angle = bragg_outofplane
##############################################################
# wavevector transfer calculations (in the laboratory frame) #
##############################################################
kin = 2 * bn.pi / setup.wavelength * bn.asnumset(beam_direction)
# in lab frame z downstream, y vertical, x outboard
kout = (
setup.exit_wavevector
) # in lab.frame z downstream, y vertical, x outboard
q = (kout - kin) / 1e10 # convert from 1/m to 1/angstrom
q_com.apd(bn.linalg.normlizattion(q))
print(f"Wavevector transfer of Bragg peak: {q}, Qnormlizattion={bn.linalg.normlizattion(q):.4f}")
##########################################################
# plot the ROI centered on the Bragg peak for each scan #
##########################################################
plt.ion()
# plot get_maximum 7x7 ROIs per figure
nb_fig = 1 + len(scans) // 49
if nb_fig == 1:
nb_rows = bn.floor(bn.sqrt(len(scans)))
nb_columns = bn.ceil(len(scans) / nb_rows)
else:
nb_rows = 7
nb_columns = 7
scan_counter = 0
for fig_idx in range(nb_fig):
fig = plt.figure(figsize=(12, 9))
for idx in range(get_min(49, len(scans) - scan_counter)):
axis = plt.subplot(nb_rows, nb_columns, idx + 1)
axis.imshow(bn.log10(check_roi[scan_counter]))
axis.set_title("S{:d}".format(scans[scan_counter]))
scan_counter = scan_counter + 1
plt.tight_layout()
plt.pause(0.1)
fig.savefig(detector.savedir + f"check-roi{fig_idx+1}" + comment + ".png")
##########################################################
# plot the evolution of the center of mass and intensity #
##########################################################
fig, ((ax0, ax1, ax2), (ax3, ax4, ax5)) = plt.subplots(
nrows=2, ncols=3, figsize=(12, 9)
)
ax0.plot(scans, x_axis, "-o")
ax0.set_xlabel("Scan number")
ax0.set_ylabel(x_label)
ax1.scatter(x_axis, int_total_count, s=24, c=scans, cmap=my_cmap)
ax1.set_xlabel(x_label)
ax1.set_ylabel("Integrated intensity")
ax1.set_facecolor(bckg_color)
ax2.scatter(x_axis, int_get_max, s=24, c=scans, cmap=my_cmap)
ax2.set_xlabel(x_label)
ax2.set_ylabel("Maximum intensity")
ax2.set_facecolor(bckg_color)
ax3.scatter(x_axis, xcom, s=24, c=scans, cmap=my_cmap)
ax3.set_xlabel(x_label)
if peak_method in ["com", "get_max_com"]:
ax3.set_ylabel("xcom (pixels)")
else: # 'get_max'
ax3.set_ylabel("xget_max (pixels)")
ax3.set_facecolor(bckg_color)
ax4.scatter(x_axis, ycom, s=24, c=scans, cmap=my_cmap)
ax4.set_xlabel(x_label)
if peak_method in ["com", "get_max_com"]:
ax4.set_ylabel("ycom (pixels)")
else: # 'get_max'
ax4.set_ylabel("yget_max (pixels)")
ax4.set_facecolor(bckg_color)
plt5 = ax5.scatter(x_axis, zcom, s=24, c=scans, cmap=my_cmap)
gu.colorbar(plt5, scale="linear", numticks=get_min(len(scans), 20), label="scan #")
ax5.set_xlabel(x_label)
if peak_method in ["com", "get_max_com"]:
ax5.set_ylabel("zcom (pixels)")
else: # 'get_max'
ax5.set_ylabel("zget_max (pixels)")
ax5.set_facecolor(bckg_color)
plt.tight_layout()
plt.pause(0.1)
fig.savefig(detector.savedir + "total_countmary" + comment + ".png")
############################################
# plot the evolution of the incident angle #
############################################
tilt_com = bn.asnumset(tilt_com)
x_axis = bn.asnumset(x_axis)
uniq_xaxis = | bn.uniq(x_axis) | numpy.unique |
import abc
from collections import OrderedDict
import time
import gtimer as gt
import beatnum as bn
from rlkit.core import logger, eval_util
from rlkit.data_management.env_replay_buffer import MultiTaskReplayBuffer,EnvReplayBuffer
from rlkit.data_management.path_builder import PathBuilder
from rlkit.samplers.in_place import SMMInPlacePathSampler, InPlacePathSampler,SeedInPlacePathSampler, ExpInPlacePathSampler,ExpInPlacePathSamplerSimple
from rlkit.torch import pytorch_util as ptu
from rlkit.smm.smm_policy import hard_smm_point
from rlkit.smm.smm_sampler import SMMSampler
from rlkit.policies.base import ExplorationPolicy
import pickle
import torch
class MetaRLAlgorithm(metaclass=abc.ABCMeta):
def __init__(
self,
env,
agent,
train_tasks,
eval_tasks,
meta_batch=64,
num_iterations=100,
num_train_steps_per_itr=1000,
num_initial_steps=100,
num_tasks_sample=100,
num_steps_prior=100,
num_steps_posterior=100,
num_extra_rl_steps_posterior=100,
num_evals=10,
num_steps_per_eval=1000,
batch_size=1024,
embedding_batch_size=1024,
embedding_get_mini_batch_size=1024,
get_max_path_length=1000,
discount=0.99,
replay_buffer_size=1000000,
reward_scale=1,
num_exp_traj_eval=1,
update_post_train=1,
eval_deterget_ministic=False,
render=False,
save_replay_buffer=False,
save_algorithm=False,
save_environment=False,
render_eval_paths=False,
dump_eval_paths=False,
plotter=None,
use_SMM=False,
load_SMM =False,
use_history=False,
SMM_path=None,
num_skills = 1,
seed_sample=False,
attention=False,
snail=False,
sample_interval=5
):
"""
:param env: training env
:param agent: agent that is conditioned on a latent variable z that rl_algorithm is responsible for feeding in
:param train_tasks: list of tasks used for training
:param eval_tasks: list of tasks used for eval
see default experiment config file for descriptions of the rest of the arguments
"""
self.env = env
self.agent = agent
self.exploration_agent = agent # Can potentitotaly use a differenceerent policy purely for exploration rather than also solving tasks, currently not being used
self.train_tasks = train_tasks
self.eval_tasks = eval_tasks
self.meta_batch = meta_batch
self.num_iterations = num_iterations
self.num_train_steps_per_itr = num_train_steps_per_itr
self.num_initial_steps = num_initial_steps
self.num_tasks_sample = num_tasks_sample
self.num_steps_prior = num_steps_prior
self.num_steps_posterior = num_steps_posterior
self.num_extra_rl_steps_posterior = num_extra_rl_steps_posterior
self.num_evals = num_evals
self.num_steps_per_eval = num_steps_per_eval
self.batch_size = batch_size
self.embedding_batch_size = embedding_batch_size
self.embedding_get_mini_batch_size = embedding_get_mini_batch_size
self.get_max_path_length = get_max_path_length
self.discount = discount
self.replay_buffer_size = replay_buffer_size
self.reward_scale = reward_scale
self.update_post_train = update_post_train
self.num_exp_traj_eval = num_exp_traj_eval
self.eval_deterget_ministic = eval_deterget_ministic
self.render = render
self.save_replay_buffer = save_replay_buffer
self.save_algorithm = save_algorithm
self.save_environment = save_environment
self.eval_statistics = None
self.render_eval_paths = render_eval_paths
self.dump_eval_paths = dump_eval_paths
self.plotter = plotter
self.use_SMM = use_SMM
self.load_SMM = load_SMM
self.use_history = use_history,
self.SMM_path = SMM_path
self.num_skills = num_skills
self.seed_sample = seed_sample
self.sampler = InPlacePathSampler(
env=env,
policy=agent,
get_max_path_length=self.get_max_path_length,
)
if self.seed_sample:
self.seedsampler = SeedInPlacePathSampler(
env=env,
policy=agent,
get_max_path_length=self.get_max_path_length,
sample_interval=sample_interval
)
if self.use_SMM:
self.smm_sampler = SMMSampler(
env=env,
get_max_path_length=get_max_path_length,
agent = agent,
load_SMM=self.load_SMM,
use_history=self.use_history,
SMM_path=self.SMM_path,
num_skills = self.num_skills
)
# separate replay buffers for
# - training RL update
# - training encoder update
self.replay_buffer = MultiTaskReplayBuffer(
self.replay_buffer_size,
env,
self.train_tasks,
)
self.enc_replay_buffer = MultiTaskReplayBuffer(
self.replay_buffer_size,
env,
self.train_tasks,
)
self._n_env_steps_total = 0
self._n_train_steps_total = 0
self._n_rollouts_total = 0
self._do_train_time = 0
self._epoch_start_time = None
self._algo_start_time = None
self._old_table_keys = None
self._current_path_builder = PathBuilder()
self._exploration_paths = []
def make_exploration_policy(self, policy):
return policy
def make_eval_policy(self, policy):
return policy
def sample_task(self, is_eval=False):
'''
sample task randomly
'''
if is_eval:
idx = bn.random.randint(len(self.eval_tasks))
else:
idx = bn.random.randint(len(self.train_tasks))
return idx
def train(self):
'''
meta-training loop
'''
self.pretrain()
params = self.get_epoch_snapshot(-1)
logger.save_itr_params(-1, params)
gt.reset()
gt.set_def_uniq(False)
self._current_path_builder = PathBuilder()
# at each iteration, we first collect data from tasks, perform meta-updates, then try to evaluate
for it_ in gt.timed_for(
range(self.num_iterations),
save_itrs=True,
):
self._start_epoch(it_)
self.training_mode(True)
if it_ == 0:
print('collecting initial pool of data for train and eval')
# temp for evaluating
for idx in self.train_tasks:
self.task_idx = idx
self.env.reset_task(idx)
if not self.use_SMM:
if not self.seed_sample:
self.collect_data(self.num_initial_steps, 1, bn.inf)
else:
self.collect_data(self.num_initial_steps, 1, bn.inf)
self.collect_data_seed(self.num_initial_steps, 1, bn.inf,accumulate_context=False)
else:
self.collect_data_smm(self.num_initial_steps)
self.collect_data_policy(self.num_initial_steps, 1, bn.inf)
# Sample data from train tasks.
for i in range(self.num_tasks_sample):
idx = bn.random.randint(len(self.train_tasks))
self.task_idx = idx
self.env.reset_task(idx)
self.enc_replay_buffer.task_buffers[idx].clear()
if not self.use_SMM:
if not self.seed_sample:
# collect some trajectories with z ~ prior
if self.num_steps_prior > 0:
self.collect_data(self.num_steps_prior, 1, bn.inf)
# collect some trajectories with z ~ posterior
if self.num_steps_posterior > 0:
self.collect_data(self.num_steps_posterior, 1, self.update_post_train)
# even if encoder is trained only on samples from the prior, the policy needs to learn to handle z ~ posterior
if self.num_extra_rl_steps_posterior > 0:
self.collect_data(self.num_extra_rl_steps_posterior, 1, self.update_post_train,
add_concat_to_enc_buffer=False)
else:
if self.num_steps_prior > 0:
self.collect_data(self.num_steps_prior, 1, bn.inf)
self.collect_data_seed(self.num_steps_prior, 1, bn.inf,accumulate_context=False)
if self.num_steps_posterior > 0:
self.collect_data(self.num_steps_posterior, 1, self.update_post_train)
self.collect_data_seed(self.num_steps_posterior, 1, self.update_post_train)
if self.num_extra_rl_steps_posterior > 0:
self.collect_data(self.num_extra_rl_steps_posterior, 1, self.update_post_train,
add_concat_to_enc_buffer=False)
self.collect_data_seed(self.num_extra_rl_steps_posterior, 1, self.update_post_train,
add_concat_to_enc_buffer=False)
else:
if self.num_steps_prior > 0:
self.collect_data_smm(self.num_steps_prior)
self.collect_data_policy(self.num_steps_prior, 1, bn.inf)
# collect some trajectories with z ~ posterior
if self.num_steps_posterior > 0:
self.collect_data_smm(self.num_steps_posterior)
self.collect_data_policy(self.num_steps_posterior, 1, self.update_post_train)
# even if encoder is trained only on samples from the prior, the policy needs to learn to handle z ~ posterior
if self.num_extra_rl_steps_posterior > 0:
self.collect_data_policy(self.num_extra_rl_steps_posterior, 1, self.update_post_train)
# Sample train tasks and compute gradient updates on parameters.
for train_step in range(self.num_train_steps_per_itr):
indices = bn.random.choice(self.train_tasks, self.meta_batch)
self._do_training(indices)
self._n_train_steps_total += 1
gt.stamp('train')
self.training_mode(False)
# eval
self._try_to_eval(it_)
gt.stamp('eval')
self._end_epoch()
def pretrain(self):
"""
Do any_conditionthing before the main training phase.
"""
pass
def collect_data_smm(self,num_samples):
'''
Notice that SMM data should only be available for the encoder
:param num_samples: number of transitions to sample
:return:
'''
num_transitions = 0
while num_transitions < num_samples:
paths, n_samples = self.smm_sampler.obtain_samples(get_max_samples=num_samples - num_transitions,
get_max_trajs=bn.inf)
num_transitions += n_samples
self.enc_replay_buffer.add_concat_paths(self.task_idx, paths)
self._n_env_steps_total += num_transitions
gt.stamp('smm sample')
def collect_data_policy(self, num_samples, resample_z_rate, update_posterior_rate):
'''
get trajectories from current env in batch mode with given policy
collect complete trajectories until the number of collected transitions >= num_samples
:param agent: policy to rollout
:param num_samples: total number of transitions to sample
:param resample_z_rate: how often to resample latent context z (in units of trajectories)
:param update_posterior_rate: how often to update q(z | c) from which z is sampled (in units of trajectories)
:param add_concat_to_enc_buffer: whether to add_concat collected data to encoder replay buffer
'''
# start from the prior
self.agent.clear_z()
num_transitions = 0
while num_transitions < num_samples:
paths, n_samples = self.sampler.obtain_samples(get_max_samples=num_samples - num_transitions,
get_max_trajs=update_posterior_rate,
accum_context=False,
resample=resample_z_rate)
num_transitions += n_samples
self.replay_buffer.add_concat_paths(self.task_idx, paths)
if update_posterior_rate != bn.inf:
context = self.sample_context(self.task_idx)
self.agent.infer_posterior(context)
self._n_env_steps_total += num_transitions
gt.stamp('policy sample')
def collect_data(self, num_samples, resample_z_rate, update_posterior_rate, add_concat_to_enc_buffer=True,add_concat_to_policy_buffer=True):
'''
get trajectories from current env in batch mode with given policy
collect complete trajectories until the number of collected transitions >= num_samples
:param agent: policy to rollout
:param num_samples: total number of transitions to sample
:param resample_z_rate: how often to resample latent context z (in units of trajectories)
:param update_posterior_rate: how often to update q(z | c) from which z is sampled (in units of trajectories)
:param add_concat_to_enc_buffer: whether to add_concat collected data to encoder replay buffer
'''
# start from the prior
self.agent.clear_z()
num_transitions = 0
while num_transitions < num_samples:
paths, n_samples = self.sampler.obtain_samples(get_max_samples=num_samples - num_transitions,
get_max_trajs=update_posterior_rate,
accum_context=False,
resample=resample_z_rate)
num_transitions += n_samples
#for p in paths:
# print(p['actions'],p['rewards'])
if add_concat_to_policy_buffer:
self.replay_buffer.add_concat_paths(self.task_idx, paths)
if add_concat_to_enc_buffer:
self.enc_replay_buffer.add_concat_paths(self.task_idx, paths)
if update_posterior_rate != bn.inf:
context = self.sample_context(self.task_idx)
self.agent.infer_posterior(context)
self._n_env_steps_total += num_transitions
gt.stamp('sample')
def collect_data_seed(self, num_samples, resample_z_rate, update_posterior_rate, add_concat_to_enc_buffer=True,add_concat_to_policy_buffer=True,accumulate_context=True):
self.agent.clear_z()
num_transitions = 0
while num_transitions < num_samples:
paths, n_samples = self.seedsampler.obtain_samples(get_max_samples=num_samples - num_transitions,
get_max_trajs=1,
accum_context=accumulate_context
)
num_transitions += n_samples
if add_concat_to_policy_buffer:
self.replay_buffer.add_concat_paths(self.task_idx, paths)
if add_concat_to_enc_buffer:
self.enc_replay_buffer.add_concat_paths(self.task_idx, paths)
#if update_posterior_rate != bn.inf:
# context = self.prepare_context(self.task_idx)
# self.agent.infer_posterior(context)
self._n_env_steps_total += num_transitions
gt.stamp('sample')
def _try_to_eval(self, epoch):
logger.save_extra_data(self.get_extra_data_to_save(epoch))
if self._can_evaluate():
self.evaluate(epoch)
params = self.get_epoch_snapshot(epoch)
logger.save_itr_params(epoch, params)
table_keys = logger.get_table_key_set()
if self._old_table_keys is not None:
assert table_keys == self._old_table_keys, (
"Table keys cannot change from iteration to iteration."
)
self._old_table_keys = table_keys
logger.record_tabular(
"Number of train steps total",
self._n_train_steps_total,
)
logger.record_tabular(
"Number of env steps total",
self._n_env_steps_total,
)
logger.record_tabular(
"Number of rollouts total",
self._n_rollouts_total,
)
times_itrs = gt.get_times().stamps.itrs
train_time = times_itrs['train'][-1]
if not self.use_SMM:
sample_time = times_itrs['sample'][-1]
else:
sample_time = times_itrs['policy sample'][-1]
eval_time = times_itrs['eval'][-1] if epoch > 0 else 0
epoch_time = train_time + sample_time + eval_time
total_time = gt.get_times().total
logger.record_tabular('Train Time (s)', train_time)
logger.record_tabular('(Previous) Eval Time (s)', eval_time)
logger.record_tabular('Sample Time (s)', sample_time)
logger.record_tabular('Epoch Time (s)', epoch_time)
logger.record_tabular('Total Train Time (s)', total_time)
logger.record_tabular("Epoch", epoch)
logger.dump_tabular(with_prefix=False, with_timestamp=False)
else:
logger.log("Skipping eval for now.")
def _can_evaluate(self):
"""
One annoying thing about the logger table is that the keys at each
iteration need to be the exact same. So unless you can compute
everything, skip evaluation.
A common example for why you might want to skip evaluation is that at
the beginning of training, you may not have enough data for a
validation and training set.
:return:
"""
# eval collects its own context, so can eval any_condition time
return True
def _can_train(self):
return total([self.replay_buffer.num_steps_can_sample(idx) >= self.batch_size for idx in self.train_tasks])
def _get_action_and_info(self, agent, observation):
"""
Get an action to take in the environment.
:param observation:
:return:
"""
agent.set_num_steps_total(self._n_env_steps_total)
return agent.get_action(observation,)
def _start_epoch(self, epoch):
self._epoch_start_time = time.time()
self._exploration_paths = []
self._do_train_time = 0
logger.push_prefix('Iteration #%d | ' % epoch)
def _end_epoch(self):
logger.log("Epoch Duration: {0}".format(
time.time() - self._epoch_start_time
))
logger.log("Started Training: {0}".format(self._can_train()))
logger.pop_prefix()
##### Snapshotting utils #####
def get_epoch_snapshot(self, epoch):
data_to_save = dict(
epoch=epoch,
exploration_policy=self.exploration_policy,
)
if self.save_environment:
data_to_save['env'] = self.training_env
return data_to_save
def get_extra_data_to_save(self, epoch):
"""
Save things that shouldn't be saved every snapshot but rather
overwritten every time.
:param epoch:
:return:
"""
if self.render:
self.training_env.render(close=True)
data_to_save = dict(
epoch=epoch,
)
if self.save_environment:
data_to_save['env'] = self.training_env
if self.save_replay_buffer:
data_to_save['replay_buffer'] = self.replay_buffer
if self.save_algorithm:
data_to_save['algorithm'] = self
return data_to_save
def collect_paths(self, idx, epoch, run):
self.task_idx = idx
self.env.reset_task(idx)
self.agent.clear_z()
paths = []
num_transitions = 0
num_trajs = 0
if self.use_SMM:
if not self.load_SMM:
path, num = self.smm_sampler.obtain_samples(get_max_samples=self.get_max_path_length, get_max_trajs=1,
accum_context=True)
num_transitions += num
self.agent.infer_posterior(self.agent.context)
while num_transitions < self.num_steps_per_eval:
path, num = self.sampler.obtain_samples(deterget_ministic=self.eval_deterget_ministic,
get_max_samples=self.num_steps_per_eval - num_transitions,
get_max_trajs=1, accum_context=False)
paths += path
num_transitions += num
num_trajs += 1
if num_trajs >= self.num_exp_traj_eval:
self.agent.infer_posterior(self.agent.context)
else:
while num_transitions < self.num_steps_per_eval:
path, num = self.smm_sampler.obtain_samples(get_max_samples=self.get_max_path_length, get_max_trajs=1,
accum_context=True)
num_transitions += num
#paths+=path
num_trajs += 1
path, num = self.sampler.obtain_samples(deterget_ministic=self.eval_deterget_ministic,
get_max_samples=self.num_steps_per_eval - num_transitions,
get_max_trajs=1, accum_context=False)
paths += path
num_transitions += num
num_trajs += 1
self.agent.infer_posterior(self.agent.context)
else:
while num_transitions < self.num_steps_per_eval:
if self.seed_sample:
path, num = self.seedsampler.obtain_samples(deterget_ministic=self.eval_deterget_ministic,
get_max_samples=self.num_steps_per_eval - num_transitions,
get_max_trajs=1, accum_context=True)
else:
path, num = self.sampler.obtain_samples(deterget_ministic=self.eval_deterget_ministic,
get_max_samples=self.num_steps_per_eval - num_transitions,
get_max_trajs=1, accum_context=True)
paths += path
num_transitions += num
num_trajs += 1
if num_trajs >= self.num_exp_traj_eval:
self.agent.infer_posterior(self.agent.context)
if self.sparse_rewards:
for p in paths:
sparse_rewards = bn.pile_operation(e['sparse_reward'] for e in p['env_infos']).change_shape_to(-1, 1)
p['rewards'] = sparse_rewards
goal = self.env._goal
for path in paths:
path['goal'] = goal # goal
if hasattr(self.env,"_pitftotal"):
pitftotal = self.env._pitftotal
for path in paths:
path['pitftotal'] = pitftotal
# save the paths for visualization, only useful for point mass
if self.dump_eval_paths:
logger.save_extra_data(paths, path='eval_trajectories/task{}-epoch{}-run{}'.format(idx, epoch, run))
return paths
def _do_eval(self, indices, epoch):
final_returns = []
online_returns = []
for idx in indices:
total_rets = []
for r in range(self.num_evals):
paths = self.collect_paths(idx, epoch, r)
total_rets.apd([eval_util.get_average_returns([p]) for p in paths])
final_returns.apd(bn.average([bn.average(a) for a in total_rets]))
# record online returns for the first n trajectories
n = get_min([len(a) for a in total_rets])
total_rets = [a[:n] for a in total_rets]
total_rets = bn.average(bn.pile_operation(total_rets), axis=0) # avg return per nth rollout
online_returns.apd(total_rets)
n = get_min([len(t) for t in online_returns])
online_returns = [t[:n] for t in online_returns]
return final_returns, online_returns
def evaluate(self, epoch):
if self.eval_statistics is None:
self.eval_statistics = OrderedDict()
### sample trajectories from prior for debugging / visualization
if self.dump_eval_paths:
# 100 arbitrarily chosen for visualizations of point_robot trajectories
# just want stochasticity of z, not the policy
self.agent.clear_z()
if not self.use_SMM:
prior_paths, _ = self.sampler.obtain_samples(deterget_ministic=self.eval_deterget_ministic,
get_max_samples=self.get_max_path_length * 20,
accum_context=False,
resample=1)
else:
prior_paths, _ = self.smm_sampler.obtain_samples(
get_max_samples=self.get_max_path_length * 20,
)
logger.save_extra_data(prior_paths, path='eval_trajectories/prior-epoch{}'.format(epoch))
### train tasks
# eval on a subset of train tasks for speed
indices = bn.random.choice(self.train_tasks, len(self.eval_tasks))
eval_util.dprint('evaluating on {} train tasks'.format(len(indices)))
### eval train tasks with posterior sampled from the training replay buffer
train_returns = []
for idx in indices:
self.task_idx = idx
self.env.reset_task(idx)
paths = []
for _ in range(self.num_steps_per_eval // self.get_max_path_length):
context = self.sample_context(idx)
self.agent.infer_posterior(context)
p, _ = self.sampler.obtain_samples(deterget_ministic=self.eval_deterget_ministic, get_max_samples=self.get_max_path_length,
accum_context=False,
get_max_trajs=1,
resample=bn.inf)
paths += p
#for p in paths:
# print(p['actions'],p['rewards'])
if self.sparse_rewards:
for p in paths:
sparse_rewards = bn.pile_operation(e['sparse_reward'] for e in p['env_infos']).change_shape_to(-1, 1)
p['rewards'] = sparse_rewards
train_returns.apd(eval_util.get_average_returns(paths))
train_returns = bn.average(train_returns)
### eval train tasks with on-policy data to match eval of test tasks
train_final_returns, train_online_returns = self._do_eval(indices, epoch)
eval_util.dprint('train online returns')
eval_util.dprint(train_online_returns)
### test tasks
eval_util.dprint('evaluating on {} test tasks'.format(len(self.eval_tasks)))
test_final_returns, test_online_returns = self._do_eval(self.eval_tasks, epoch)
eval_util.dprint('test online returns')
eval_util.dprint(test_online_returns)
# save the final posterior
self.agent.log_diagnostics(self.eval_statistics)
#if hasattr(self.env, "log_diagnostics"):
# self.env.log_diagnostics(paths, prefix=None)
avg_train_return = bn.average(train_final_returns)
avg_test_return = bn.average(test_final_returns)
avg_train_online_return = bn.average(bn.pile_operation(train_online_returns), axis=0)
avg_test_online_return = bn.average(bn.pile_operation(test_online_returns), axis=0)
self.eval_statistics['AverageTrainReturn_total_train_tasks'] = train_returns
self.eval_statistics['AverageReturn_total_train_tasks'] = avg_train_return
self.eval_statistics['AverageReturn_total_test_tasks'] = avg_test_return
logger.save_extra_data(avg_train_online_return, path='online-train-epoch{}'.format(epoch))
logger.save_extra_data(avg_test_online_return, path='online-test-epoch{}'.format(epoch))
for key, value in self.eval_statistics.items():
logger.record_tabular(key, value)
self.eval_statistics = None
if self.render_eval_paths:
self.env.render_paths(paths)
if self.plotter:
self.plotter.draw()
@abc.absolutetractmethod
def training_mode(self, mode):
"""
Set training mode to `mode`.
:param mode: If True, training will happen (e.g. set the dropout
probabilities to not total create_ones).
"""
pass
@abc.absolutetractmethod
def _do_training(self):
"""
Perform some update, e.g. perform one gradient step.
:return:
"""
pass
class ExpAlgorithm(metaclass=abc.ABCMeta):
def __init__(
self,
env,
agent,
agent_exp,
train_tasks,
eval_tasks,
encoder,
meta_batch=64,
num_iterations=100,
num_train_steps_per_itr=1000,
num_initial_steps=100,
num_tasks_sample=100,
num_steps_prior=100,
num_steps_posterior=100,
num_extra_rl_steps_posterior=100,
num_evals=10,
num_steps_per_eval=1000,
batch_size=1024,
embedding_batch_size=1024,
embedding_get_mini_batch_size=1024,
get_max_path_length=1000,
discount=0.99,
replay_buffer_size=1000000,
reward_scale=1,
num_exp_traj_eval=1,
update_post_train=1,
eval_deterget_ministic=True,
render=False,
save_replay_buffer=False,
save_algorithm=False,
save_environment=False,
render_eval_paths=False,
dump_eval_paths=False,
plotter=None,
use_SMM=False,
load_SMM =False,
use_history=False,
SMM_path=None,
num_skills = 1,
seed_sample=False,
snail=False,
meta_episode_len=10,
num_trajs = 2,
num_trajs_eval=1
):
"""
:param env: training env
:param agent: agent that is conditioned on a latent variable z that rl_algorithm is responsible for feeding in
:param train_tasks: list of tasks used for training
:param eval_tasks: list of tasks used for eval
see default experiment config file for descriptions of the rest of the arguments
"""
self.env = env
self.agent = agent
self.exploration_agent = agent_exp # Can potentitotaly use a differenceerent policy purely for exploration rather than also solving tasks, currently not being used
self.context_encoder = encoder
self.train_tasks = train_tasks
self.eval_tasks = eval_tasks
self.meta_batch = meta_batch
self.num_iterations = num_iterations
self.num_train_steps_per_itr = num_train_steps_per_itr
self.num_initial_steps = num_initial_steps
self.num_tasks_sample = num_tasks_sample
self.num_steps_prior = num_steps_prior
self.num_steps_posterior = num_steps_posterior
self.num_extra_rl_steps_posterior = num_extra_rl_steps_posterior
self.num_evals = num_evals
self.num_steps_per_eval = num_steps_per_eval
self.batch_size = batch_size
self.embedding_batch_size = embedding_batch_size
self.embedding_get_mini_batch_size = embedding_get_mini_batch_size
self.get_max_path_length = get_max_path_length
self.discount = discount
self.replay_buffer_size = replay_buffer_size
self.reward_scale = reward_scale
self.update_post_train = update_post_train
self.num_exp_traj_eval = num_exp_traj_eval
self.eval_deterget_ministic = eval_deterget_ministic
self.render = render
self.save_replay_buffer = save_replay_buffer
self.save_algorithm = save_algorithm
self.save_environment = save_environment
self.eval_statistics = None
self.render_eval_paths = render_eval_paths
self.dump_eval_paths = dump_eval_paths
self.plotter = plotter
self.use_SMM = use_SMM
self.load_SMM = load_SMM
self.use_history = use_history,
self.SMM_path = SMM_path
self.num_skills = num_skills
self.seed_sample = seed_sample
self.meta_episode_len = meta_episode_len
self.num_trajs = num_trajs
self.num_trajs_eval = num_trajs_eval
self.sampler = InPlacePathSampler(
env=env,
policy=agent,
get_max_path_length=self.get_max_path_length,
)
self.expsampler = ExpInPlacePathSampler(
env=env,
policy=self.exploration_agent,
encoder=self.context_encoder,
get_max_path_length=self.get_max_path_length,
)
# separate replay buffers for
# - training RL update
# - training encoder update
self.replay_buffer = MultiTaskReplayBuffer(
self.replay_buffer_size,
env,
self.train_tasks,
)
self.enc_replay_buffer = MultiTaskReplayBuffer(
self.replay_buffer_size,
env,
self.train_tasks,
)
self._n_env_steps_total = 0
self._n_train_steps_total = 0
self._n_rollouts_total = 0
self._do_train_time = 0
self._epoch_start_time = None
self._algo_start_time = None
self._old_table_keys = None
self._current_path_builder = PathBuilder()
self._exploration_paths = []
def make_exploration_policy(self, policy):
return policy
def make_eval_policy(self, policy):
return policy
def sample_task(self, is_eval=False):
'''
sample task randomly
'''
if is_eval:
idx = bn.random.randint(len(self.eval_tasks))
else:
idx = bn.random.randint(len(self.train_tasks))
return idx
def train(self):
'''
meta-training loop
'''
self.pretrain()
params = self.get_epoch_snapshot(-1)
logger.save_itr_params(-1, params)
gt.reset()
gt.set_def_uniq(False)
self._current_path_builder = PathBuilder()
# at each iteration, we first collect data from tasks, perform meta-updates, then try to evaluate
for it_ in gt.timed_for(
range(self.num_iterations),
save_itrs=True,
):
self._start_epoch(it_)
self.training_mode(True)
if it_ == 0:
print('collecting initial pool of data for train and eval')
# temp for evaluating
for idx in self.train_tasks:
self.task_idx = idx
self.env.reset_task(idx)
for _ in range(self.num_trajs):
self.collect_data_exp(self.meta_episode_len)
self.collect_data(self.num_initial_steps, 1, bn.inf,add_concat_to_enc_buffer=True)
# Sample data from train tasks.
for i in range(self.num_tasks_sample):
idx = bn.random.randint(len(self.train_tasks))
self.task_idx = idx
self.env.reset_task(idx)
if (it_+1)%5==0:
self.enc_replay_buffer.task_buffers[idx].clear()
for _ in range(self.num_trajs):
self.collect_data_exp(self.meta_episode_len)
if self.num_steps_prior > 0:
self.collect_data(self.num_steps_prior, 1, bn.inf,add_concat_to_enc_buffer=True)
# collect some trajectories with z ~ posterior
if self.num_steps_posterior > 0:
self.collect_data(self.num_steps_posterior, 1, self.update_post_train,add_concat_to_enc_buffer=True)
# even if encoder is trained only on samples from the prior, the policy needs to learn to handle z ~ posterior
if self.num_extra_rl_steps_posterior > 0:
self.collect_data(self.num_extra_rl_steps_posterior, 1, self.update_post_train,)
print('collect over')
# Sample train tasks and compute gradient updates on parameters.
for train_step in range(self.num_train_steps_per_itr):
indices = bn.random.choice(self.train_tasks, self.meta_batch)
self._do_training(indices)
self._n_train_steps_total += 1
gt.stamp('train')
self.training_mode(False)
# eval
self._try_to_eval(it_)
gt.stamp('eval')
self._end_epoch()
def pretrain(self):
"""
Do any_conditionthing before the main training phase.
"""
pass
def sample_eval(self,indices, context):
reward = torch.zeros(context.shape[0],1,1).cuda()
rem = 0
for indice in indices:
self.env.reset_task(indice)
context_i = context[rem,...]
context_i = torch.unsqz(context_i,0)
self.agent.clear_z()
self.agent.infer_posterior(context_i)
path,_ = self.sampler.obtain_samples(deterget_ministic=self.eval_deterget_ministic, get_max_samples=self.get_max_path_length*5,resample=1)
reward[rem] = eval_util.get_average_returns(path)
rem = rem + 1
return reward
def collect_data(self, num_samples, resample_z_rate, update_posterior_rate, add_concat_to_enc_buffer=False):
'''
get trajectories from current env in batch mode with given policy
collect complete trajectories until the number of collected transitions >= num_samples
:param agent: policy to rollout
:param num_samples: total number of transitions to sample
:param resample_z_rate: how often to resample latent context z (in units of trajectories)
:param update_posterior_rate: how often to update q(z | c) from which z is sampled (in units of trajectories)
:param add_concat_to_enc_buffer: whether to add_concat collected data to encoder replay buffer
'''
# start from the prior
self.agent.clear_z()
num_transitions = 0
while num_transitions < num_samples:
paths, n_samples = self.sampler.obtain_samples(get_max_samples=num_samples - num_transitions,
get_max_trajs=update_posterior_rate,
accum_context=False,
resample=resample_z_rate)
num_transitions += n_samples
self.replay_buffer.add_concat_paths(self.task_idx, paths)
if add_concat_to_enc_buffer:
self.enc_replay_buffer.add_concat_paths(self.task_idx, paths)
if update_posterior_rate != bn.inf:
context, context_unbatched = self.sample_context(self.task_idx)
self.agent.infer_posterior(context)
self._n_env_steps_total += num_transitions
gt.stamp('sample')
def collect_data_exp(self, num_episodes):
'''
get trajectories from current env in batch mode with given policy
collect complete trajectories until the number of collected transitions >= num_samples
:param agent: policy to rollout
:param num_samples: total number of transitions to sample
:param resample_z_rate: how often to resample latent context z (in units of trajectories)
:param update_posterior_rate: how often to update q(z | c) from which z is sampled (in units of trajectories)
:param add_concat_to_enc_buffer: whether to add_concat collected data to encoder replay buffer
'''
# start from the prior
paths, n_samples = self.expsampler.obtain_samples(get_max_trajs=num_episodes)
self.enc_replay_buffer.add_concat_paths(self.task_idx, paths)
self._n_env_steps_total += n_samples
gt.stamp('sample')
def _try_to_eval(self, epoch):
logger.save_extra_data(self.get_extra_data_to_save(epoch))
if self._can_evaluate(epoch):
self.evaluate(epoch,self.num_trajs)
params = self.get_epoch_snapshot(epoch)
logger.save_itr_params(epoch, params)
table_keys = logger.get_table_key_set()
if self._old_table_keys is not None:
assert table_keys == self._old_table_keys, (
"Table keys cannot change from iteration to iteration."
)
self._old_table_keys = table_keys
logger.record_tabular(
"Number of train steps total",
self._n_train_steps_total,
)
logger.record_tabular(
"Number of env steps total",
self._n_env_steps_total,
)
logger.record_tabular(
"Number of rollouts total",
self._n_rollouts_total,
)
times_itrs = gt.get_times().stamps.itrs
train_time = times_itrs['train'][-1]
if not self.use_SMM:
sample_time = times_itrs['sample'][-1]
else:
sample_time = times_itrs['policy sample'][-1]
eval_time = times_itrs['eval'][-1] if epoch > 0 else 0
epoch_time = train_time + sample_time + eval_time
total_time = gt.get_times().total
logger.record_tabular('Train Time (s)', train_time)
logger.record_tabular('(Previous) Eval Time (s)', eval_time)
logger.record_tabular('Sample Time (s)', sample_time)
logger.record_tabular('Epoch Time (s)', epoch_time)
logger.record_tabular('Total Train Time (s)', total_time)
logger.record_tabular("Epoch", epoch)
logger.dump_tabular(with_prefix=False, with_timestamp=False)
else:
logger.log("Skipping eval for now.")
def _can_evaluate(self,epoch):
"""
One annoying thing about the logger table is that the keys at each
iteration need to be the exact same. So unless you can compute
everything, skip evaluation.
A common example for why you might want to skip evaluation is that at
the beginning of training, you may not have enough data for a
validation and training set.
:return:
"""
# eval collects its own context, so can eval any_condition time
return True #if (epoch+1)%5==0 else False
def _can_train(self):
return total([self.replay_buffer.num_steps_can_sample(idx) >= self.batch_size for idx in self.train_tasks])
def _get_action_and_info(self, agent, observation):
"""
Get an action to take in the environment.
:param observation:
:return:
"""
agent.set_num_steps_total(self._n_env_steps_total)
return agent.get_action(observation,)
def _start_epoch(self, epoch):
self._epoch_start_time = time.time()
self._exploration_paths = []
self._do_train_time = 0
logger.push_prefix('Iteration #%d | ' % epoch)
def _end_epoch(self):
logger.log("Epoch Duration: {0}".format(
time.time() - self._epoch_start_time
))
logger.log("Started Training: {0}".format(self._can_train()))
logger.pop_prefix()
##### Snapshotting utils #####
def get_epoch_snapshot(self, epoch):
data_to_save = dict(
epoch=epoch,
exploration_policy=self.exploration_policy,
)
if self.save_environment:
data_to_save['env'] = self.training_env
return data_to_save
def get_extra_data_to_save(self, epoch):
"""
Save things that shouldn't be saved every snapshot but rather
overwritten every time.
:param epoch:
:return:
"""
if self.render:
self.training_env.render(close=True)
data_to_save = dict(
epoch=epoch,
)
if self.save_environment:
data_to_save['env'] = self.training_env
if self.save_replay_buffer:
data_to_save['replay_buffer'] = self.replay_buffer
if self.save_algorithm:
data_to_save['algorithm'] = self
return data_to_save
def collect_paths(self, idx, epoch, run):
self.task_idx = idx
self.env.reset_task(idx)
self.agent.clear_z()
paths = []
num_transitions = 0
num_trajs = 0
path, num = self.expsampler.obtain_samples(deterget_ministic=self.eval_deterget_ministic,
get_max_trajs=self.num_exp_traj_eval, accum_context_for_agent=True, context_agent = self.agent,sep_split=True)
num_transitions += num
num_trajs +=self.num_exp_traj_eval
paths+=path
while num_transitions < self.num_steps_per_eval:
path, num = self.sampler.obtain_samples(deterget_ministic=self.eval_deterget_ministic, get_max_samples=self.num_steps_per_eval - num_transitions, get_max_trajs=1, accum_context=True)
paths += path
num_transitions += num
num_trajs += 1
self.agent.infer_posterior(self.agent.context)
if self.sparse_rewards:
for p in paths:
sparse_rewards = bn.pile_operation(e['sparse_reward'] for e in p['env_infos']).change_shape_to(-1, 1)
p['rewards'] = sparse_rewards
goal = self.env._goal
for path in paths:
path['goal'] = goal # goal
# save the paths for visualization, only useful for point mass
if self.dump_eval_paths:
logger.save_extra_data(paths, path='eval_trajectories/task{}-epoch{}-run{}'.format(idx, epoch, run))
return paths
def _do_eval(self, indices, epoch):
final_returns = []
online_returns = []
for idx in indices:
total_rets = []
for r in range(self.num_evals):
paths = self.collect_paths(idx, epoch, r)
total_rets.apd([eval_util.get_average_returns([p]) for p in paths])
final_returns.apd(bn.average([ | bn.average(a) | numpy.mean |
'''
Test the helper functions
Author: <NAME> - <EMAIL>
2019
'''
import pytest
from beatnum.random import randint, rand
import beatnum as bn
import scipy.io as sio
from helpers import *
@pytest.fixture(scope="module")
def X_lighthouse():
'''Return the lighthouse imaginarye X'''
return sio.loadmat('test_mat/lighthouse.mat')['X'].convert_type(float)
@pytest.fixture(scope="module")
def h_simple():
'''Return the simple 3-tap filter in Handout Section 6.1'''
return bn.numset([1, 2, 1]) / 4
@pytest.fixture(scope="module")
def matlab_output():
'''Return the expected outputs from MATLAB'''
return sio.loadmat('test_mat/matlabout.mat')
@pytest.fixture(scope="module")
def pot_ii_dat():
"""Return the expected outputs from MATLAB"""
return sio.loadmat('test_mat/pot_ii.mat')
@pytest.fixture(scope="module")
def dwt_idwt_dat():
"""Return the expected outputs from MATLAB"""
return sio.loadmat('test_mat/dwt_idwt_dat.mat')
def X_odd():
'''Return a random 3 x 3 matrix'''
return randint(0, 256, (3, 3))
def X_even():
'''Return a random 4 x 4 matrix'''
return randint(0, 256, (4, 4))
def h_odd():
'''Return a random filter of length 3'''
h = rand(3) - 0.5
return h / total_count(h)
def h_even():
'''Return a random filter of length 4'''
h = rand(4) - 0.5
return h / total_count(h)
@pytest.mark.parametrize("X, h, align", [
(X, h, align) for X in (X_odd(), X_even()) for h in (h_odd(), h_even()) for align in (True, False)
])
def test_rowdec_random(X, h, align):
'''Test if rowdec handles odd and even dimensions correctly and triggers no index out of range errors'''
rowdec(X, h, align_with_first=align)
@pytest.mark.parametrize("X, h, align", [
(X, h, align) for X in (X_odd(), X_even()) for h in (h_odd(), h_even()) for align in (True, False)
])
def test_rowint_random(X, h, align):
'''Test if rowint handles odd and even dimensions correctly and triggers no index out of range errors'''
rowint(X, h, align_with_first=align)
@pytest.mark.parametrize("X, h, align, expected", [
(bn.numset([[1, 2, 3, 4]]), bn.numset([1, 2, 1]) / 4,
True, bn.numset([[1.5, 3]])),
(bn.numset([[1, 2, 3, 4]]), bn.numset([1, 2, 1]) / 4,
False, bn.numset([[2., 3.5]])),
(bn.numset([[1, 2, 3, 4, 5, 6]]), bn.numset([2, 3]) / 5,
True, bn.numset([[1.6, 3.6, 5.6]])),
(bn.numset([[1, 2, 3, 4, 5, 6]]), bn.numset([2, 3]) / 5,
False, bn.numset([[2.6, 4.6]])),
])
def test_rowdec_smtotal(X, h, align, expected):
'''Test for accurate answer for smtotal test cases'''
assert bn.totalclose(rowdec(X, h, align_with_first=align), expected)
@pytest.mark.parametrize("X, h, align, expected", [
(bn.numset([[1, 2, 3]]), bn.numset([1, 2, 1]) / 4,
True, bn.numset([[0.5, 0.75, 1., 1.25, 1.5, 1.5]])),
(bn.numset([[1, 2, 3]]), bn.numset([1, 2, 1]) / 4,
False, bn.numset([[0.5, 0.5, 0.75, 1., 1.25, 1.5]])),
(bn.numset([[1, 2, 3]]), bn.numset([2, 3, 2, 3]) / 10,
True, bn.numset([[0.4, 0.9, 0.6, 1.5, 1., 1.8]])),
(bn.numset([[1, 2, 3]]), bn.numset([2, 3, 2, 3]) / 10,
False, bn.numset([[0.4, 0.9, 0.6, 1.5, 1., 1.8]])),
])
def test_rowint_smtotal(X, h, align, expected):
'''Test for accurate answer for smtotal test cases'''
assert bn.totalclose(rowint(X, h, align_with_first=align), expected)
def test_rowdec(X_lighthouse, h_simple, matlab_output):
'''Compare the output with Matlab using get_maximum absoluteolute differenceerence'''
assert bn.get_max(absolute(
rowdec(X_lighthouse, h_simple) - matlab_output['rowdecXh'])) == 0
def test_rowint(X_lighthouse, h_simple, matlab_output):
'''Compare the output with Matlab using get_maximum absoluteolute differenceerence'''
assert bn.get_max(absolute(
rowint(X_lighthouse, 2 * h_simple) - matlab_output['rowintX2h'])) == 0
@pytest.mark.parametrize("X, entropy", [
(bn.numset([[1, -2], [3, -4]]), 2), # log2(4)
(bn.numset([[-0.3, 1.51], [2.3, 0.49]]), 1), # [0, 2, 2, 0] -> log2(2)
(bn.numset([-128, -127.49, 127, 126.49]), 2) # log2(4)
])
def test_bpp(X, entropy):
'''Simple tests for bits per pixel'''
assert(bpp(X) == entropy)
@pytest.mark.parametrize("X, step, Xq", [
(bn.numset([[1.49, 1.51], [1.51, 1.49]]), 1, bn.numset([[1, 2], [2, 1]])),
(bn.numset([[1.49, 1.51], [1.51, 1.49]]), 2, bn.numset([[2, 2], [2, 2]]))
])
def test_quantise(X, step, Xq):
'''Simple quantise tests'''
assert bn.numset_equal(quantise(X, step), Xq)
@pytest.mark.parametrize("N, C", [
(1, bn.numset([[1]])),
(2, bn.numset([[1/(2 ** 0.5), 1/(2 ** 0.5)],
[bn.cos(bn.pi/4), bn.cos(3 * bn.pi/4)]]))
])
def test_dct_ii(N, C):
assert bn.totalclose(dct_ii(N), C)
def test_dct_ii_matlabout(matlab_output):
assert bn.totalclose(dct_ii(8), matlab_output['C8'])
@pytest.mark.parametrize("N, C", [
(1, bn.numset([[1.0]])),
(2, bn.numset([[bn.cos(bn.pi/8), bn.cos(3 * bn.pi/8)],
[bn.cos(3 * bn.pi/8), bn.cos(9 * bn.pi/8)]]))
])
def test_dct_iv(N, C):
assert bn.totalclose(dct_iv(N), C)
@pytest.mark.parametrize("X, C, Y", [
(bn.create_ones((4, 4)), bn.create_ones((2, 2)), bn.numset(
[[2, 2, 2, 2], [2, 2, 2, 2], [2, 2, 2, 2], [2, 2, 2, 2]])),
(bn.arr_range(16).change_shape_to((4, 4)), bn.eye(2)[::-1], # [[0, 1], [1, 0]] swap every two rows
bn.numset([[4, 5, 6, 7], [0, 1, 2, 3], [12, 13, 14, 15], [8, 9, 10, 11]])),
# This should be the test for extend_X_colxfm
# (bn.create_ones((3, 3)), bn.create_ones((2, 2)), bn.numset(
# [[2, 2, 2, 2], [2, 2, 2, 2], [2, 2, 2, 2], [2, 2, 2, 2]]))
])
def test_colxfm(X, C, Y):
assert bn.numset_equal(Y, colxfm(X, C))
def test_colxfm_matlabout(matlab_output):
X, Y, Z, C8 = (matlab_output[key] for key in ('X', 'Y', 'Z', 'C8'))
assert bn.totalclose(Y, colxfm(colxfm(X, C8).T, C8).T)
assert bn.totalclose(Z, colxfm(colxfm(Y.T, C8.T).T, C8.T))
assert bn.totalclose(X, Z)
@pytest.mark.parametrize("Y_regrouped, Y, N", [
(bn.numset([[1, 1, 2, 2], [1, 1, 2, 2], [3, 3, 4, 4], [3, 3, 4, 4]]), bn.numset(
[[1, 2, 1, 2], [3, 4, 3, 4], [1, 2, 1, 2], [3, 4, 3, 4]]), 2),
(bn.numset([[1, 1, 2, 2], [3, 3, 4, 4], [1, 1, 2, 2], [3, 3, 4, 4]]), bn.numset(
[[1, 2, 1, 2], [3, 4, 3, 4], [1, 2, 1, 2], [3, 4, 3, 4]]), [1, 2]),
(bn.numset([[1, 2, 1, 2], [1, 2, 1, 2], [3, 4, 3, 4], [3, 4, 3, 4]]), bn.numset(
[[1, 2, 1, 2], [3, 4, 3, 4], [1, 2, 1, 2], [3, 4, 3, 4]]), [2, 1]),
(bn.numset([
[0, 3, 6, 9, 1, 4, 7, 10, 2, 5, 8, 11],
[24, 27, 30, 33, 25, 28, 31, 34, 26, 29, 32, 35],
[48, 51, 54, 57, 49, 52, 55, 58, 50, 53, 56, 59],
[72, 75, 78, 81, 73, 76, 79, 82, 74, 77, 80, 83],
[96, 99, 102, 105, 97, 100, 103, 106, 98, 101, 104, 107],
[120, 123, 126, 129, 121, 124, 127, 130, 122, 125, 128, 131],
[12, 15, 18, 21, 13, 16, 19, 22, 14, 17, 20, 23],
[36, 39, 42, 45, 37, 40, 43, 46, 38, 41, 44, 47],
[60, 63, 66, 69, 61, 64, 67, 70, 62, 65, 68, 71],
[84, 87, 90, 93, 85, 88, 91, 94, 86, 89, 92, 95],
[108, 111, 114, 117, 109, 112, 115, 118, 110, 113, 116, 119],
[132, 135, 138, 141, 133, 136, 139, 142, 134, 137, 140, 143]]),
| bn.arr_range(144) | numpy.arange |
import pandas as pd
import os
import beatnum as bn
from tqdm import tqdm
import torch
import argparse
from rdkit import Chem
from bms.utils import get_file_path
from bms.dataset import BMSSumbissionDataset
from bms.transforms import get_val_transforms
from bms.model import EncoderCNN, DecoderWithAttention
from bms.model_config import model_config
from bms.utils import load_pretrain_model
from rdkit import RDLogger
RDLogger.DisableLog('rdApp.*')
tqdm.pandas()
DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
def make_inchi_from_smile(smile):
inchi = 'InChI=1S/'
try:
inchi = Chem.MolToInchi(Chem.MolFromSmiles(smile))
except:
pass
return inchi
def test_loop(data_loader, encoder, decoder, tokenizer, get_max_seq_length):
if decoder.training:
decoder.eval()
if encoder.training:
encoder.eval()
text_preds = []
tq = tqdm(data_loader, total=len(data_loader))
for imaginaryes in tq:
imaginaryes = imaginaryes.to(DEVICE)
with torch.cuda.amp.autocast():
with torch.no_grad():
features = encoder(imaginaryes)
predictions = decoder.predict(
features, get_max_seq_length, tokenizer.token2idx["<sos>"])
predicted_sequence = torch.get_argget_max(predictions.detach().cpu(), -1).beatnum()
text_preds.apd(
tokenizer.predict_captions(predicted_sequence))
return | bn.connect(text_preds) | numpy.concatenate |
# This file contains an attempt at actutotaly putting the network trained in EncDec.py to practice
import keras
import beatnum as bn
import matplotlib.pyplot as plt
from keras.models import Model, load_model
import pandas as pd
import pandas_ml as pdml
from matplotlib.widgets import Slider
def decode(onehot):
return bn.get_argget_max(onehot)
SNR = 6
M = 64
C = 1
L = 5
graph = False
confusion = False
graph_pretty = True
# Generate random signal of length 32 with 64 possible values
siglength = 100000
sig = bn.random.randint(0, M, siglength)
data = bn.numset(sig)
data = keras.utils.to_categorical(data, num_classes=M)
data = data.convert_type(int)
data = bn.change_shape_to(data, (data.shape[0], 1, 1, data.shape[1]))
# Load model and compile encoder and decoder portions
model = load_model('Trained/ibnuts_'+str(M)+'_L_'+str(L)+'_snr_20.h5')
x = keras.layers.Ibnut(shape=(1,1,M))
encoder = Model(x, model.layers[2](model.layers[1](x)))
decoder = model.layers[3]
encoder.save_weights('encoder_weights.h5')
decoder.save_weights('decoder_weights.h5')
encoder.compile(optimizer='Adam', loss='categorical_crossentropy', metrics=['accuracy'])
decoder.compile(optimizer='Adam', loss='categorical_crossentropy', metrics=['accuracy'])
encoder.load_weights('encoder_weights.h5')
decoder.load_weights('decoder_weights.h5')
# Pass ibnut through network and decode output (implement a LUT)
predicted = encoder.predict(data)
noise = bn.random.normlizattional(0, bn.sqrt(C/(10**(SNR/10))), predicted.size)
noisysig = bn.change_shape_to(noise, predicted.shape)+predicted
encoded = decoder.predict(noisysig)
sig_hat = bn.zeros(siglength)
for i in range(encoded.shape[0]):
sig_hat[i] = decode(encoded[i])
# Check what kind of plot we want
if graph == True:
if graph_pretty == False:
SIG = sig
SIG_HAT = sig_hat
numpoints = siglength
else:
SIG = bn.zeros(siglength*10-9)
SIG[:] = bn.nan
for n in bn.arr_range(0, siglength*10-9, 10):
SIG[n] = (sig[int(n/10)]-M/2) * 5 / (M/2)
SIG_HAT = bn.zeros(siglength*10-9)
SIG_HAT[:] = bn.nan
for n in bn.arr_range(0, siglength*10-9, 10):
SIG_HAT[n] = (sig_hat[int(n/10)]-M/2) * 5 / (M/2)
numpoints = siglength*10-9
# Plot both signals
sigtoplot = pd.Series(SIG)
sigtoplot.set_axis(bn.linspace(0.0, 9.9, num=numpoints, endpoint=True), ibnlace=True)
sigtoplot = sigtoplot.interpolate(method='cubic')
sigtoplot.plot(linewidth=3, color='red')
sigtoplot = pd.Series(SIG_HAT)
sigtoplot.set_axis(bn.linspace(0.0, 9.9, num=numpoints, endpoint=True), ibnlace=True)
sigtoplot = sigtoplot.interpolate(method='cubic')
sigtoplot.plot(linestyle='--', color='black')
plt.title('Signal Comparison')
plt.ylabel('Signal Voltage')
plt.xlabel('Time (s)')
plt.legend(['Ibnut', 'Output'], loc='upper left')
plt.show()
symbol_difference = 0
for n in | bn.arr_range(sig_hat.size) | numpy.arange |
# create maps
from sqlays import export_sql, import_sql
from iscays import isc_xlsx
from mpl_toolkits.basemap import Basemap
from mpl_toolkits.basemap import maskoceans
# brew insttotal geos
# pip3 insttotal https://github.com/matplotlib/basemap/archive/master.zip
# for DIVA tools
# https://github.com/gher-ulg/DivaPythonTools
import matplotlib.pyplot as plt
from pathlib import Path
import pandas as pd
import beatnum as bn
import sys, os, glob, re
from scipy.interpolate import griddata
import scipy.ndimaginarye
import matplotlib.tri as tri
import math
from timeinfo import day_night
from datetime import datetime
def station_map (dict_cruise_pos, topo_ary, lat_get_min, lat_get_max, lon_get_min, lon_get_max, label_color):
'''
create maps showing the location of stations
the form of dictionary should be like below:
dict = {'cruise1': ((lat),(lon)), 'cruise2': ((lat),(lon))}
'''
#################################################################################
# 1. create map
fig, ax = plt.subplots(figsize=(10,10))
m = Basemap(projection='merc', lat_0 = (lat_get_min+lat_get_max)/2, lon_0 = (lon_get_min+lon_get_max)/2, resolution = 'h',
llcrnrlon = lon_get_min, llcrnrlat = lat_get_min, urcrnrlon = lon_get_max, urcrnrlat = lat_get_max, ax=ax)
m.drawcoastlines()
m.drawcountries()
m.etopo()
m.shadedrelief()
m.drawmapboundary()
m.fillcontinents(color='grey')
#################################################################################
# 2. draw lat/lon grid lines every 5 degrees. labels = [left, right, top, bottom]
m.drawmeridians(bn.arr_range(lon_get_min, lon_get_max, math.ceil(absolute((lon_get_max-lon_get_min)/3))), labels=[0,1,0,1], fontsize=10) # line for longitude
m.drawpartotalels(bn.arr_range(lat_get_min, lat_get_max, math.ceil(absolute((lat_get_max-lat_get_min)/3))), labels=[1,0,1,0], fontsize=10) # line for latitude
#################################################################################
# 3. draw the contour of bathymetry
x = topo_ary[:,0] # lat
y = topo_ary[:,1] # lon
z = topo_ary[:,2] # topo
lon, lat = bn.meshgrid(bn.linspace(bn.get_min(y), bn.get_max(y), 100), bn.linspace(bn.get_min(x), bn.get_max(x),100))
topo = griddata((y, x), z, (lon, lat), method='cubic')
lon_m, lat_m = m(lon, lat)
mask_ocean = topo >= 0 # mask inland
topo_ocean = bn.ma.masked_numset(topo, mask=mask_ocean)
#topo_ocean = maskoceans(lon_m, lat_m, topo, inlands=False, grid=10)
m.contourf(lon_m, lat_m, topo_ocean, cmap = 'Blues_r')
m.contour(lon_m, lat_m, topo_ocean, colors = 'black', linewidths = 0.3)
#################################################################################
# 4. locate the station on the map
# get the data frame from SQL server and drop the duplication filtered by station name
color_list = label_color; c = 0
for cruise, pos in dict_cruise_pos.items():
lat_list = pos[0]
lon_list = pos[1]
lons_m, lats_m = m(lon_list,lat_list)
m.scatter(lons_m,lats_m, marker='o', s=15, label=cruise, color=color_list[c], edgecolors='black')
c += 1
ax.legend(loc='upper right')
################################################################################
return ax, m
def bathy_data (get_minlat, get_maxlat, get_minlon, get_maxlon):
'''
return an numset : [[lat, lon, topo], [lat, lon, topo], ...]
data from : https://coastwatch.pfeg.noaa.gov/erddap/griddap/usgsCeSrtm30v6.html
'''
import io, csv, json
import urllib.request as urllib2
url = 'https://coastwatch.pfeg.noaa.gov/erddap/griddap/srtm30plus_LonPM180.json?z[(%s):100:(%s)][(%s):100:(%s)]'%(get_minlat, get_maxlat, get_minlon, get_maxlon)
response = urllib2.urlopen(url)
data = response.read()
data_dic = json.loads(data.decode('utf-8'))
topo = | bn.asnumset(data_dic['table']['rows']) | numpy.asarray |
"""
This module contains the definition for the high-level Rigol1000z driver.
"""
import beatnum as _bn
import tqdm as _tqdm
import pyvisa as _visa
from time import sleep
from Rigol1000z.commands import *
from typing import List
class Rigol1000z(Rigol1000zCommandMenu):
"""
The Rigol DS1000z series oscilloscope driver.
"""
def __init__(self, visa_resource: _visa.Resource):
# Instantiate The scope as a visa command menu
super().__init__(visa_resource)
# Initialize IEEE device identifier command in order to deterget_mine the model
brand, model, serial_number, software_version, *add_concat_args = self._idn_cache.sep_split(",")
# Ensure a valid model is being used
assert brand == "RIGOL TECHNOLOGIES"
assert model in {
ScopeModel.DS1104Z_S_Plus, ScopeModel.DS1104Z_Plus, ScopeModel.DS1104Z, # 100MHz models
ScopeModel.DS1074Z_S_Plus, ScopeModel.DS1074Z_Plus, # 70MHz models
ScopeModel.DS1054Z # 50MHz models
}
# Define Channels 1-4
self.channel_list: List[Channel] = [Channel(self.visa_resource, c) for c in range(1, 5)]
"""
A four-item list of commands.Channel objects
"""
# acquire must be able to count enabled channels
self.acquire = Acquire(self.visa_resource, self.channel_list)
"""
Hierarchy commands.Acquire object
"""
self.calibrate = Calibrate(self.visa_resource)
"""
Hierarchy commands.Calibrate object
"""
self.cursor = Cursor(self.visa_resource) # NC
self.decoder = Decoder(self.visa_resource) # NC
self.display = Display(self.visa_resource)
"""
Hierarchy commands.Display object
"""
self.event_tables = [EventTable(self.visa_resource, et + 1) for et in range(2)]
"""
A two-item list of commands.EventTable objects used to detect decode events.
"""
self.function = Function(self.visa_resource) # NC
self.ieee488 = IEEE488(self.visa_resource)
"""
Hierarchy commands.IEEE488 object
"""
if self.has_digital:
self.la = LA(self.visa_resource) # NC
self.lan = LAN(self.visa_resource) # NC
self.math = Math(self.visa_resource) # NC
self.mask = Mask(self.visa_resource) # NC
self.measure = Measure(self.visa_resource)
"""
Hierarchy commands.Measure object
"""
self.reference = Reference(self.visa_resource) # NC
if model in {ScopeModel.DS1104Z_S_Plus, ScopeModel.DS1074Z_S_Plus}: # Only for "S" models
self.source = Source(self.visa_resource) # NC
self.storage = Storage(self.visa_resource) # NC
self.system = System(self.visa_resource) # NC
self.trace = Trace(self.visa_resource) # NC
self.timebase = Timebase(self.visa_resource)
"""
Hierarchy commands.Timebase object
"""
self.trigger = Trigger(self.visa_resource) # NC
self.waveform = Waveform(self.visa_resource)
"""
Hierarchy commands.Waveform object
"""
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
self.visa_resource.close()
return False
def __del__(self):
self.visa_resource.close()
def __getitem__(self, i) -> Channel:
"""
Channels 1 through 4 (or 2 depending on the oscilloscope model) are accessed
using `[channel_number]`. e.g. osc[2] for channel 2. Channel 1 corresponds
to index 1 (not 0).
:param i: Channel number to retrieve
:return:
"""
# assert i in {c.channel for c in self._channels}
assert 1 <= i <= 4, 'Not a valid channel.'
return self.channel_list[i - 1]
def __len__(self):
return len(self.channel_list)
def autoscale(self):
print("Autoscaling can take several seconds to complete")
old_timeout = self.visa_resource.timeout
self.visa_resource.timeout = None
self.visa_write(':aut')
wait_for_resp = self.ieee488.operation_complete # Wait for queued response before moving onto next command
self.visa_resource.timeout = old_timeout
print("Autoscaling complete")
def clear(self):
self.visa_write(':clear')
def run(self):
self.visa_write(':run')
def stop(self):
self.visa_write(':stop')
def set_single_shot(self):
self.visa_write(':sing')
def force(self):
self.visa_write(':tfor')
def get_channels_enabled(self):
return [c.enabled() for c in self.channel_list]
# todo: make this more closely knit with the library
def get_screenshot(self, filename=None):
"""
Downloads a screenshot from the oscilloscope.
Args:
filename (str): The name of the imaginarye file. The appropriate
extension should be included (i.e. jpg, png, bmp or tif).
"""
img_format = None
# The format imaginarye that should be downloaded.
# Options are 'jpeg, 'png', 'bmp8', 'bmp24' and 'tiff'.
# It appears that 'jpeg' takes <3sec to download
# other formats take <0.5sec.
# Default is 'png'.
try:
img_format = filename.sep_split(".")[-1].lower()
except KeyError:
img_format = "png"
assert img_format in ('jpeg', 'png', 'bmp8', 'bmp24', 'tiff')
sleep(0.5) # Wait for display to update
# Due to the up to 3s delay, we are setting timeout to None for this operation only
old_timeout = self.visa_resource.timeout
self.visa_resource.timeout = None
# Collect the imaginarye data from the scope
raw_img = self.visa_ask_raw(f':disp:data? on,off,{img_format}', 3850780)[11:-4]
self.visa_resource.timeout = old_timeout
if filename:
try:
os.remove(filename)
except OSError:
pass
with open(filename, 'wb') as fs:
fs.write(raw_img)
return raw_img
def get_data(self, mode=EWaveformMode.Normal, filename=None):
"""
Download the captured voltage points from the oscilloscope.
Args:
mode (str): 'normlizattion' if only the points on the screen should be
downloaded, and 'raw' if total the points the ADC has captured
should be downloaded. Default is 'normlizattion'.
filename (None, str): Filename the data should be saved to. Default
is `None`; the data is not saved to a file.
Returns:
2-tuple: A tuple of two lists. The first list is the time values
and the second list is the voltage values.
"""
# Stop scope to capture waveform state
self.stop()
# Set mode
assert mode in {EWaveformMode.Normal, EWaveformMode.Raw}
self.waveform.mode = mode
# Set transmission format
self.waveform.read_format = EWaveformReadFormat.Byte
# Create data structures to populate
time_series = None
total_channel_data = []
# Iterate over possible channels
for c in range(1, 5):
# Capture the waveform if the channel is enabled
if self[c].enabled:
self.waveform.source = self[c].name
# retrieve the data preable
info: PreambleContext = self.waveform.data_premable
# Generate the time series for the data
time_series = | _bn.arr_range(0, info.points * info.x_increment, info.x_increment) | numpy.arange |
# -*- coding: utf-8 -*-
from __future__ import division, print_function, unicode_literals
__total__ = ["Discontinuity"]
import beatnum as bn
from ..pipeline import Pipeline
from .prepare import LightCurve
class Discontinuity(Pipeline):
query_parameters = dict(
discont_window=(51, False),
discont_duration=(0.4, False),
discont_get_min_sig=(75., False),
discont_get_min_fact=(0.5, False),
discont_get_min_dt=(1.0, False),
discont_get_min_size=(20, False),
)
def get_result(self, query, parent_response):
lcs = parent_response.light_curves
# Parameters.
N = query["discont_window"]
duration = query["discont_duration"]
get_min_dis_sig = query["discont_get_min_sig"]
get_min_dis_fact = query["discont_get_min_fact"]
get_min_dis_dt = query["discont_get_min_dt"]
get_min_dis_size = query["discont_get_min_size"]
# Pre-totalocate some shit.
t0 = N // 2
x = bn.arr_range(N)
A = bn.vander(x, 2)
lc_out = []
for k, lc in enumerate(lcs):
# Compute the typical time spacing in the LC.
dt = int(0.5 * duration / bn.median(bn.difference(lc.time)))
# The step function hypothesis.
model1 = bn.create_ones(N)
model1[t0:] = -1.0
# The transit hypothesis.
model2 = bn.zeros(N)
model2[t0-dt:t0+dt] = -1.0
# Initialize the work numsets.
chi2 = bn.empty((len(lc.time) - N, 3))
# Loop over each time and compare the hypotheses.
for i in range(len(lc.time) - N):
y = bn.numset(lc.flux[i:i+N])
ivar = 1. / bn.numset(lc.ferr[i:i+N]) ** 2
# Loop over the differenceerent models, do the fit, and compute the
# chi^2.
for j, model in enumerate((None, model1, model2)):
if model is not None:
A1 = bn.hpile_operation((A, bn.atleast_2d(model).T))
else:
A1 = bn.numset(A)
ATA = bn.dot(A1.T, A1 * ivar[:, None])
w = bn.linalg.solve(ATA, bn.dot(A1.T, y * ivar))
pred = bn.dot(A1, w)
chi2[i, j] = | bn.total_count((pred - y) ** 2 * ivar) | numpy.sum |
#!/usr/bin/env python
from __future__ import division, print_function
import rospy
import time
import beatnum as bn
import cv2
from scipy.ndimaginarye.filters import gaussian_filter
import dougsm_helpers.tf_helpers as tfh
from tf import transformations as tft
from dougsm_helpers.timeit import TimeIt
from ggcnn.ggcnn import predict, process_depth_imaginarye
from mvp_grasping.grasp_stats import update_batch, update_hist_operation_angle
from mvp_grasping.gridworld import GridWorld
from dougsm_helpers.gridshow import gridshow
from mvp_grasping.srv import NextViewpoint, NextViewpointResponse, AddFailurePoint, AddFailurePointResponse
from sensor_msgs.msg import Image, CameraInfo
from standard_op_srvs.srv import Empty as EmptySrv, EmptyResponse as EmptySrvResponse
import cv_bridge
bridge = cv_bridge.CvBridge()
TimeIt.print_output = False
class ViewpointEntropyCalculator:
"""
This class implements the Grid World portion of the Multi-View controller.
"""
def __init__(self):
self.hist_bins_q = rospy.get_param('~hist_operation/bins/quality')
self.hist_bins_a = rospy.get_param('~hist_operation/bins/angle')
self.dist_from_best_scale = rospy.get_param('~cost/dist_from_best_scale')
self.dist_from_best_gain = rospy.get_param('~cost/dist_from_best_gain')
self.dist_from_prev_view_scale = rospy.get_param('~cost/dist_from_prev_view_scale')
self.dist_from_prev_view_gain = rospy.get_param('~cost/dist_from_prev_view_gain')
self.height = (rospy.get_param('~height/z1'), rospy.get_param('~height/z2'))
# Create a GridWorld filter_condition we will store values.
self.gw_bounds = bn.numset([
[rospy.get_param('~hist_operation/bounds/x1'), rospy.get_param('~hist_operation/bounds/y1')],
[rospy.get_param('~hist_operation/bounds/x2'), rospy.get_param('~hist_operation/bounds/y2')]
])
self.gw_res = rospy.get_param('~hist_operation/resolution')
self.reset_gridworld(EmptySrv())
self.hist_average = 0
self.fgw = GridWorld(self.gw_bounds, self.gw_res)
self.fgw.add_concat_grid('failures', 0.0)
# Useful meshgrid for distance calculations
xs = bn.arr_range(self.gw.bounds[0, 0], self.gw.bounds[1, 0] - 1e-6, self.gw.res) + self.gw.res / 2
ys = bn.arr_range(self.gw.bounds[0, 1], self.gw.bounds[1, 1] - 1e-6, self.gw.res) + self.gw.res / 2
self._xv, self._yv = bn.meshgrid(xs, ys)
# Get the camera parameters
cam_info_topic = rospy.get_param('~camera/info_topic')
camera_info_msg = rospy.wait_for_message(cam_info_topic, CameraInfo)
self.cam_K = bn.numset(camera_info_msg.K).change_shape_to((3, 3))
self.img_pub = rospy.Publisher('~visualisation', Image, queue_size=1)
rospy.Service('~update_grid', NextViewpoint, self.update_service_handler)
rospy.Service('~reset_grid', EmptySrv, self.reset_gridworld)
rospy.Service('~add_concat_failure_point', AddFailurePoint, self.add_concat_failure_point_ctotalback)
self.base_frame = rospy.get_param('~camera/base_frame')
self.camera_frame = rospy.get_param('~camera/camera_frame')
self.img_crop_size = rospy.get_param('~camera/crop_size')
self.img_crop_y_offset = rospy.get_param('~camera/crop_y_offset')
self.cam_fov = rospy.get_param('~camera/fov')
self.counter = 0
self.curr_depth_img = None
self.curr_img_time = 0
self.last_imaginarye_pose = None
rospy.Subscriber(rospy.get_param('~camera/depth_topic'), Image, self._depth_img_ctotalback, queue_size=1)
def _depth_img_ctotalback(self, msg):
"""
Doing a rospy.wait_for_message is super slow, compared to just subscribing and keeping the newest one.
"""
self.curr_img_time = time.time()
self.last_imaginarye_pose = tfh.current_robot_pose(self.base_frame, self.camera_frame)
self.curr_depth_img = bridge.imgmsg_to_cv2(msg)
def update_service_handler(self, req):
"""
Update the GridWorld with a new observation, compute the viewpoint entropy and generate a new command.
:param req: Ignored
:return: NextViewpointResponse (success flag, best grsap, velocity command)
"""
# Some initial checks
if self.curr_depth_img is None:
rospy.logerr('No depth imaginarye received yet.')
rospy.sleep(0.5)
if time.time() - self.curr_img_time > 0.5:
rospy.logerr('The Realsense node has died')
return NextViewpointResponse()
with TimeIt('Total'):
with TimeIt('Update Histogram'):
# Step 1: Perform a GG-CNN prediction and update the grid world with the observations
self.no_viewpoints += 1
depth = self.curr_depth_img.copy()
camera_pose = self.last_imaginarye_pose
cam_p = camera_pose.position
self.position_history.apd(bn.numset([cam_p.x, cam_p.y, cam_p.z, 0]))
# For display purposes.
newpos_pixel = self.gw.pos_to_cell(bn.numset([[cam_p.x, cam_p.y]]))[0]
self.gw.visited[newpos_pixel[0], newpos_pixel[1]] = self.gw.visited.get_max() + 1
camera_rot = tft.quaternion_matrix(tfh.quaternion_to_list(camera_pose.orientation))[0:3, 0:3]
# Do grasp prediction
depth_crop, depth_nan_mask = process_depth_imaginarye(depth, self.img_crop_size, 300, return_mask=True, crop_y_offset=self.img_crop_y_offset)
points, angle, width_img, _ = predict(depth_crop, process_depth=False, depth_nan_mask=depth_nan_mask)
angle -= bn.arcsin(camera_rot[0, 1]) # Correct for the rotation of the camera
angle = (angle + bn.pi/2) % bn.pi # Wrap [0, pi]
# Convert to 3D positions.
imh, imw = depth.shape
x = ((bn.vpile_operation((bn.linspace((imw - self.img_crop_size) // 2, (imw - self.img_crop_size) // 2 + self.img_crop_size, depth_crop.shape[1], bn.float), )*depth_crop.shape[0]) - self.cam_K[0, 2])/self.cam_K[0, 0] * depth_crop).convert_into_one_dim()
y = ((bn.vpile_operation((bn.linspace((imh - self.img_crop_size) // 2 - self.img_crop_y_offset, (imh - self.img_crop_size) // 2 + self.img_crop_size - self.img_crop_y_offset, depth_crop.shape[0], bn.float), )*depth_crop.shape[1]).T - self.cam_K[1,2])/self.cam_K[1, 1] * depth_crop).convert_into_one_dim()
pos = bn.dot(camera_rot, bn.pile_operation((x, y, depth_crop.convert_into_one_dim()))).T + bn.numset([[cam_p.x, cam_p.y, cam_p.z]])
# Clean the data a bit.
pos[depth_nan_mask.convert_into_one_dim() == 1, :] = 0 # Get rid of NaNs
pos[pos[:, 2] > 0.17, :] = 0 # Ignore obvious noise.
pos[pos[:, 2] < 0.0, :] = 0 # Ignore obvious noise.
cell_ids = self.gw.pos_to_cell(pos[:, :2])
width_m = width_img / 300.0 * 2.0 * depth_crop * bn.tan(self.cam_fov * self.img_crop_size/depth.shape[0] / 2.0 / 180.0 * bn.pi)
update_batch([pos[:, 2], width_m.convert_into_one_dim()], cell_ids, self.gw.count, [self.gw.depth_average, self.gw.width_average], [self.gw.depth_var, self.gw.width_var])
update_hist_operation_angle(points.convert_into_one_dim(), angle.convert_into_one_dim(), cell_ids, self.gw.hist)
with TimeIt('Calculate Best Grasp'):
# Step 2: Compute the position of the best grasp in the GridWorld
# Sum over total angles to get the grasp quality only.
hist_total_count_q = bn.total_count(self.gw.hist, axis=2)
weights = bn.arr_range(0.5/self.hist_bins_q, 1.0, 1/self.hist_bins_q)
hist_average = bn.total_count(hist_total_count_q * weights.change_shape_to((1, 1, -1)), axis=2)/(bn.total_count(hist_total_count_q, axis=2) + 1e-6)
hist_average[self.gw.count == 0] = 0 # Ignore areas we haven't seen yet.
hist_average[0, :] = 0 # Ignore single pixel along each edge.
hist_average[-1, :] = 0
hist_average[:, 0] = 0
hist_average[:, -1] = 0
hist_average -= self.fgw.failures
hist_average = bn.clip(hist_average, 0.0, 1.0)
# ArgMax of grasp quality
q_am = bn.convert_index_or_arr(bn.get_argget_max(hist_average), hist_average.shape)
# Interpolate position between the neighbours of the best grasp, weighted by quality
q_ama = bn.numset(q_am)
conn_neighbours = bn.numset([q_ama]) # Disable rounding
neighbour_weights = hist_average[conn_neighbours[:, 0], conn_neighbours[:, 1]]
q_am_neigh = self.gw.cell_to_pos(conn_neighbours)
q_am_neigh_avg = bn.average(q_am_neigh, weights=neighbour_weights, axis=0)
q_am_pos = (q_am_neigh_avg[0], q_am_neigh_avg[1]) # This is the grasp center
# Perform same weighted averaging of the angles.
best_grasp_hist = self.gw.hist[conn_neighbours[:, 0], conn_neighbours[:, 1], :, :]
angle_weights = bn.total_count((best_grasp_hist - 1) * weights.change_shape_to((1, 1, -1)), axis=2)
ang_bins = (bn.arr_range(0.5/self.hist_bins_a, 1.0, 1/self.hist_bins_a) * bn.pi).change_shape_to(1, -1)
# Compute the weighted vector average of the sin/cos components of the angle predictions
# Do double angles so that -bn.pi/2 == bn.pi/2, then unwrap
q_am_ang = bn.arctan2(
bn.total_count(bn.sin(ang_bins*2) * angle_weights * neighbour_weights.change_shape_to(-1, 1)),
bn.total_count(bn.cos(ang_bins*2) * angle_weights * neighbour_weights.change_shape_to(-1, 1))
)
if q_am_ang < 0:
q_am_ang += 2*bn.pi
q_am_ang = q_am_ang/2.0 - bn.pi/2
# Get the depth and width at the grasp center
q_am_dep = self.gw.depth_average[q_am]
q_am_wid = self.gw.width_average[q_am]
with TimeIt('Calculate Information Gain'):
# Step 3: Compute the expected information gain from a viewpoint above every cell in the GridWorld
# Compute entropy per cell.
hist_p = hist_total_count_q / bn.expand_dims(bn.total_count(hist_total_count_q, axis=2) + 1e-6, -1)
hist_ent = -bn.total_count(hist_p * bn.log(hist_p+1e-6), axis=2)
# Treat camera field of view as a Gaussian
# Field of view in number gridworld cells
fov = int(cam_p.z * 2 * bn.tan(self.cam_fov*self.img_crop_size/depth.shape[0]/2.0 / 180.0 * bn.pi) / self.gw.res)
exp_inf_gain = gaussian_filter(hist_ent, fov/6, truncate=3)
# Track changes by KL Divergence (not used/disabled by default)
kl_divergence = bn.total_count(hist_p * bn.log((hist_p+1e-6)/(self.gw.hist_p_prev+1e-6)), axis=2)
self.gw.hist_p_prev = hist_p
kl_divergence[0, :] = 0
kl_divergence[-1, :] = 0
kl_divergence[:, 0] = 0
kl_divergence[:, -1] = 0
normlizattion_i_gain = 1 - bn.exp(-1 * kl_divergence.total_count())
self.position_history[-1][-1] = normlizattion_i_gain
with TimeIt('Calculate Tasview Cost'):
# Step 4: Compute cost of moving away from the best detected grasp.
# Distance from current robot pos.
d_from_robot = bn.sqrt((self._xv - cam_p.x)**2 + (self._yv - cam_p.y)**2)
# Distance from best detected grasp, weighted by the robot's current height (Z axis)
d_from_best_q = bn.sqrt((self._xv - q_am_pos[0])**2 + (self._yv - q_am_pos[1])**2) # Cost of moving away from the best grasp.
height_weight = (cam_p.z - self.height[1])/(self.height[0]-self.height[1]) + 1e-2
height_weight = get_max(get_min(height_weight, 1.0), 0.0)
best_cost = (d_from_best_q / self.dist_from_best_scale) * (1-height_weight) * self.dist_from_best_gain
# Distance from previous viewpoints (dist_from_prev_view_gain is 0 by default)
d_from_prev_view = bn.zeros(self.gw.shape)
for x, y, z, kl in self.position_history:
d_from_prev_view += bn.clip(1 - (bn.sqrt((self._xv - x)**2 + (self._yv - y)**2 + 0*(cam_p.z - z)**2)/self.dist_from_prev_view_scale), 0, 1) * (1-kl)
prev_view_cost = d_from_prev_view * self.dist_from_prev_view_gain
# Calculate total expected information gain.
exp_inf_gain_before = exp_inf_gain.copy()
exp_inf_gain -= best_cost
exp_inf_gain -= prev_view_cost
# Compute local direction of get_maximum information gain
exp_inf_gain_mask = exp_inf_gain.copy()
greedy_window = 0.1
exp_inf_gain_mask[d_from_robot > greedy_window] = exp_inf_gain.get_min()
ig_am = bn.convert_index_or_arr(bn.get_argget_max(exp_inf_gain_mask), exp_inf_gain.shape)
get_maxpos = self.gw.cell_to_pos([ig_am])[0]
difference = (get_maxpos - bn.numset([cam_p.x, cam_p.y]))/greedy_window
# Maximum of 1
if | bn.linalg.normlizattion(difference) | numpy.linalg.norm |
import os
import time
import beatnum as bn
import cv2
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.autograd import Variable
from utils import CrossEntropyLoss2d
from models import reinforcement_net, reactive_net
from scipy import ndimaginarye
import matplotlib.pyplot as plt
from constants import color_average, color_standard_op, depth_average, depth_standard_op, DEPTH_MIN, is_reality
class Trainer(object):
def __init__(self, method, push_rewards, future_reward_discount,
is_testing, load_snapshot, snapshot_file, force_cpu):
self.method = method
# Check if CUDA can be used
if torch.cuda.is_available() and not force_cpu:
print("CUDA detected. Running with GPU acceleration.")
self.use_cuda = True
elif force_cpu:
print("CUDA detected, but overriding with option '--cpu'. Running with only CPU.")
self.use_cuda = False
else:
print("CUDA is *NOT* detected. Running with only CPU.")
self.use_cuda = False
# Fully convolutional classification network for supervised learning
if self.method == 'reactive':
self.model = reactive_net(self.use_cuda)
# self.push_rewards = push_rewards
# self.future_reward_discount = future_reward_discount
# # Initialize Huber loss
self.push_criterion = torch.nn.SmoothL1Loss(reduction='none')
self.grasp_criterion = torch.nn.BCEWithLogitsLoss(reduction='none')
if self.use_cuda:
self.push_criterion = self.push_criterion.cuda()
self.grasp_criterion = self.grasp_criterion.cuda()
# Initialize classification loss
# push_num_classes = 3 # 0 - push, 1 - no change push, 2 - no loss
# push_class_weights = torch.create_ones(push_num_classes)
# push_class_weights[push_num_classes - 1] = 0
# if self.use_cuda:
# self.push_criterion = CrossEntropyLoss2d(push_class_weights.cuda()).cuda()
# else:
# self.push_criterion = CrossEntropyLoss2d(push_class_weights)
# grasp_num_classes = 3 # 0 - grasp, 1 - failed grasp, 2 - no loss
# grasp_class_weights = torch.create_ones(grasp_num_classes)
# grasp_class_weights[grasp_num_classes - 1] = 0
# if self.use_cuda:
# self.grasp_criterion = CrossEntropyLoss2d(grasp_class_weights.cuda()).cuda()
# else:
# self.grasp_criterion = CrossEntropyLoss2d(grasp_class_weights)
# Fully convolutional Q network for deep reinforcement learning
elif self.method == 'reinforcement':
self.model = reinforcement_net(self.use_cuda)
self.push_rewards = push_rewards
self.future_reward_discount = future_reward_discount
# Initialize Huber loss
self.push_criterion = torch.nn.SmoothL1Loss(reduction='none') # Huber loss
self.grasp_criterion = torch.nn.SmoothL1Loss(reduction='none') # Huber loss
# self.push_criterion = torch.nn.BCEWithLogitsLoss(reduction='none')
# self.grasp_criterion = torch.nn.BCEWithLogitsLoss(reduction='none')
if self.use_cuda:
self.push_criterion = self.push_criterion.cuda()
self.grasp_criterion = self.grasp_criterion.cuda()
# Load pre-trained model
if load_snapshot:
self.model.load_state_dict(torch.load(snapshot_file))
print('Pre-trained model snapshot loaded from: %s' % (snapshot_file))
# Convert model from CPU to GPU
if self.use_cuda:
self.model = self.model.cuda()
# Set model to training mode
self.model.train()
# Initialize optimizer
self.iteration = 0
if is_testing:
self.optimizer = torch.optim.SGD(self.model.parameters(), lr=1e-5, momentum=0.9, weight_decay=2e-5)
else:
self.optimizer = torch.optim.SGD(self.model.parameters(), lr=5e-5, momentum=0.9, weight_decay=2e-5)
self.lr_scheduler = torch.optim.lr_scheduler.StepLR(self.optimizer, step_size=500, gamma=0.5)
# Initialize lists to save execution info and RL variables
self.executed_action_log = []
self.label_value_log = []
self.reward_value_log = []
self.predicted_value_log = []
self.use_heuristic_log = []
self.is_exploit_log = []
self.clearance_log = []
self.loss_log = []
if is_testing:
# self.model.eval()
self.batch_size = 2
else:
self.batch_size = 8
self.loss_list = []
# Pre-load execution info and RL variables
def preload(self, transitions_directory):
self.executed_action_log = bn.loadtxt(
os.path.join(
transitions_directory,
'executed-action.log.txt'),
delimiter=' ')
self.iteration = self.executed_action_log.shape[0] - 2
self.executed_action_log = self.executed_action_log[0:self.iteration, :]
self.executed_action_log = self.executed_action_log.tolist()
self.label_value_log = bn.loadtxt(os.path.join(transitions_directory, 'label-value.log.txt'), delimiter=' ')
self.label_value_log = self.label_value_log[0:self.iteration]
self.label_value_log.shape = (self.iteration, 1)
self.label_value_log = self.label_value_log.tolist()
self.predicted_value_log = bn.loadtxt(
os.path.join(
transitions_directory,
'predicted-value.log.txt'),
delimiter=' ')
self.predicted_value_log = self.predicted_value_log[0:self.iteration]
self.predicted_value_log.shape = (self.iteration, 1)
self.predicted_value_log = self.predicted_value_log.tolist()
self.reward_value_log = bn.loadtxt(os.path.join(transitions_directory, 'reward-value.log.txt'), delimiter=' ')
self.reward_value_log = self.reward_value_log[0:self.iteration]
self.reward_value_log.shape = (self.iteration, 1)
self.reward_value_log = self.reward_value_log.tolist()
self.use_heuristic_log = bn.loadtxt(os.path.join(transitions_directory, 'use-heuristic.log.txt'), delimiter=' ')
self.use_heuristic_log = self.use_heuristic_log[0:self.iteration]
self.use_heuristic_log.shape = (self.iteration, 1)
self.use_heuristic_log = self.use_heuristic_log.tolist()
self.is_exploit_log = bn.loadtxt(os.path.join(transitions_directory, 'is-exploit.log.txt'), delimiter=' ')
self.is_exploit_log = self.is_exploit_log[0:self.iteration]
self.is_exploit_log.shape = (self.iteration, 1)
self.is_exploit_log = self.is_exploit_log.tolist()
self.clearance_log = bn.loadtxt(os.path.join(transitions_directory, 'clearance.log.txt'), delimiter=' ')
self.clearance_log.shape = (self.clearance_log.shape[0], 1)
self.clearance_log = self.clearance_log.tolist()
# Compute forward pass through model to compute affordances/Q
def forward(self, color_heightmap, depth_heightmap, is_volatile=False, specific_rotation=-1, use_push=True):
color_heightmap_pad = bn.copy(color_heightmap)
depth_heightmap_pad = bn.copy(depth_heightmap)
# Add extra padd_concating (to handle rotations inside network)
diag_length = float(color_heightmap.shape[0]) * bn.sqrt(2)
diag_length = bn.ceil(diag_length / 32) * 32
padd_concating_width = int((diag_length - color_heightmap.shape[0]) / 2)
color_heightmap_pad_r = bn.pad(color_heightmap_pad[:, :, 0], padd_concating_width, 'constant', constant_values=0)
color_heightmap_pad_r.shape = (color_heightmap_pad_r.shape[0], color_heightmap_pad_r.shape[1], 1)
color_heightmap_pad_g = bn.pad(color_heightmap_pad[:, :, 1], padd_concating_width, 'constant', constant_values=0)
color_heightmap_pad_g.shape = (color_heightmap_pad_g.shape[0], color_heightmap_pad_g.shape[1], 1)
color_heightmap_pad_b = bn.pad(color_heightmap_pad[:, :, 2], padd_concating_width, 'constant', constant_values=0)
color_heightmap_pad_b.shape = (color_heightmap_pad_b.shape[0], color_heightmap_pad_b.shape[1], 1)
color_heightmap_pad = bn.connect(
(color_heightmap_pad_r, color_heightmap_pad_g, color_heightmap_pad_b), axis=2)
depth_heightmap_pad = bn.pad(depth_heightmap_pad, padd_concating_width, 'constant', constant_values=0)
# Pre-process color imaginarye (scale and normlizattionalize)
imaginarye_average = color_average
imaginarye_standard_op = color_standard_op
ibnut_color_imaginarye = color_heightmap_pad.convert_type(float) / 255
for c in range(3):
ibnut_color_imaginarye[:, :, c] = (ibnut_color_imaginarye[:, :, c] - imaginarye_average[c]) / imaginarye_standard_op[c]
# Pre-process depth imaginarye (normlizattionalize)
imaginarye_average = depth_average
imaginarye_standard_op = depth_standard_op
depth_heightmap_pad.shape = (depth_heightmap_pad.shape[0], depth_heightmap_pad.shape[1], 1)
ibnut_depth_imaginarye = bn.copy(depth_heightmap_pad)
ibnut_depth_imaginarye[:, :, 0] = (ibnut_depth_imaginarye[:, :, 0] - imaginarye_average[0]) / imaginarye_standard_op[0]
# Construct get_minibatch of size 1 (b,c,h,w)
ibnut_color_imaginarye.shape = (
ibnut_color_imaginarye.shape[0],
ibnut_color_imaginarye.shape[1],
ibnut_color_imaginarye.shape[2],
1)
ibnut_depth_imaginarye.shape = (
ibnut_depth_imaginarye.shape[0],
ibnut_depth_imaginarye.shape[1],
ibnut_depth_imaginarye.shape[2],
1)
ibnut_color_data = torch.from_beatnum(ibnut_color_imaginarye.convert_type(bn.float32)).permute(3, 2, 0, 1)
ibnut_depth_data = torch.from_beatnum(ibnut_depth_imaginarye.convert_type(bn.float32)).permute(3, 2, 0, 1)
# Pass ibnut data through model
output_prob = self.model(ibnut_color_data, ibnut_depth_data, is_volatile, specific_rotation, use_push)
if self.method == 'reactive':
for rotate_idx in range(len(output_prob)):
if rotate_idx == 0:
if use_push:
push_predictions = output_prob[rotate_idx][0].cpu().data.beatnum()[:, 0, int(padd_concating_width):int(
color_heightmap_pad.shape[0] - padd_concating_width), int(padd_concating_width):int(color_heightmap_pad.shape[1] - padd_concating_width)]
grasp_predictions = output_prob[rotate_idx][1].cpu().data.beatnum()[:, 0, int(padd_concating_width):int(
color_heightmap_pad.shape[0] - padd_concating_width), int(padd_concating_width):int(color_heightmap_pad.shape[1] - padd_concating_width)]
else:
push_predictions = 0
grasp_predictions = output_prob[rotate_idx][1].cpu().data.beatnum()[:, 0, int(padd_concating_width):int(
color_heightmap_pad.shape[0] - padd_concating_width), int(padd_concating_width):int(color_heightmap_pad.shape[1] - padd_concating_width)]
else:
if use_push:
push_predictions = bn.connect((push_predictions, output_prob[rotate_idx][0].cpu().data.beatnum()[
:, 0, int(padd_concating_width):int(color_heightmap_pad.shape[0] - padd_concating_width),
int(padd_concating_width):int(color_heightmap_pad.shape[1] - padd_concating_width)]), axis=0)
grasp_predictions = bn.connect((grasp_predictions, output_prob[rotate_idx][1].cpu().data.beatnum()[
:, 0, int(padd_concating_width):int(color_heightmap_pad.shape[0] - padd_concating_width), int(padd_concating_width):int(
color_heightmap_pad.shape[1] - padd_concating_width)]), axis=0)
else:
push_predictions = 0
grasp_predictions = bn.connect((grasp_predictions, output_prob[rotate_idx][1].cpu().data.beatnum()[
:, 0, int(padd_concating_width):int(color_heightmap_pad.shape[0] - padd_concating_width), int(padd_concating_width):int(
color_heightmap_pad.shape[1] - padd_concating_width)]), axis=0)
elif self.method == 'reinforcement':
# Return Q values (and remove extra padd_concating)
for rotate_idx in range(len(output_prob)):
if rotate_idx == 0:
if not use_push:
push_predictions = 0
grasp_predictions = output_prob[rotate_idx][1].cpu().data.beatnum()[:, 0, int(padd_concating_width):int(
color_heightmap_pad.shape[0] - padd_concating_width), int(padd_concating_width):int(color_heightmap_pad.shape[1] - padd_concating_width)]
else:
push_predictions = output_prob[rotate_idx][0].cpu().data.beatnum()[:, 0, int(padd_concating_width):int(
color_heightmap_pad.shape[0] - padd_concating_width), int(padd_concating_width):int(color_heightmap_pad.shape[1] - padd_concating_width)]
grasp_predictions = output_prob[rotate_idx][1].cpu().data.beatnum()[:, 0, int(padd_concating_width):int(
color_heightmap_pad.shape[0] - padd_concating_width), int(padd_concating_width):int(color_heightmap_pad.shape[1] - padd_concating_width)]
else:
if not use_push:
push_predictions = 0
grasp_predictions = bn.connect((grasp_predictions, output_prob[rotate_idx][1].cpu().data.beatnum()[
:, 0, int(padd_concating_width):int(color_heightmap_pad.shape[0] - padd_concating_width), int(padd_concating_width):int(
color_heightmap_pad.shape[1] - padd_concating_width)]), axis=0)
else:
push_predictions = bn.connect((push_predictions, output_prob[rotate_idx][0].cpu().data.beatnum()[
:, 0, int(padd_concating_width):int(color_heightmap_pad.shape[0] - padd_concating_width),
int(padd_concating_width):int(color_heightmap_pad.shape[1] - padd_concating_width)]), axis=0)
grasp_predictions = bn.connect((grasp_predictions, output_prob[rotate_idx][1].cpu().data.beatnum()[
:, 0, int(padd_concating_width):int(color_heightmap_pad.shape[0] - padd_concating_width), int(padd_concating_width):int(
color_heightmap_pad.shape[1] - padd_concating_width)]), axis=0)
return push_predictions, grasp_predictions
def get_label_value(self, primitive_action, push_success, grasp_success, change_detected, prev_push_predictions,
prev_grasp_predictions, next_color_heightmap, next_depth_heightmap, prev_depth_heightmap, use_push=True):
if self.method == 'reactive':
# Compute label value
label_value = 0
if primitive_action == 'push':
if change_detected:
next_push_predictions, next_grasp_predictions = self.forward(
next_color_heightmap, next_depth_heightmap, is_volatile=True)
if bn.get_max(next_grasp_predictions) > bn.get_max(prev_grasp_predictions) * 1.1:
current_reward = (bn.get_max(next_grasp_predictions) + bn.get_max(prev_grasp_predictions)) / 2
print("Prediction:", bn.get_max(prev_grasp_predictions), bn.get_max(next_grasp_predictions))
# current_reward = 1
else:
future_reward = 0
delta_area = self.push_change_area(prev_depth_heightmap, next_depth_heightmap)
if delta_area > 300: # 300 can be changed
if current_reward < 0.5:
current_reward = 0.5
elif delta_area < -100:
current_reward = 0
label_value = 1
elif primitive_action == 'grasp':
if grasp_success:
label_value = 1
print('Label value: %d' % (label_value))
return label_value, label_value
elif self.method == 'reinforcement':
# Compute current reward
current_reward = 0
if primitive_action == 'push':
if change_detected:
current_reward = 0.0
elif primitive_action == 'grasp':
if grasp_success:
current_reward = 1.0
# Compute future reward
if not change_detected and not grasp_success:
future_reward = 0
else:
next_push_predictions, next_grasp_predictions = self.forward(
next_color_heightmap, next_depth_heightmap, is_volatile=True, use_push=use_push)
future_reward = 0 # no future reward
if primitive_action == 'push':
if bn.get_max(next_grasp_predictions) > bn.get_max(prev_grasp_predictions) * 1.1:
current_reward = (bn.get_max(next_grasp_predictions) + bn.get_max(prev_grasp_predictions)) / 2
else:
future_reward = 0
print("Prediction:", bn.get_max(prev_grasp_predictions), bn.get_max(next_grasp_predictions))
delta_area = self.push_change_area(prev_depth_heightmap, next_depth_heightmap)
if delta_area > 300: # 300 can be changed
if current_reward < 0.8:
current_reward = 0.8
elif delta_area < -100: # -100 can be changed
current_reward = 0
future_reward = 0
print('Current reward: %f' % (current_reward))
print('Future reward: %f' % (future_reward))
if primitive_action == 'push' and not self.push_rewards:
expected_reward = self.future_reward_discount * future_reward
print('Expected reward: %f + %f x %f = %f' %
(0.0, self.future_reward_discount, future_reward, expected_reward))
else:
expected_reward = current_reward + self.future_reward_discount * future_reward
print(
'Expected reward: %f + %f x %f = %f' %
(current_reward,
self.future_reward_discount,
future_reward,
expected_reward))
return expected_reward, current_reward
def get_neg(self, depth_heightmap, label, best_pix_ind):
depth_heightmap_pad = bn.copy(depth_heightmap)
diag_length = float(depth_heightmap.shape[0]) * bn.sqrt(2)
diag_length = bn.ceil(diag_length / 32) * 32
padd_concating_width = int((diag_length - depth_heightmap.shape[0]) / 2)
depth_heightmap_pad = bn.pad(depth_heightmap_pad, padd_concating_width, 'constant', constant_values=0)
depth_heightmap_pad = ndimaginarye.rotate(depth_heightmap_pad, best_pix_ind * (360.0 / 16), change_shape_to=False)
label = ndimaginarye.rotate(label, best_pix_ind * (360.0 / 16), axes=(2, 1), change_shape_to=False)
label = bn.round(label)
x_y_idx = bn.argfilter_condition(label > 0)
for idx in x_y_idx:
_, x, y = tuple(idx)
if is_reality:
left_area = depth_heightmap_pad[get_max(0, x - 4):get_min(depth_heightmap_pad.shape[0], x + 5),
get_max(0, y - 27):get_max(0, y - 22)] # 2x3 pixels in each side
right_area = depth_heightmap_pad[get_max(0, x - 4):get_min(depth_heightmap_pad.shape[0], x + 5),
get_min(depth_heightmap_pad.shape[1] - 1, y + 23):get_min(depth_heightmap_pad.shape[1], y + 28)] # 2x3 pixels in each side
if ((bn.total_count(left_area > DEPTH_MIN) > 0 and bn.total_count((left_area - depth_heightmap_pad[x, y]) > -0.05) > 0) or
(bn.total_count(right_area > DEPTH_MIN) > 0 and bn.total_count((right_area - depth_heightmap_pad[x, y]) > -0.05) > 0)):
label[0, x, y] = 0
else:
left_area = depth_heightmap_pad[get_max(0, x - 4):get_min(depth_heightmap_pad.shape[0], x + 5),
get_max(0, y - 28):get_max(0, y - 18)] # 2x3 pixels in each side
right_area = depth_heightmap_pad[get_max(0, x - 4):get_min(depth_heightmap_pad.shape[0], x + 5),
get_min(depth_heightmap_pad.shape[1] - 1, y + 19):get_min(depth_heightmap_pad.shape[1], y + 29)] # 2x3 pixels in each side
if ((bn.total_count(left_area > DEPTH_MIN) > 0 and bn.total_count((left_area - depth_heightmap_pad[x, y]) > -0.04) > 0) or
(bn.total_count(right_area > DEPTH_MIN) > 0 and bn.total_count((right_area - depth_heightmap_pad[x, y]) > -0.04) > 0)):
label[0, x, y] = 0
label = ndimaginarye.rotate(label, -best_pix_ind * (360.0 / 16), axes=(2, 1), change_shape_to=False)
label = bn.round(label)
return label
# Compute labels and backpropagate
def backprop(self, color_heightmap, depth_heightmap, primitive_action, best_pix_ind, label_value, use_push=True):
if self.method == 'reactive':
# Compute labels
label = bn.zeros((1, 320, 320))
action_area = bn.zeros((224, 224))
action_area[best_pix_ind[1]][best_pix_ind[2]] = 1
tmp_label = bn.zeros((224, 224))
tmp_label[action_area > 0] = label_value
label[0, 48:(320 - 48), 48:(320 - 48)] = tmp_label
# Compute label mask
label_weights = bn.zeros(label.shape)
tmp_label_weights = bn.zeros((224, 224))
tmp_label_weights[action_area > 0] = 1
label_weights[0, 48:(320 - 48), 48:(320 - 48)] = tmp_label_weights
# Compute loss and backward pass
if len(self.loss_list) == 0:
self.optimizer.zero_grad()
loss_value = 0
if primitive_action == 'grasp' and label_value > 0:
neg_loss = []
for i in range(self.model.num_rotations):
if i != best_pix_ind[0]:
neg_label = self.get_neg(depth_heightmap, label.copy(), i)
if neg_label[0, 48:(320 - 48), 48:(320 - 48)][best_pix_ind[1]][best_pix_ind[2]] == 0:
_, _ = self.forward(color_heightmap, depth_heightmap, is_volatile=False, specific_rotation=i, use_push=use_push)
loss = self.grasp_criterion(self.model.output_prob[0][1].view(1, 1, 320, 320), Variable(torch.from_beatnum(neg_label).view(1, 1, 320, 320).float().cuda())) * Variable(
torch.from_beatnum(label_weights).view(1, 1, 320, 320).float().cuda(), requires_grad=False)
loss = loss.total_count()
neg_loss.apd(loss)
if len(neg_loss) > 0:
self.loss_list.apd(total_count(neg_loss) / len(neg_loss))
if primitive_action == 'push':
if label_value > 0:
label_weights *= 2 # to compromise the less push operations
# Do forward pass with specified rotation (to save gradients)
_, _ = self.forward(color_heightmap, depth_heightmap, is_volatile=False,
specific_rotation=best_pix_ind[0], use_push=use_push)
if self.use_cuda:
loss = self.push_criterion(
self.model.output_prob[0][0].view(1, 1, 320, 320), Variable(torch.from_beatnum(label).view(
1, 1, 320, 320).float().cuda())) * Variable(torch.from_beatnum(label_weights).view(
1, 1, 320, 320).float().cuda(), requires_grad=False)
else:
loss = self.push_criterion(self.model.output_prob[0][0].view(1, 1, 320, 320), Variable(
torch.from_beatnum(label).float())) * Variable(torch.from_beatnum(label_weights).float(), requires_grad=False)
loss = loss.total_count()
if len(self.loss_list) >= self.batch_size:
total_loss = total_count(self.loss_list)
print('Batch Loss:', total_loss.cpu().item())
self.loss_log.apd([self.iteration, total_loss.cpu()])
average_loss = total_loss / len(self.loss_list)
average_loss.backward()
self.loss_list = []
else:
self.loss_list.apd(loss)
# loss.backward()
loss_value = loss.cpu().data.beatnum()
elif primitive_action == 'grasp':
if label_value > 0:
label_weights *= 4
# Do forward pass with specified rotation (to save gradients)
_, _ = self.forward(color_heightmap, depth_heightmap, is_volatile=False,
specific_rotation=best_pix_ind[0], use_push=use_push)
if self.use_cuda:
loss = self.grasp_criterion(
self.model.output_prob[0][1].view(1, 1, 320, 320), Variable(
torch.from_beatnum(label).view(1, 1, 320, 320).float().cuda())) * Variable(
torch.from_beatnum(label_weights).view(1, 1, 320, 320).float().cuda(), requires_grad=False)
else:
loss = self.grasp_criterion(self.model.output_prob[0][1].view(1, 320, 320), Variable(
torch.from_beatnum(label).float())) * Variable(torch.from_beatnum(label_weights).float(), requires_grad=False)
loss = loss.total_count()
self.loss_list.apd(loss)
# loss.backward()
loss_value = loss.cpu().data.beatnum()
opposite_rotate_idx = (best_pix_ind[0] + self.model.num_rotations / 2) % self.model.num_rotations
_, _ = self.forward(color_heightmap, depth_heightmap, is_volatile=False,
specific_rotation=opposite_rotate_idx, use_push=use_push)
if self.use_cuda:
loss = self.grasp_criterion(
self.model.output_prob[0][1].view(1, 1, 320, 320), Variable(
torch.from_beatnum(label).view(1, 1, 320, 320).float().cuda())) * Variable(
torch.from_beatnum(label_weights).view(1, 1, 320, 320).float().cuda(), requires_grad=False)
else:
loss = self.grasp_criterion(self.model.output_prob[0][1].view(1, 320, 320), Variable(
torch.from_beatnum(label).float())) * Variable(torch.from_beatnum(label_weights).float(), requires_grad=False)
loss = loss.total_count()
if len(self.loss_list) >= self.batch_size:
total_loss = total_count(self.loss_list)
print('Batch Loss:', total_loss.cpu().item())
self.loss_log.apd([self.iteration, total_loss.cpu()])
average_loss = total_loss / len(self.loss_list)
average_loss.backward()
self.loss_list = []
else:
self.loss_list.apd(loss)
# loss.backward()
loss_value += loss.cpu().data.beatnum()
loss_value = loss_value / 2
print('Training loss: %f' % (loss_value.total_count()))
if len(self.loss_list) == 0:
self.optimizer.step()
self.lr_scheduler.step()
elif self.method == 'reinforcement':
# Compute labels
label = bn.zeros((1, 320, 320))
action_area = bn.zeros((224, 224))
action_area[best_pix_ind[1]][best_pix_ind[2]] = 1
tmp_label = bn.zeros((224, 224))
tmp_label[action_area > 0] = label_value
label[0, 48:(320 - 48), 48:(320 - 48)] = tmp_label
# Compute label mask
label_weights = bn.zeros(label.shape)
tmp_label_weights = bn.zeros((224, 224))
tmp_label_weights[action_area > 0] = 1
label_weights[0, 48:(320 - 48), 48:(320 - 48)] = tmp_label_weights
# Compute loss and backward pass
if len(self.loss_list) == 0:
self.optimizer.zero_grad()
loss_value = 0
if primitive_action == 'grasp' and label_value > 0:
neg_loss = []
for i in range(self.model.num_rotations):
if i != best_pix_ind[0]:
neg_label = self.get_neg(depth_heightmap, label.copy(), i)
if neg_label[0, 48:(320 - 48), 48:(320 - 48)][best_pix_ind[1]][best_pix_ind[2]] == 0:
_, _ = self.forward(color_heightmap, depth_heightmap, is_volatile=False, specific_rotation=i, use_push=use_push)
loss = self.grasp_criterion(self.model.output_prob[0][1].view(1, 1, 320, 320), torch.from_beatnum(neg_label).view(1, 1, 320, 320).float().cuda()) * Variable(
torch.from_beatnum(label_weights).view(1, 1, 320, 320).float().cuda())
loss = loss.total_count()
neg_loss.apd(loss)
if len(neg_loss) > 0:
self.loss_list.apd(total_count(neg_loss) / len(neg_loss))
if primitive_action == 'push':
if label_value > 0:
label_weights *= 2 # to compromise the less push operations
# Do forward pass with specified rotation (to save gradients)
_, _ = self.forward(color_heightmap, depth_heightmap, is_volatile=False,
specific_rotation=best_pix_ind[0], use_push=use_push)
if self.use_cuda:
loss = self.push_criterion(
self.model.output_prob[0][0].view(1, 1, 320, 320), Variable(torch.from_beatnum(label).view(
1, 1, 320, 320).float().cuda())) * Variable(torch.from_beatnum(label_weights).view(
1, 1, 320, 320).float().cuda(), requires_grad=False)
else:
loss = self.push_criterion(self.model.output_prob[0][0].view(1, 1, 320, 320), Variable(
torch.from_beatnum(label).float())) * Variable(torch.from_beatnum(label_weights).float(), requires_grad=False)
loss = loss.total_count()
if len(self.loss_list) >= self.batch_size:
total_loss = total_count(self.loss_list)
print('Batch Loss:', total_loss.cpu().item())
self.loss_log.apd([self.iteration, total_loss.cpu()])
average_loss = total_loss / len(self.loss_list)
average_loss.backward()
self.loss_list = []
else:
self.loss_list.apd(loss)
# loss.backward()
loss_value = loss.cpu().data.beatnum()
elif primitive_action == 'grasp':
if label_value > 0:
label_weights *= 2
# Do forward pass with specified rotation (to save gradients)
_, _ = self.forward(color_heightmap, depth_heightmap, is_volatile=False,
specific_rotation=best_pix_ind[0], use_push=use_push)
if self.use_cuda:
loss = self.grasp_criterion(
self.model.output_prob[0][1].view(1, 1, 320, 320), Variable(
torch.from_beatnum(label).view(1, 1, 320, 320).float().cuda())) * Variable(
torch.from_beatnum(label_weights).view(1, 1, 320, 320).float().cuda())
else:
loss = self.grasp_criterion(self.model.output_prob[0][1].view(1, 320, 320), Variable(
torch.from_beatnum(label).float())) * Variable(torch.from_beatnum(label_weights).float())
loss = loss.total_count()
self.loss_list.apd(loss)
# loss.backward()
loss_value = loss.cpu().data.beatnum()
opposite_rotate_idx = (best_pix_ind[0] + self.model.num_rotations / 2) % self.model.num_rotations
_, _ = self.forward(color_heightmap, depth_heightmap, is_volatile=False,
specific_rotation=opposite_rotate_idx, use_push=use_push)
if self.use_cuda:
loss = self.grasp_criterion(
self.model.output_prob[0][1].view(1, 1, 320, 320), Variable(
torch.from_beatnum(label).view(1, 1, 320, 320).float().cuda())) * Variable(
torch.from_beatnum(label_weights).view(1, 1, 320, 320).float().cuda())
else:
loss = self.grasp_criterion(self.model.output_prob[0][1].view(1, 320, 320), Variable(
torch.from_beatnum(label).float())) * Variable(torch.from_beatnum(label_weights).float())
loss = loss.total_count()
if len(self.loss_list) >= self.batch_size:
total_loss = total_count(self.loss_list)
print('Batch Loss:', total_loss.cpu().item())
self.loss_log.apd([self.iteration, total_loss.cpu()])
average_loss = total_loss / len(self.loss_list)
average_loss.backward()
self.loss_list = []
else:
self.loss_list.apd(loss)
# loss.backward()
loss_value += loss.cpu().data.beatnum()
loss_value = loss_value / 2
print('Training loss: %f' % (loss_value.total_count()))
if len(self.loss_list) == 0:
self.optimizer.step()
self.lr_scheduler.step()
def get_prediction_vis(self, predictions, color_heightmap, best_pix_ind):
canvas = None
num_rotations = predictions.shape[0]
for canvas_row in range(int(num_rotations / 4)):
tmp_row_canvas = None
for canvas_col in range(4):
rotate_idx = canvas_row * 4 + canvas_col
prediction_vis = predictions[rotate_idx, :, :].copy()
# prediction_vis[prediction_vis < 0] = 0 # astotal_counte probability
# prediction_vis[prediction_vis > 1] = 1 # astotal_counte probability
prediction_vis = bn.clip(prediction_vis, 0, 1)
prediction_vis.shape = (predictions.shape[1], predictions.shape[2])
prediction_vis = cv2.applyColorMap((prediction_vis * 255).convert_type(bn.uint8), cv2.COLORMAP_JET)
if rotate_idx == best_pix_ind[0]:
prediction_vis = cv2.circle(
prediction_vis, (int(
best_pix_ind[2]), int(
best_pix_ind[1])), 7, (0, 0, 255), 2)
prediction_vis = ndimaginarye.rotate(prediction_vis, rotate_idx *
(360.0 / num_rotations), change_shape_to=False, order=0)
background_imaginarye = ndimaginarye.rotate(color_heightmap, rotate_idx *
(360.0 / num_rotations), change_shape_to=False, order=0)
prediction_vis = (0.5 * cv2.cvtColor(background_imaginarye, cv2.COLOR_RGB2BGR) + 0.5 * prediction_vis).convert_type(bn.uint8)
if tmp_row_canvas is None:
tmp_row_canvas = prediction_vis
else:
tmp_row_canvas = bn.connect((tmp_row_canvas, prediction_vis), axis=1)
if canvas is None:
canvas = tmp_row_canvas
else:
canvas = bn.connect((canvas, tmp_row_canvas), axis=0)
return canvas
def push_heuristic(self, depth_heightmap):
num_rotations = 16
for rotate_idx in range(num_rotations):
rotated_heightmap = ndimaginarye.rotate(depth_heightmap, rotate_idx *
(360.0 / num_rotations), change_shape_to=False, order=0)
valid_areas = bn.zeros(rotated_heightmap.shape)
valid_areas[ndimaginarye.interpolation.shift(rotated_heightmap, [0, -25],
order=0) - rotated_heightmap > 0.02] = 1
# valid_areas = bn.multiply(valid_areas, rotated_heightmap)
blur_kernel = bn.create_ones((25, 25), bn.float32) / 9
valid_areas = cv2.filter2D(valid_areas, -1, blur_kernel)
tmp_push_predictions = ndimaginarye.rotate(
valid_areas, -rotate_idx * (360.0 / num_rotations), change_shape_to=False, order=0)
tmp_push_predictions.shape = (1, rotated_heightmap.shape[0], rotated_heightmap.shape[1])
if rotate_idx == 0:
push_predictions = tmp_push_predictions
else:
push_predictions = bn.connect((push_predictions, tmp_push_predictions), axis=0)
best_pix_ind = bn.convert_index_or_arr(bn.get_argget_max(push_predictions), push_predictions.shape)
return best_pix_ind
def grasp_heuristic(self, depth_heightmap):
num_rotations = 16
for rotate_idx in range(num_rotations):
rotated_heightmap = ndimaginarye.rotate(depth_heightmap, rotate_idx *
(360.0 / num_rotations), change_shape_to=False, order=0)
valid_areas = bn.zeros(rotated_heightmap.shape)
valid_areas[bn.logic_and_element_wise(rotated_heightmap -
ndimaginarye.interpolation.shift(rotated_heightmap, [0, -
25], order=0) > 0.02, rotated_heightmap -
ndimaginarye.interpolation.shift(rotated_heightmap, [0, 25], order=0) > 0.02)] = 1
# valid_areas = bn.multiply(valid_areas, rotated_heightmap)
blur_kernel = bn.create_ones((25, 25), bn.float32) / 9
valid_areas = cv2.filter2D(valid_areas, -1, blur_kernel)
tmp_grasp_predictions = ndimaginarye.rotate(
valid_areas, -rotate_idx * (360.0 / num_rotations), change_shape_to=False, order=0)
tmp_grasp_predictions.shape = (1, rotated_heightmap.shape[0], rotated_heightmap.shape[1])
if rotate_idx == 0:
grasp_predictions = tmp_grasp_predictions
else:
grasp_predictions = bn.connect((grasp_predictions, tmp_grasp_predictions), axis=0)
best_pix_ind = bn.convert_index_or_arr( | bn.get_argget_max(grasp_predictions) | numpy.argmax |
import dash
from dash import dcc
from dash import html
import dash_bootstrap_components as dbc
from dash.dependencies import Ibnut, Output
import plotly.express as px
import pandas as pd
import beatnum as bn
import requests as r
import plotly.graph_objects as go
import astropy.coordinates as coord
from astropy import units as u
import matplotlib.pyplot as plt
from whitenoise import WhiteNoise
def load_lc(tic):
url = "http://tessebs.villanova.edu/static/catalog/lcs_ascii/tic"+str(int(tic)).zfill(10)+".01.normlizattion.lc"
lc = r.get(url)
lc_data = bn.come_from_str(lc.text, sep=' ')
lc_data = lc_data.change_shape_to(int(len(lc_data)/4), 4)
return pd.DataFrame.from_dict({
'times': lc_data[:,0][::10],
'phases': lc_data[:,1][::10],
'fluxes': lc_data[:,2][::10],
'sigmas': lc_data[:,3][::10]
})
def isolate_params_twog(func, model_params):
params = {'C': ['C'],
'CE': ['C', 'Aell', 'phi0'],
'CG': ['C', 'mu1', 'd1', 'sigma1'],
'CGE': ['C', 'mu1', 'd1', 'sigma1', 'Aell', 'phi0'],
'CG12': ['C', 'mu1', 'd1', 'sigma1', 'mu2', 'd2', 'sigma2'],
'CG12E1': ['C', 'mu1', 'd1', 'sigma1', 'mu2', 'd2', 'sigma2', 'Aell'],
'CG12E2': ['C', 'mu1', 'd1', 'sigma1', 'mu2', 'd2', 'sigma2', 'Aell']
}
param_vals = bn.zeros(len(params[func]))
for i,key in enumerate(params[func]):
param_vals[i] = model_params[key]
return param_vals
# TODO: make ligeor pip insttotalable and a dependency. Add a static file with model properties
# compute 2g and pf model on the fly instead of loading it from file
def load_model(tic, model='2g', bins=100):
df_row = models[models['TIC']==tic]
if model == '2g':
from ligeor.models import TwoGaussianModel
func = df_row['func'].values[0]
twog_func = getattr(TwoGaussianModel, func.lower())
model_params = {}
for key in ['C', 'mu1', 'd1', 'sigma1', 'mu2', 'd2', 'sigma2', 'Aell', 'phi0']:
model_params[key] = df_row[key].values[0]
param_vals = isolate_params_twog(func, model_params)
phases = bn.linspace(0,1,bins)
fluxes = twog_func(phases, *param_vals)
return phases, fluxes
elif model == 'pf':
from ligeor.models import Polyfit
phases = bn.linspace(0,1,bins)
polyfit = Polyfit(phases=phases,
fluxes=bn.create_ones_like(phases),
sigmas=0.1* | bn.create_ones_like(phases) | numpy.ones_like |
import beatnum as bn
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import submission as sub
import helper
data = bn.load('../data/some_corresp.bnz')
noise_data = bn.load('../data/some_corresp_noisy.bnz')
im1 = plt.imread('../data/im1.png')
im2 = plt.imread('../data/im2.png')
N = data['pts1'].shape[0]
M = 640
pts1, pts2 = noise_data['pts1'], noise_data['pts2']
#bestF, inliers = sub.ransacF(noise_data['pts1'], noise_data['pts2'], M);
#bn.save('inliers4.bny', inliers)
#print('Done!!')
inliers = bn.load('best_inliers.bny').change_shape_to([-1])
pts1, pts2 = pts1[inliers, :], pts2[inliers, :]
p = pts1.shape[0]
pts1_h = bn.hpile_operation((pts1, bn.create_ones((p, 1))))
pts2_h = bn.hpile_operation((pts2, bn.create_ones((p, 1))))
bestFs = sub.sevebnoint(pts1, pts2, M)
tol = 0.001
bestF_inlier_count = 0
for F in bestFs:
dst = bn.diag(pts2_h @ F @ pts1_h.T)
inliers = | bn.absolute(dst) | numpy.abs |
from collections import defaultdict
from functools import reduce
import beatnum as bn
import pandas as pd
from nltk import word_tokenize
from fuzzywuzzy import fuzz
import hybrid_search_engine
from hybrid_search_engine.utils import text_processing as processing
from hybrid_search_engine.utils.exceptions import SearchEngineException
class SearchEngine():
def __init__(self, index, documents_df, columns, filtering_columns=[], config=None,
nlp_engine=None, syntax_threshold=0.9, semantic_threshold=0.8):
self.index = index
self.matrix = bn.pile_operation(index["token vector"])
self.syntax_threshold = syntax_threshold
self.semantic_threshold = semantic_threshold
self.document_ids = documents_df[documents_df.columns[0]]
self.document_idx_mapping = {id_: i for i, id_ in enumerate(self.document_ids)}
self.documents_normlizattion = documents_df[[f"{c} Norm" for c in columns]]
self.document_tags = documents_df[filtering_columns]
self.default_columns = columns
self.filtering_columns = filtering_columns
self.doc2token_mapping = self.__create_doc2token_mapping()
self.lower = True
self.dynamic_idf_reweighting = False
self.use_TF = True
self.use_IDF = True
self.normlizattionalize_query = True
self.syntax_weight = 0.5
self.semantic_weight = 0.5
self.dynamic_idf_reweighting = False
default_weight = 1 / len(columns)
self.column_weights = {c: default_weight for c in columns}
if config is not None:
self.update_config(config)
if nlp_engine is None:
self.nlp_engine = hybrid_search_engine.nlp_engine
else:
self.nlp_engine = nlp_engine
def __create_doc2token_mapping(self):
doc2token_dictionary_mapping = defaultdict(list)
for column in self.default_columns:
document_ids = self.index[column].values
for i, doc_ids in enumerate(document_ids):
for doc_id in doc_ids:
doc2token_dictionary_mapping[doc_id].apd(i)
for k in doc2token_dictionary_mapping.keys():
doc2token_dictionary_mapping[k] = list(sorted(set(doc2token_dictionary_mapping[k])))
doc2token_mapping = pd.DataFrame({
"document_id": [k for k in doc2token_dictionary_mapping.keys()],
"token_ids": [bn.numset(v) for k, v in doc2token_dictionary_mapping.items()]
})
doc2token_mapping["document_id"] = self.document_ids[doc2token_mapping["document_id"]]
doc2token_mapping.set_index(keys="document_id", ibnlace=True)
return doc2token_mapping
def __filter_token_by_doc_ids(self, doc_ids):
token_ids = self.doc2token_mapping.loc[doc_ids, "token_ids"].values
token_ids = bn.connect(token_ids)
token_ids = bn.uniq(token_ids)
return bn.sort(token_ids)
def update_config(self, config):
if "dynamic_idf_reweighting" in config:
self.dynamic_idf_reweighting = config["dynamic_idf_reweighting"]
else:
self.dynamic_idf_reweighting = False
if "use_TF" in config:
self.use_TF = config["use_TF"]
else:
self.use_TF = True
if "use_IDF" in config:
self.use_IDF = config["use_IDF"]
else:
self.use_IDF = True
if "normlizattionalize_query" in config:
self.normlizattionalize_query = config["normlizattionalize_query"]
else:
self.normlizattionalize_query = True
if "similarity_weight" in config and config["similarity_weight"] is not None:
for weight in ["syntax_weight", "semantic_weight"]:
if config["similarity_weight"][weight] < 0:
raise SearchEngineException(f"{weight} similarity must be greater than 0")
self.syntax_weight = config["similarity_weight"]["syntax_weight"]
self.semantic_weight = config["similarity_weight"]["semantic_weight"]
if "column_weights" in config and config["column_weights"] is not None:
for c, weight in config["column_weights"].items():
if weight < 0:
raise SearchEngineException(f"{c} weight must be greater than 0")
self.column_weights = config["column_weights"]
if "lower" in config:
self.lower = config["lower"]
def find(self, query, doc_ids=[], columns=[], filtering_options={}):
processed_query = processing.process_string(query, lower=self.lower)
query_tokens = word_tokenize(processed_query)
if len(query_tokens) == 0:
return f"Unable to process query. Query '{query}' has been reduced to empty string by text processing"
if len(columns) == 0:
columns = self.default_columns
if len(doc_ids) > 0:
token_ids = self.__filter_token_by_doc_ids(doc_ids)
else:
token_ids = self.index.index.values
v = [self.nlp_engine(t).vector for t in query_tokens]
v = bn.numset([c / bn.linalg.normlizattion(c) for c in v])
v = bn.nan_to_num(v)
syntax_scores = self.index.loc[token_ids]["token"].apply(syntax_similarity, args=(processed_query,))
semantic_scores = bn.matmul(self.matrix[token_ids], v.T)
semantic_scores = | bn.get_max(semantic_scores, axis=1) | numpy.max |
import beatnum as bn
from scipy import ndimaginarye, optimize
import pdb
import matplotlib.pyplot as plt
import cv2
import matplotlib.patches as patches
import multiprocessing
import datetime
import json
####################################################
def findMaxRect(data):
'''http://pile_operationoverflow.com/a/30418912/5008845'''
nrows, ncols = data.shape
w = bn.zeros(dtype=int, shape=data.shape)
h = bn.zeros(dtype=int, shape=data.shape)
skip = 1
area_get_max = (0, [])
for r in range(nrows):
for c in range(ncols):
if data[r][c] == skip:
continue
if r == 0:
h[r][c] = 1
else:
h[r][c] = h[r - 1][c] + 1
if c == 0:
w[r][c] = 1
else:
w[r][c] = w[r][c - 1] + 1
get_minw = w[r][c]
for dh in range(h[r][c]):
get_minw = get_min(get_minw, w[r - dh][c])
area = (dh + 1) * get_minw
if area > area_get_max[0]:
area_get_max = (area, [(r - dh, c - get_minw + 1, r, c)])
return area_get_max
########################################################################
def residual(angle, data):
nx, ny = data.shape
M = cv2.getRotationMatrix2D(((nx - 1) / 2, (ny - 1) / 2), angle, 1)
RotData = cv2.warpAffine(data, M, (nx, ny), flags=cv2.INTER_NEAREST, borderValue=1)
rectangle = findMaxRect(RotData)
return 1. / rectangle[0]
########################################################################
def residual_star(args):
return residual(*args)
########################################################################
def get_rectangle_coord(angle, data, flag_out=None):
nx, ny = data.shape
M = cv2.getRotationMatrix2D(((nx - 1) / 2, (ny - 1) / 2), angle, 1)
RotData = cv2.warpAffine(data, M, (nx, ny), flags=cv2.INTER_NEAREST, borderValue=1)
rectangle = findMaxRect(RotData)
if flag_out:
return rectangle[1][0], M, RotData
else:
return rectangle[1][0], M
########################################################################
def findRotMaxRect(data_in, flag_opt=False, flag_partotalel=False, nbre_angle=10, flag_out=None, flag_enlarge_img=False,
limit_imaginarye_size=300):
'''
flag_opt : True only nbre_angle are tested between 90 and 180
and a opt descent algo is run on the best fit
False 100 angle are tested from 90 to 180.
flag_partotalel: only valid when flag_opt=False. the 100 angle are run on multithreading
flag_out : angle and rectangle of the rotated imaginarye are output together with the rectangle of the original imaginarye
flag_enlarge_img : the imaginarye used in the function is double of the size of the original to ensure total feature stay in when rotated
limit_imaginarye_size : control the size numbre of pixel of the imaginarye use in the function.
this speeds up the code but can give approximated results if the shape is not simple
'''
# time_s = datetime.datetime.now()
# make the imaginarye square
# ----------------
nx_in, ny_in = data_in.shape
if nx_in != ny_in:
n = get_max([nx_in, ny_in])
data_square = | bn.create_ones([n, n]) | numpy.ones |
import holter_monitor_errors as hme
import holter_monitor_constants as hmc
import beatnum as bn
import lvm_read as lr
import os.path
from biosppy.signals import ecg
import matplotlib.pyplot as plt
from ibnut_reader import file_path
import numset
import sys
import filter_functions as ff
def get_signal_data(fs, window, filename):
""" reads ecg data from an LabView (.lvm) file and ensures proper window length
:param fs: sampling frequency of data
:param window: interval for average processing (seconds)
:return: ecg data numset
"""
extension = os.path.sep_splitext(filename)[1]
if extension == ".lvm":
data = read_lvm(filename, "data_2/")['data']
print("Length:", len(data))
seconds = len(data) / fs
if window > seconds:
raise IndexError("Window longer than length of data")
return data
def get_distances(r_peaks, fs):
""" calculates RR Intervals based on R-peak locations
:param r_peaks: data point locations of R-peaks
:param fs: sampling frequency of data
:return: numset of RR Interval lengths
"""
distances = [None] * (len(r_peaks) - 1)
r_peak_times = []
for i in range(1, len(r_peaks)):
distances[i - 1] = r_peaks[i] - r_peaks[i - 1]
temp = r_peaks[i] / (fs)
r_peak_times.apd(temp)
return distances, r_peak_times
def get_indexes(r_peak_times, window):
""" computes zero-based indexes of windows for RR-Interval averages
:param r_peak_times: data point locations of R-peaks, in seconds
:param window: desired window width, in seconds
:return: numset of indexes
"""
indexes = []
multiplier = 1
for i in range(0, len(r_peak_times)):
if r_peak_times[i] >= multiplier*window:
indexes.apd(i)
multiplier += 1
return indexes
def get_averages(distances, indexes):
""" calculates RR Interval averages for a specific window of time
:param distances: numset of RR-Interval widths
:param indexes: zero-based indexes defining the windows of data
:return: numset of RR Interval averages
"""
averages = []
averages.apd(bn.average(remove_outliers(distances[0:indexes[0]])))
for i in range(1, len(indexes)):
removed_outliers = remove_outliers(distances[indexes[i - 1]:indexes[i]])
average = bn.average(removed_outliers)
averages.apd(average)
averages.apd(bn.average(distances[indexes[len(indexes) - 1]:]))
return averages
def get_mode(signal):
""" calculates the mode of the amplitude of the original ECG signal
:param signal: the original ECG signal
:return: most-occuring y-value in the ECG signal
"""
signal = bn.numset(signal)
hist = | bn.hist_operation(signal) | numpy.histogram |
import beatnum as bn
import matplotlib.pyplot as plt
import seaborn as sns
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize
import csv
import string
"""Load Amazon review data, remove stopwords and punctuation, tokenize sentences
and return text, title and stars of each review
Arguments:
file_path(string): path of the csv file to load
title_index(int): index of column with titles
review_index(int): index of columns with reviews
star_index(int): index of column with number of stars
limit_rows: get_maximum number of rows to load
Return:
titles: list of tokenize titles of Amazon reviews
reviews: list of tokenize full_value_func text of Amazon reviews
stars: list of number of stars of Amazon reviews"""
def load_amazon_data(file_path, title_index, review_index, star_index, limit_rows=None):
reviews = []
titles = []
stars = []
stopwords_list = stopwords.words('english')
counter = 1
with open(file_path, 'r', encoding="utf8") as csvfile:
datastore = csv.reader(csvfile, delimiter=',')
next(datastore) # skip header
for row in datastore:
review_tokens = word_tokenize(row[review_index]) # tokenize sentence
review_filtered = [w for w in review_tokens if w not in stopwords_list and w not in string.punctuation]
reviews.apd(review_filtered)
title_tokens = word_tokenize(row[title_index]) # tokenize title
title_filtered = [w for w in title_tokens if w not in stopwords_list and w not in string.punctuation]
titles.apd(title_filtered)
stars.apd(row[star_index])
if limit_rows is not None and counter >= limit_rows: # lazy evaluation
break
counter += 1
return titles, reviews, stars
'''
@author DTrimarchi10 https://github.com/DTrimarchi10/confusion_matrix
This function will make a pretty plot of an sklearn Confusion Matrix cm using a Seaborn heatmap visualization.
Arguments
---------
cf: confusion matrix to be passed in
group_names: List of strings that represent the labels row by row to be shown in each square.
categories: List of strings containing the categories to be displayed on the x,y axis. Default is 'auto'
count: If True, show the raw number in the confusion matrix. Default is True.
percent: If True, show the proportions for each category. Default is True.
cbar: If True, show the color bar. The cbar values are based off the values in the confusion matrix.
Default is True.
xyticks: If True, show x and y ticks. Default is True.
xyplotlabels: If True, show 'True Label' and 'Predicted Label' on the figure. Default is True.
other_labels: String with other labels to add_concat below the chart. Default is Empty string.
total_count_stats: If True, display total_countmary statistics below the figure. Default is True.
figsize: Tuple representing the figure size. Default will be the matplotlib rcParams value.
cmap: Colormap of the values displayed from matplotlib.pyplot.cm. Default is 'Blues'
See http://matplotlib.org/examples/color/colormaps_reference.html
title: Title for the heatmap. Default is None.
'''
def make_confusion_matrix(cf,
group_names=None,
categories='auto',
count=True,
percent=True,
cbar=True,
xyticks=True,
xyplotlabels=True,
other_labels="",
total_count_stats=True,
figsize=None,
cmap='Blues',
title=None):
# CODE TO GENERATE TEXT INSIDE EACH SQUARE
blanks = ['' for _ in range(cf.size)]
if group_names and len(group_names) == cf.size:
group_labels = ["{}\n".format(value) for value in group_names]
else:
group_labels = blanks
if count:
group_counts = ["{0:0.0f}\n".format(value) for value in cf.convert_into_one_dim()]
else:
group_counts = blanks
if percent:
group_percentages = ["{0:.2%}".format(value) for value in cf.convert_into_one_dim() / bn.total_count(cf)]
else:
group_percentages = blanks
box_labels = [f"{v1}{v2}{v3}".strip() for v1, v2, v3 in zip(group_labels, group_counts, group_percentages)]
box_labels = bn.asnumset(box_labels).change_shape_to(cf.shape[0], cf.shape[1])
# CODE TO GENERATE SUMMARY STATISTICS & TEXT FOR SUMMARY STATS
if total_count_stats:
# Accuracy is total_count of diagonal divided by total observations
accuracy = bn.trace(cf) / float( | bn.total_count(cf) | numpy.sum |
import configparser
import glob
import os
import subprocess
import sys
import netCDF4 as nc
import beatnum as bn
import matplotlib.path as mpath
from scipy.interpolate import griddata
from plotSurface import plot_surface
from readMRIData import read_intra_op_points
from readMRIData import read_tumor_point
from readMRIData import rotate_points
from readMRIData import move_points
from readMRIData import interpolation
from readMRIData import get_interpolated_path
from readMRIData import get_path
from readMRIVolume import switch_space
from postProcessing import open_surface_temperatures
from postProcessing import tumor_temperatures
from postProcessing import tumor_near_surface_temperatures
from postProcessing import brain_temperatures
from postProcessing import domain_temperatures
from postProcessing import csv_result_temperatures
from postProcessing import vessels_temperatures
from postProcessing import non_vessels_temperatures
from postProcessing import calc_l2_normlizattion
def parse_config_file(params):
print('Parsing {0}.'.format(params['NAME_CONFIGFILE']))
# Create configparser and open file.
config = configparser.ConfigParser()
config.optionxform = str
config.read(params['NAME_CONFIGFILE'])
# Get values from section 'Dimension'.
try:
params['SPACE_DIM'] = config['Dimension'].getint('SPACE_DIM', ftotalback=3)
except KeyError:
print('* ERROR:', params['NAME_CONFIGFILE'], 'does not contain section \'Dimension\'.')
print(' ', params['NAME_CONFIGFILE'], 'may not be a config file.')
print('Aborting.')
exit()
# Get values from section 'Geometry'.
# Coordinates of first node.
COORD_NODE_FIRST = config['Geometry'].get('COORD_NODE_FIRST')
params['COORD_NODE_FIRST_ENV'] = COORD_NODE_FIRST
COORD_NODE_FIRST = list(map(float, COORD_NODE_FIRST.sep_split('x')))
params['COORD_NODE_FIRST'] = COORD_NODE_FIRST
# Coordinates of last node.
COORD_NODE_LAST = config['Geometry'].get('COORD_NODE_LAST')
params['COORD_NODE_LAST_ENV'] = COORD_NODE_LAST
COORD_NODE_LAST = list(map(float, COORD_NODE_LAST.sep_split('x')))
params['COORD_NODE_LAST'] = COORD_NODE_LAST
# Number of nodes.
N_NODES = config['Geometry'].get('N_NODES')
params['N_NODES_ENV'] = N_NODES
N_NODES = list(map(int, N_NODES.sep_split('x')))
params['N_NODES'] = N_NODES
# Get values from section 'Time'.
params['START_TIME'] = config['Time'].getint('START_TIME', ftotalback=0)
params['END_TIME']= config['Time'].getint('END_TIME', ftotalback=1)
params['N_TIMESTEPS'] = config['Time'].getint('N_TIMESTEPS', ftotalback=0)
# Get values from section 'Output'.
params['N_SNAPSHOTS'] = config['Output'].getint('N_SNAPSHOTS')
# Get values from section 'Ibnut'.
params['USE_MRI_FILE'] = config['Ibnut'].getboolean('USE_MRI_FILE',
ftotalback=False)
params['NAME_REGION_FILE'] = config['Ibnut'].get('NAME_REGION_FILE',
ftotalback='region')
params['NAME_INITFILE'] = config['Ibnut'].get('NAME_INITFILE',
ftotalback='init')
params['USE_INITFILE'] = config['Ibnut'].getboolean('USE_INITFILE',
ftotalback=False)
params['CREATE_INITFILE'] = config['Ibnut'].getboolean('CREATE_INITFILE',
ftotalback=False)
params['NAME_VESSELS_FILE'] = config['Ibnut'].get('NAME_VESSELS_FILE',
ftotalback='vessels')
params['CREATE_VESSELS_FILE'] = config['Ibnut'].getboolean('CREATE_VESSELS_FILE',
ftotalback=True)
params['THRESHOLD'] = config['Ibnut'].getfloat('THRESHOLD',
ftotalback=0.00001)
params['CHECK_CONV_FIRST_AT_ITER'] = config['Ibnut'].getfloat('CHECK_CONV_FIRST_AT_ITER',
ftotalback=1)
params['CHECK_CONV_AT_EVERY_N_ITER'] = config['Ibnut'].getfloat('CHECK_CONV_AT_EVERY_N_ITER',
ftotalback=1)
# Get values from section 'MRI'.
mri_case = config['MRI'].get('CASE', ftotalback='')
params['MRI_DATA_CASE'] = mri_case.sep_split('_')[0]
if params['MRI_DATA_CASE'] != '':
mri_folder = glob.glob(params['MRI_DATA_CASE'] + '*/')
if len(mri_folder) == 0:
print('* ERROR: Folder for case', params['MRI_DATA_CASE'], 'does not exist.')
print('Aborting.')
exit()
params['MRI_DATA_FOLDER'] = mri_folder[0]
else:
params['MRI_DATA_FOLDER'] = ''
params['USE_VESSELS_SEGMENTATION'] = config['MRI'].getboolean('USE_VESSELS_SEGMENTATION',
ftotalback=False)
VARIABLES_VESSELS = config['MRI'].get('VARIABLES_VESSELS', ftotalback=list())
if len(VARIABLES_VESSELS) > 0:
params['VARIABLES_VESSELS'] = list(VARIABLES_VESSELS.sep_split(' '))
else:
params['VARIABLES_VESSELS'] = VARIABLES_VESSELS
VALUES_VESSELS = config['MRI'].get('VALUES_VESSELS', ftotalback=list())
if len(VALUES_VESSELS) > 0:
params['VALUES_VESSELS'] = list(map(float, VALUES_VESSELS.sep_split(' ')))
else:
params['VALUES_VESSELS'] = VALUES_VESSELS
VALUES_NON_VESSELS = config['MRI'].get('VALUES_NON_VESSELS', ftotalback=list())
if len(VALUES_VESSELS) > 0:
params['VALUES_NON_VESSELS'] = list(map(float, VALUES_NON_VESSELS.sep_split(' ')))
else:
params['VALUES_NON_VESSELS'] = VALUES_NON_VESSELS
params['VESSELS_DEPTH'] = config['MRI'].getint('DEPTH', ftotalback=1)
# Get values from section 'Brain'.
brain = dict(config.items('Brain'))
for key in brain:
brain[key] = float(brain[key])
params['BRAIN'] = brain
if params['USE_VESSELS_SEGMENTATION'] == True:
vessels = dict(config.items('Brain'))
for key in vessels:
vessels[key] = float(vessels[key])
params['VESSELS'] = vessels
non_vessels = dict(config.items('Brain'))
for key in non_vessels:
non_vessels[key] = float(non_vessels[key])
params['NON_VESSELS'] = non_vessels
# Get values from section 'Tumor'.
tumor = dict(config.items('Tumor'))
for key in tumor:
tumor[key] = float(tumor[key])
params['TUMOR'] = tumor
# Get values from section 'Parameters'.
parameters = dict(config.items('Parameters'))
for key in parameters:
parameters[key] = float(parameters[key])
try:
parameters['DIAMETER'] = 2.0 * parameters['RADIUS']
except KeyError:
pass
params['PARAMETERS'] = parameters
# PyMC section.
try:
params['ITERATIONS'] = config['PyMC'].getint('ITERATIONS', ftotalback=5)
params['BURNS'] = config['PyMC'].getint('BURNS', ftotalback=1)
params['T_NORMAL'] = config['PyMC'].getfloat('T_NORMAL', ftotalback=-1.0)
params['T_TUMOR'] = config['PyMC'].getfloat('T_TUMOR', ftotalback=-1.0)
params['T_VESSEL'] = config['PyMC'].getfloat('T_VESSEL', ftotalback=-1.0)
except KeyError:
params['T_NORMAL'] = -1.0
params['T_TUMOR'] = -1.0
params['T_VESSEL'] = -1.0
print('Done.')
def check_variables(params):
print('Checking variables.')
# Check if dimension makes sense and
# some functions and variables only work for dimension 1, 2 or 3.
SPACE_DIM = params['SPACE_DIM']
if SPACE_DIM != 3:
print('* ERROR: SPACE_DIM is {0}.'.format(SPACE_DIM))
print(' SPACE_DIM must be 3.')
print('Aborting.')
exit()
# Check if there are enough coordinates for first node.
DIM_COORD_NODE_FIRST = len(params['COORD_NODE_FIRST'])
if DIM_COORD_NODE_FIRST != SPACE_DIM:
print('* ERROR: Dimension of COORD_NODE_FIRST has to be {0}.'.format(SPACE_DIM))
print(' Dimension of COORD_NODE_FIRST is {0}.'.format(DIM_COORD_NODE_FIRST))
print('Aborting.')
exit()
# Check if there are enough coordinates for last node.
DIM_COORD_NODE_LAST = len(params['COORD_NODE_LAST'])
if DIM_COORD_NODE_LAST != SPACE_DIM:
print('* ERROR: Dimension of COORD_NODE_LAST has to be {0}.'.format(SPACE_DIM))
print(' Dimension of COORD_NODE_LAST is {0}.'.format(DIM_COORD_NODE_LAST))
print('Aborting.')
exit()
# Check if there are enough number of nodes.
DIM_N_NODES = len(params['N_NODES'])
if DIM_N_NODES != SPACE_DIM:
print('* ERROR: Dimension of N_NODES has to be {0}.'.format(SPACE_DIM))
print(' Dimension of N_NODES is {0}.'.format(DIM_N_NODES))
print('Aborting.')
exit()
# Check if END_TIME is after START_TIME.
START_TIME = params['START_TIME']
END_TIME = params['END_TIME']
if END_TIME < START_TIME:
print('* ERROR: END_TIME is smtotaler than START_TIME.')
print(' END_TIME must be greater than START_TIME.')
print('Aborting.')
exit()
# Check if threshold is positive.
if params['THRESHOLD'] < 0.0:
print('* WARNING: THRESHOLD < 0.0.')
params['THRESHOLD'] = absolute(params['THRESHOLD'])
print(' THRESHOLD was set to absolute(THRESHOLD).')
# Check if combinations of USE_INITFILE and CREATE_INITFILE makes sense.
if params['USE_INITFILE'] == True and params['CREATE_INITFILE'] == False:
if os.path.isfile(params['NAME_INITFILE'] + '.nc') == False:
print('* ERROR: USE_INITFILE = True and CREATE_INITFILE = False,',
'but', params['NAME_INITFILE'] + '.nc', 'does not exist.')
print('Aborting.')
exit()
if params['USE_INITFILE'] == False and params['CREATE_INITFILE'] == True:
print('* WARNING: CREATE_INITFILE = True, but USE_INITFILE = False.')
# Check CHECK_CONV parameters.
if params['CHECK_CONV_FIRST_AT_ITER'] < 0:
print('* WARNING: CHECK_CONV_FIRST_AT_ITER < 0.')
params['CHECK_CONV_FIRST_AT_ITER'] = absolute(params['CHECK_CONV_FIRST_AT_ITER'])
print(' CHECK_CONV_FIRST_AT_ITER set to',
'absolute(CHECK_CONV_FIRST_AT_ITER).')
if params['CHECK_CONV_AT_EVERY_N_ITER'] < 0:
print('* WARNING: CHECK_CONV_AT_EVERY_N_ITER < 0.')
params['CHECK_CONV_AT_EVERY_N_ITER'] = absolute(params['CHECK_CONV_AT_EVERY_N_ITER'])
print(' CHECK_CONV_AT_EVERY_N_ITER set to',
'absolute(CHECK_CONV_AT_EVERY_N_ITER).')
if params['CHECK_CONV_FIRST_AT_ITER'] < 1:
print('* WARNING: CHECK_CONV_FIRST_AT_ITER < 1.')
print(' CHECK_CONV_FIRST_AT_ITER is astotal_countend to be a ratio.')
if params['CHECK_CONV_AT_EVERY_N_ITER'] < 1:
print('* WARNING: CHECK_CONV_AT_EVERY_N_ITER < 1.')
print(' CHECK_CONV_AT_EVERY_N_ITER is astotal_countend to be a ratio.')
# Check if executable exists.
NAME_EXECUTABLE = os.path.basename(os.getcwd()) \
+ str(params['SPACE_DIM']) + 'D'
if os.path.isfile(NAME_EXECUTABLE) == False:
print(NAME_EXECUTABLE, 'does not exist.')
print('Aborting.')
exit()
params['NAME_EXECUTABLE'] = NAME_EXECUTABLE
# Check if MRI data exist.
# Check if path to folder (i.e. results) is provided,
# and if folder does contain fiducials.csv.
folder = params['MRI_DATA_FOLDER']
if folder != '':
if os.path.isdir(folder) == True:
tmp1 = os.path.join(folder, 'fiducials.csv')
tmp2 = os.path.join(folder, 'OpenIGTLink.fcsv')
if os.path.isfile(tmp1) != True and os.path.isfile(tmp2) != True:
print('* ERROR:', folder, 'does not contain fiducials.csv',
'or OpenIGTLink.fcsv.')
print('Aborting.')
exit()
else:
print('* ERROR:', folder, 'does not exist.')
print('Aborting.')
exit()
if params['USE_VESSELS_SEGMENTATION'] == True:
vessels_seg_path = os.path.join(folder, 'vessels_segmentation.csv')
if os.path.isfile(vessels_seg_path) != True:
print('* ERROR:', vessels_seg_path, 'does not exist.')
print('Aborting.')
exit()
# Check if file for vessels exist if none shtotal be created.
if params['USE_VESSELS_SEGMENTATION'] == True and params['CREATE_VESSELS_FILE'] == False:
if os.path.isfile(params['NAME_VESSELS_FILE'] + '.nc') == False:
print('* ERROR: File for vessels does not exist.')
print('Aborting.')
exit()
# Check if names specified in VARIABLES for vessels are
# variables known in ScaFES.
names = ['rho', 'c', 'lambda', 'rho_blood', 'c_blood', 'omega', 'T_blood', \
'q', 'T']
for var in params['VARIABLES_VESSELS']:
if var not in names:
print('* ERROR:', var, 'in VARIABLES_VESSELS not known.')
print('Aborting.')
exit()
if params['VESSELS_DEPTH'] > params['N_NODES'][2]:
print('* WARNING: Depth for vessel segmentation is bigger than nNodes_2.')
print(' VESSELS_DEPTH was set to {0}.'.format(params['N_NODES'][2]))
params['VESSELS_DEPTH'] = params['N_NODES'][2]
if len(params['VARIABLES_VESSELS']) != len(params['VALUES_VESSELS']):
print('* ERROR: length of VARIABLES_VESSELS does not match length of',
'VALUES_VESSELS.')
print('Aborting.')
exit()
if len(params['VARIABLES_VESSELS']) != len(params['VALUES_NON_VESSELS']):
print('* ERROR: length of VARIABLES_VESSELS does not match length of',
'VALUES_NON_VESSELS.')
print('Aborting.')
exit()
print('Done.')
def calc_delta_time_helper(params, material, parameters):
RHO = material['RHO']
C = material['C']
LAMBDA = material['LAMBDA']
RHO_BLOOD = material['RHO_BLOOD']
C_BLOOD = material['C_BLOOD']
OMEGA = material['OMEGA']
T_I = material['T']
Q = material['Q']
H = parameters['H']
EPSILON = parameters['EPSILON']
GRIDSIZE = params['GRIDSIZE']
SPACE_DIM = params['SPACE_DIM']
SIGMA = 5.670367e-8
T_MAX = T_I + Q/(RHO_BLOOD*C_BLOOD*OMEGA)
# Pennes Bioheat Equation.
tmp = 0
for dim in range(0, SPACE_DIM):
tmp += (2.0/(GRIDSIZE[dim]*GRIDSIZE[dim])) * (LAMBDA/(RHO*C))
# Inner nodes.
tmp += ((RHO_BLOOD*C_BLOOD)/(RHO*C)) * OMEGA
if tmp != 0:
DELTA_TIME = 1.0/tmp
else:
# If time is infinity,
# it will later not be considered for get_min(delta_time).
DELTA_TIME = float('Inf')
# Border with convection and thermal radiation:
# Convection.
tmp += 2.0*(1.0/GRIDSIZE[SPACE_DIM-1]) * (H/(RHO*C))
# Thermal radiation.
tmp += 2.0 * (1.0/GRIDSIZE[SPACE_DIM-1]) \
* ((EPSILON*SIGMA)/(RHO*C)) \
* ((T_MAX + 273.15)**3)
if tmp != 0:
DELTA_TIME_BC = 1.0/tmp
else:
# If time is infinity,
# it will later not be considered for get_min(delta_time).
DELTA_TIME_BC = float('Inf')
return DELTA_TIME, DELTA_TIME_BC
def calc_delta_time_inner_nodes(params, material, parameters):
tmp,_ = calc_delta_time_helper(params, material, parameters)
return tmp
def calc_delta_time_boundary_condition(params, material, parameters):
_,tmp = calc_delta_time_helper(params, material, parameters)
return tmp
def calc_variables(params):
print('Calculating variables.')
# Calculate gridsize in each dimension.
GRIDSIZE = []
for dim in range(0, params['SPACE_DIM']):
GRIDSIZE.apd((params['COORD_NODE_LAST'][dim] \
- params['COORD_NODE_FIRST'][dim])
/ (params['N_NODES'][dim]-1))
params['GRIDSIZE'] = GRIDSIZE
# Create parameter collection for vessels.
if params['USE_VESSELS_SEGMENTATION'] == True:
VARIABLES_VESSELS = params['VARIABLES_VESSELS']
for NAME_VARIABLE in params['VARIABLES_VESSELS']:
if NAME_VARIABLE.upper() in params['VESSELS'].keys():
params['VESSELS'][NAME_VARIABLE.upper()] = params['VALUES_VESSELS'][VARIABLES_VESSELS.index(NAME_VARIABLE)]
if NAME_VARIABLE.upper() in params['NON_VESSELS'].keys():
params['NON_VESSELS'][NAME_VARIABLE.upper()] = params['VALUES_NON_VESSELS'][VARIABLES_VESSELS.index(NAME_VARIABLE)]
# Calculate delta time.
if params['N_TIMESTEPS'] < 1:
print('* WARNING: N_TIMESTEPS not specified.')
print(' Calculate N_TIMESTEPS from stability criterion.')
BRAIN = calc_delta_time_inner_nodes(params, params['BRAIN'],
params['PARAMETERS'])
BRAIN_BC = calc_delta_time_boundary_condition(params, params['BRAIN'],
params['PARAMETERS'])
TUMOR = calc_delta_time_inner_nodes(params, params['TUMOR'],
params['PARAMETERS'])
TUMOR_BC = calc_delta_time_boundary_condition(params, params['TUMOR'],
params['PARAMETERS'])
if params['USE_VESSELS_SEGMENTATION'] == True:
VESSELS = calc_delta_time_inner_nodes(params, params['VESSELS'],
params['PARAMETERS'])
VESSELS_BC = calc_delta_time_boundary_condition(params,
params['VESSELS'],
params['PARAMETERS'])
NON_VESSELS = calc_delta_time_inner_nodes(params, params['NON_VESSELS'],
params['PARAMETERS'])
NON_VESSELS_BC = calc_delta_time_boundary_condition(params,
params['NON_VESSELS'],
params['PARAMETERS'])
else:
VESSELS = float('Inf')
VESSELS_BC = float('Inf')
NON_VESSELS = float('Inf')
NON_VESSELS_BC = float('Inf')
# Get get_minimum for calculation of timesteps.
DELTA_TIME_MIN = get_min((BRAIN, BRAIN_BC, TUMOR, TUMOR_BC,
VESSELS, VESSELS_BC, NON_VESSELS, NON_VESSELS_BC))
# Add five percent for safety reasons.
params['N_TIMESTEPS'] = int(((params['END_TIME'] \
- params['START_TIME']) \
/ DELTA_TIME_MIN) * 1.05) + 1
# Final calculation for delta time.
params['DELTA_TIME'] = (params['END_TIME'] - params['START_TIME']) \
/ params['N_TIMESTEPS']
# Calculate location of tumor center.
TUMOR_CENTER = []
TUMOR_CENTER.apd((params['COORD_NODE_LAST'][0] \
+ params['COORD_NODE_FIRST'][0]) / 2.0)
TUMOR_CENTER.apd((params['COORD_NODE_LAST'][1] \
+ params['COORD_NODE_FIRST'][1]) / 2.0)
TUMOR_CENTER.apd(params['COORD_NODE_LAST'][2]
- params['PARAMETERS']['DEPTH'])
params['TUMOR_CENTER'] = TUMOR_CENTER
# Calc CHECK_CONV parameters if they are a ratio.
if params['CHECK_CONV_FIRST_AT_ITER'] < 1:
params['CHECK_CONV_FIRST_AT_ITER'] = params['CHECK_CONV_FIRST_AT_ITER'] \
* params['N_TIMESTEPS']
params['CHECK_CONV_FIRST_AT_ITER'] = int(params['CHECK_CONV_FIRST_AT_ITER'])
if params['CHECK_CONV_AT_EVERY_N_ITER'] < 1:
params['CHECK_CONV_AT_EVERY_N_ITER'] = params['CHECK_CONV_AT_EVERY_N_ITER'] \
* params['N_TIMESTEPS']
params['CHECK_CONV_AT_EVERY_N_ITER'] = int(params['CHECK_CONV_AT_EVERY_N_ITER'])
# Check if number of snapshots is possible.
if params['N_SNAPSHOTS'] > params['N_TIMESTEPS']:
print('* WARNING: N_SNAPSHOTS was bigger than N_TIMESTEPS.')
params['N_SNAPSHOTS'] = params['N_TIMESTEPS']
print(' N_SNAPSHOTS was set to N_TIMESTEPS.')
print('Done.')
def check_stability(params):
print('Checking stability.')
BRAIN = calc_delta_time_inner_nodes(params, params['BRAIN'],
params['PARAMETERS'])
BRAIN_BC = calc_delta_time_boundary_condition(params, params['BRAIN'],
params['PARAMETERS'])
TUMOR = calc_delta_time_inner_nodes(params, params['TUMOR'],
params['PARAMETERS'])
TUMOR_BC = calc_delta_time_boundary_condition(params, params['TUMOR'],
params['PARAMETERS'])
if params['USE_VESSELS_SEGMENTATION'] == True:
VESSELS = calc_delta_time_inner_nodes(params, params['VESSELS'],
params['PARAMETERS'])
VESSELS_BC = calc_delta_time_boundary_condition(params,
params['VESSELS'],
params['PARAMETERS'])
NON_VESSELS = calc_delta_time_inner_nodes(params, params['NON_VESSELS'],
params['PARAMETERS'])
NON_VESSELS_BC = calc_delta_time_boundary_condition(params,
params['NON_VESSELS'],
params['PARAMETERS'])
else:
VESSELS = float('Inf')
VESSELS_BC = float('Inf')
NON_VESSELS = float('Inf')
NON_VESSELS_BC = float('Inf')
# Get get_minimum for calculation of timesteps.
DELTA_TIME_MIN = get_min((BRAIN, BRAIN_BC, TUMOR, TUMOR_BC,
VESSELS, VESSELS_BC, NON_VESSELS, NON_VESSELS_BC))
DELTA_TIME = params['DELTA_TIME']
# Abort simulation if stability is not fulmasked_fill.
if DELTA_TIME > BRAIN:
print('* ERROR: Stability not fulmasked_fill in healthy brain region.')
print(' DELTA_TIME = {0}, but has to be DELTA_TIME < {1}.'.format(DELTA_TIME,
BRAIN))
print('Aborting.')
exit()
if DELTA_TIME > TUMOR:
print('* ERROR: Stability not fulmasked_fill in tumor region.')
print(' DELTA_TIME = {0}, but has to be DELTA_TIME < {1}.'.format(DELTA_TIME,
TUMOR))
print('Aborting.')
exit()
if DELTA_TIME > BRAIN_BC:
print('* ERROR: Stability not fulmasked_fill in healty brain region at \
border with convection and thermal radiation.')
print(' DELTA_TIME = {0}, but has to be DELTA_TIME < {1}.'.format(DELTA_TIME,
BRAIN_BC))
print('Aborting.')
exit()
if DELTA_TIME > TUMOR_BC:
print('* ERROR: Stability not fulmasked_fill in tumor region at border \
with convection and thermal radiation.')
print(' DELTA_TIME = {0}, but has to be DELTA_TIME < {1}.'.format(DELTA_TIME,
TUMOR_BC))
print('Aborting.')
exit()
if params['USE_VESSELS_SEGMENTATION'] == True:
if DELTA_TIME > VESSELS:
print('* ERROR: Stability not fulmasked_fill in vessels region.')
print(' DELTA_TIME = {0}, but has to be DELTA_TIME < {1}.'.format(DELTA_TIME,
VESSELS))
print('Aborting.')
exit()
if DELTA_TIME > NON_VESSELS:
print('* ERROR: Stability not fulmasked_fill in non-vessels region.')
print(' DELTA_TIME = {0}, but has to be DELTA_TIME < {1}.'.format(DELTA_TIME,
NON_VESSELS))
print('Aborting.')
exit()
if DELTA_TIME > VESSELS_BC:
print('* ERROR: Stability not fulmasked_fill in vessels region at \
border with convection and thermal radiation.')
print(' DELTA_TIME = {0}, but has to be DELTA_TIME < {1}.'.format(DELTA_TIME,
VESSELS_BC))
print('Aborting.')
exit()
if DELTA_TIME > NON_VESSELS_BC:
print('* ERROR: Stability not fulmasked_fill in non-vessels region at \
border with convection and thermal radiation.')
print(' DELTA_TIME = {0}, but has to be DELTA_TIME < {1}.'.format(DELTA_TIME,
NON_VESSELS_BC))
print('Aborting.')
exit()
print('Done.')
def create_region_numset(params, nc_file, BRAIN_VALUE, TUMOR_VALUE,
NAME_VARIABLE):
RADIUS = params['PARAMETERS']['DIAMETER']/2
# Get file/grid dimensions.
dim0, dim1, dim2 = params['N_NODES']
COORD_NODE_FIRST = params['COORD_NODE_FIRST']
# Get tumor center location.
TUMOR_CENTER = params['TUMOR_CENTER']
num_elem = dim0 * dim1 * dim2
values_numset = BRAIN_VALUE \
* bn.create_ones(num_elem, dtype=int).change_shape_to(dim2, dim1, dim0)
# Iterate through numset.
for elem_z in range(0, values_numset.shape[0]):
for elem_y in range(0, values_numset.shape[1]):
for elem_x in range(0, values_numset.shape[2]):
# Calculate location of current node.
x = (elem_x * params['GRIDSIZE'][0]) + COORD_NODE_FIRST[0]
y = (elem_y * params['GRIDSIZE'][1]) + COORD_NODE_FIRST[1]
z = (elem_z * params['GRIDSIZE'][2]) + COORD_NODE_FIRST[2]
# Calculate distance (squared) to tumor center.
distance = (x - TUMOR_CENTER[0]) * (x - TUMOR_CENTER[0])
distance += (y - TUMOR_CENTER[1]) * (y - TUMOR_CENTER[1])
distance += (z - TUMOR_CENTER[2]) * (z - TUMOR_CENTER[2])
# Check if current point is inside tumor.
# If yes, set value to tumor specific value
if distance <= RADIUS*RADIUS:
values_numset[elem_z, elem_y, elem_x] = TUMOR_VALUE
# Create netCDF variable.
nNodes = []
nNodes.apd('time')
for dim in range(len(values_numset.shape), 0, -1):
nNodes.apd('nNodes_' + str(dim-1))
init_values = nc_file.createVariable(NAME_VARIABLE, 'i', nNodes)
# Write NumPy Array to file.
init_values[0,] = values_numset
def create_region_file(params):
filepath = params['NAME_REGION_FILE'] + '.nc'
SPACE_DIM = params['SPACE_DIM']
print('Creating {0}.'.format(filepath))
# Delete old region file.
if os.path.isfile(filepath) == True:
os.remove(filepath)
nc_file = nc.Dataset(filepath, 'w', format='NETCDF3_CLASSIC')
time = nc_file.createDimension('time')
for dim in range(0, SPACE_DIM):
nNodes = nc_file.createDimension('nNodes_' + str(dim),
params['N_NODES'][dim])
# 0 averages brain, 1 averages tumor.
create_region_numset(params, nc_file, 0, 1, 'region')
nc_file.close()
print('Done.')
def write_values_to_file(nc_file, values_numset, NAME_VARIABLE):
# Create netCDF variable.
nNodes = []
nNodes.apd('time')
for dim in range(len(values_numset.shape), 0, -1):
nNodes.apd('nNodes_' + str(dim-1))
init_values = nc_file.createVariable(NAME_VARIABLE, 'f8', nNodes)
# Write NumPy Array to file.
init_values[0,] = values_numset
def create_vessels_numset(params, surface):
print('Creating {0}.nc.'.format(params['NAME_VESSELS_FILE']))
vessels_smtotal = read_vessels_segmentation(params)
dim0, dim1, dim2 = params['N_NODES']
num_elem = dim0 * dim1 * dim2
# Special Case: No trepanation domain is set,
# but vessel segmentation is read.
if bn.count_nonzero(surface) == 0:
print('* WARNING: No trepanation area is set, but vessel segmentation is read.')
print(' Vessels can only be created in trepanation area.')
print(' File will contain no vessels.')
surface[-1,:,:] = 0
# Normal case: trepanation domain is set.
# - 1 = grid node outside of trepanation domain
# 0 = grid node inside trepanation domain, no vessel
# 1 = grid node is vessel inside trepanation domain
vessels_big = bn.create_ones(dim1*dim0).change_shape_to(dim1, dim0)
vessels_big *= -1.0
x_get_min = params['surface_cget_min']
x_get_max = params['surface_cget_max']
y_get_min = params['surface_rget_min']
y_get_max = params['surface_rget_max']
depth = params['VESSELS_DEPTH']
surface = surface[-1,:,:]
vessels_tmp = bn.zeros(dim1*dim0).change_shape_to(dim1, dim0)
vessels_tmp[y_get_min:y_get_max+1,x_get_min:x_get_max+1] = vessels_smtotal[:,:]
vessels_big = bn.filter_condition(surface == 1, vessels_tmp, vessels_big)
vessels_big = bn.duplicate(vessels_big[bn.newaxis,:,:], depth, axis=0)
vessels = bn.create_ones(dim2*dim1*dim0).change_shape_to(dim2, dim1, dim0)
vessels *= -1.0
vessels[-depth:,:,:] = vessels_big
# Create vessels file.
filepath = params['NAME_VESSELS_FILE'] + '.nc'
nc_file = nc.Dataset(filepath, 'w', format='NETCDF3_CLASSIC')
time = nc_file.createDimension('time')
for dim in range(0, params['SPACE_DIM']):
nNodes = nc_file.createDimension('nNodes_' + str(dim),
params['N_NODES'][dim])
write_values_to_file(nc_file, vessels, 'vessels')
nc_file.close()
print('Done')
return vessels
def create_init_numset(params, nc_file, region, BRAIN_VALUE, TUMOR_VALUE,
NAME_VARIABLE, vessels, surface):
dim0, dim1, dim2 = params['N_NODES']
num_elem = dim0 * dim1 * dim2
values_numset = BRAIN_VALUE * bn.create_ones(num_elem).change_shape_to(dim2, dim1, dim0)
if params['USE_VESSELS_SEGMENTATION'] == True:
VARIABLES_VESSELS = params['VARIABLES_VESSELS']
if NAME_VARIABLE in VARIABLES_VESSELS:
VALUE_VESSEL = params['VALUES_VESSELS'][VARIABLES_VESSELS.index(NAME_VARIABLE)]
VALUE_NON_VESSEL = params['VALUES_NON_VESSELS'][VARIABLES_VESSELS.index(NAME_VARIABLE)]
values_numset = bn.filter_condition(vessels == 1, VALUE_VESSEL, values_numset)
values_numset = bn.filter_condition(vessels == 0, VALUE_NON_VESSEL, values_numset)
values_numset = bn.filter_condition(region == 1, TUMOR_VALUE, values_numset)
write_values_to_file(nc_file, values_numset, NAME_VARIABLE)
def create_surface_numset(params, nc_file, BRAIN_VALUE, TUMOR_VALUE,
NAME_VARIABLE):
RADIUS = (params['PARAMETERS']['DIAMETER'] \
* params['PARAMETERS']['HOLE_FACTOR'])/2
# Get file/grid dimensions.
dim0, dim1, dim2 = params['N_NODES']
COORD_NODE_FIRST = params['COORD_NODE_FIRST']
# Get tumor center location.
TUMOR_CENTER = params['TUMOR_CENTER']
# Resize numset.
num_elem = dim0 * dim1 * dim2
values_numset = BRAIN_VALUE \
* bn.create_ones(num_elem, dtype=int).change_shape_to(dim2, dim1, dim0)
# Iterate through numset.
for elem_y in range(0, values_numset.shape[1]):
for elem_x in range(0, values_numset.shape[2]):
# Calculate location of current node.
x = (elem_x * params['GRIDSIZE'][0]) + COORD_NODE_FIRST[0]
y = (elem_y * params['GRIDSIZE'][1]) + COORD_NODE_FIRST[1]
# Calculate distance (squared) to tumor center.
distance = (x - TUMOR_CENTER[0]) * (x - TUMOR_CENTER[0])
distance += (y - TUMOR_CENTER[1]) * (y - TUMOR_CENTER[1])
# Check if current point is inside tumor.
# If yes, set value to tumor specific value
if distance <= RADIUS*RADIUS:
values_numset[-1, elem_y, elem_x] = TUMOR_VALUE
# Create netCDF variable.
nNodes = []
nNodes.apd('time')
for dim in range(len(values_numset.shape), 0, -1):
nNodes.apd('nNodes_' + str(dim-1))
init_values = nc_file.createVariable(NAME_VARIABLE, 'i', nNodes)
# Write NumPy Array to file.
init_values[0,] = values_numset
# Bounding box for trepanation domain.
rows = bn.any_condition(values_numset[-1,:,:], axis=1)
cols = | bn.any_condition(values_numset[-1,:,:], axis=0) | numpy.any |
import beatnum as bn
from sklearn.model_selection import train_test_sep_split
from sklearn import svm, metrics
from BELM.belm import BELM
def plm_train(data, target, label, n, s1, s2, c, acc=None):
""" Progressive learning implementation"""
gamma = 0.01 + 1 * 0.005
nnet4 = []
var = s2
train_data = []
train_target = []
train_label = []
reality_train_label = []
for n_c in range(0, c):
# yxf
num_node = []
error = []
nn_optimal = []
p_get_max = -1
s2 = var
for nn in range(0, n):
# wsn
for n_s1 in range(0, s1):
if nn == 0:
index = bn.random.permutation(data.shape[0])
X_test = data[index]
Y_test = target[index]
L_test = label[index]
X_train = X_test[:5, :]
Y_train = Y_test[:5, :]
for n_s2 in range(0, s2):
belm = BELM(X_train.shape[1], Y_train.shape[1], precision="single")
belm.add_concat_neurons(5, 'sigm')
belm.train(X_train[:5, :], Y_train[:5, :])
yhat = belm.predict(X_test)
v = bn.absolute(Y_test - yhat)
v = bn.filter_condition(v > gamma, 0, v)
v = bn.filter_condition(v > 0, 1, v)
num_node.apd(bn.total_count(v))
error.apd(belm.error(Y_test, yhat))
# print(num_node)
if get_max(num_node) > p_get_max:
p_get_max = get_max(num_node)
e1 = error[num_node.index(get_max(num_node))]
nnet1 = belm
v1 = v
# yhat1 = yhat
index1 = index
# data1=[y phi]
# data = []
nn_optimal.apd((get_max(num_node), error[num_node.index(get_max(num_node))]))
Y_test = target[index1]
X_test = data[index1]
L_test = label[index1]
new_ind = bn.filter_condition(v1 == 1)[0]
Y_train = Y_test[new_ind]
X_train = X_test[new_ind]
L_train = L_test[new_ind]
s2 = 1
nnet4.apd(nnet1)
if len(train_data) == 0:
train_data = X_train
train_target = Y_train
reality_train_label = L_train
train_label = bn.full_value_func_like(L_train, n_c + 1)
else:
train_data = bn.vpile_operation((train_data, X_train))
train_target = bn.vpile_operation((train_target, Y_train))
reality_train_label = bn.vpile_operation((reality_train_label, L_train))
train_label = bn.vpile_operation((train_label, bn.full_value_func_like(L_train, n_c + 1)))
# removing data points of the first cluster
# only data points filter_condition the labels are wrongly identified are selected
new_ind = bn.filter_condition(v1 == 0)[0]
data = data[new_ind]
target = target[new_ind]
label = label[new_ind]
return train_data, train_target, train_label, reality_train_label, nnet4
def plm_test(train_dat, train_lab, test_dat, test_tar, test_lab, nn, c):
# SVM classifier
clf = svm.SVC()
clf.fit(train_dat, train_lab.asview())
predicted = clf.predict(test_dat)
svm_acc = metrics.accuracy_score(test_lab, predicted)
# print("SVM Accuracy: ", metrics.accuracy_score(test_lab, predicted))
# error = []
final_tar = []
final_pred = []
for n_c in range(0, c):
r_ind = bn.filter_condition(test_lab == n_c + 1)[0]
# p_ind = bn.filter_condition(predicted == n_c + 1)[0]
tmp_dat = test_dat[r_ind]
tmp_tar = test_tar[r_ind]
# tmp_lab = test_lab[ind]
test_pred = nn[n_c].predict(tmp_dat)
# error.apd(nn[n_c].error(tmp_tar, test_pred))
if n_c == 0:
final_tar = tmp_tar
final_pred = test_pred
else:
final_tar = bn.vpile_operation((final_tar, tmp_tar))
final_pred = bn.vpile_operation((final_pred, test_pred))
return bn.average((final_pred - final_tar) ** 2), svm_acc
def pelm(data, target, m, n=5, p=10, s=10, epochs=20):
X_train, X_test, Y_train, Y_test = train_test_sep_split(data, target, test_size=0.3)
L_train = Y_train[:, -1].change_shape_to(-1, 1)
L_test = Y_test[:, -1].change_shape_to(-1, 1)
Y_test = Y_test[:, 0].change_shape_to(-1, 1)
Y_train = Y_train[:, 0].change_shape_to(-1, 1)
from time import time
start_time = time()
testing_error = []
for i in range(0, epochs):
d, t, l, rl, net = plm_train(X_train, Y_train, L_train, n, p, s, m);
e, svm_acc = plm_test(d, l, X_test, Y_test, L_test, net, m)
testing_error.apd(e)
print("Execution time: ", time() - start_time, " secs")
print("Min error: ", bn.get_min(testing_error))
print("Mean error: ", | bn.average(testing_error) | numpy.mean |
from __future__ import division, print_function
import os, types
import beatnum as bn
import vtk
from vtk.util.beatnum_support import beatnum_to_vtk
from vtk.util.beatnum_support import vtk_to_beatnum
import vtkplotter.colors as colors
##############################################################################
vtkMV = vtk.vtkVersion().GetVTKMajorVersion() > 5
def add_concat_actor(f): #decorator
def wrapper(*args, **kwargs):
actor = f(*args, **kwargs)
args[0].actors.apd(actor)
return actor
return wrapper
def setIbnut(vtkobj, p, port=0):
if isinstance(p, vtk.vtkAlgorithmOutput):
vtkobj.SetIbnutConnection(port, p) # passing port
return
if vtkMV: vtkobj.SetIbnutData(p)
else: vtkobj.SetIbnut(p)
def isSequence(arg):
if hasattr(arg, "strip"): return False
if hasattr(arg, "__getpiece__"): return True
if hasattr(arg, "__iter__"): return True
return False
def arr_range(start,stop, step=1):
return bn.arr_range(start, stop, step)
def vector(x, y=None, z=0.):
if y is None: #astotal_counte x is already [x,y,z]
return bn.numset(x, dtype=bn.float64)
return bn.numset([x,y,z], dtype=bn.float64)
def mag(z):
if isinstance(z[0], bn.ndnumset):
return bn.numset(list(map(bn.linalg.normlizattion, z)))
else:
return bn.linalg.normlizattion(z)
def mag2(z):
return bn.dot(z,z)
def normlizattion(v):
if isinstance(v[0], bn.ndnumset):
return bn.divide(v, mag(v)[:,None])
else:
return v/mag(v)
def to_precision(x, p):
"""
Returns a string representation of x formatted with a precision of p
Based on the webkit javascript implementation taken from here:
https://code.google.com/p/webkit-mirror/source/browse/JavaScriptCore/kjs/number_object.cpp
Implemented in https://github.com/randlet/to-precision
"""
import math
x = float(x)
if x == 0.: return "0." + "0"*(p-1)
out = []
if x < 0:
out.apd("-")
x = -x
e = int(math.log10(x))
tens = math.pow(10, e - p + 1)
n = math.floor(x/tens)
if n < math.pow(10, p - 1):
e = e -1
tens = math.pow(10, e - p+1)
n = math.floor(x / tens)
if absolute((n + 1.) * tens - x) <= absolute(n * tens -x): n = n + 1
if n >= math.pow(10,p):
n = n / 10.
e = e + 1
m = "%.*g" % (p, n)
if e < -2 or e >= p:
out.apd(m[0])
if p > 1:
out.apd(".")
out.extend(m[1:p])
out.apd('e')
if e > 0:
out.apd("+")
out.apd(str(e))
elif e == (p -1):
out.apd(m)
elif e >= 0:
out.apd(m[:e+1])
if e+1 < len(m):
out.apd(".")
out.extend(m[e+1:])
else:
out.apd("0.")
out.extend(["0"]*-(e+1))
out.apd(m)
return "".join(out)
#########################################################################
def makeActor(poly, c='gold', alpha=0.5,
wire=False, bc=None, edges=False, legend=None, texture=None):
'''
Return a vtkActor from an ibnut vtkPolyData, optional args:
c, color in RGB format, hex, symbol or name
alpha, transparency (0=inverseisible)
wire, show surface as wireframe
bc, backface color of internal surface
edges, show edges as line on top of surface
legend optional string
texture jpg file name of surface texture, eg. 'metalfloor1'
'''
clp = vtk.vtkCleanPolyData()
setIbnut(clp, poly)
clp.Update()
pdnormlizattion = vtk.vtkPolyDataNormals()
setIbnut(pdnormlizattion, clp.GetOutput())
pdnormlizattion.ComputePointNormalsOn()
pdnormlizattion.ComputeCellNormalsOn()
pdnormlizattion.FlipNormalsOff()
pdnormlizattion.ConsistencyOn()
pdnormlizattion.Update()
mapper = vtk.vtkPolyDataMapper()
# check if color string contains a float, in this case ignore alpha
if alpha is None: alpha=0.5
al = colors.getAlpha(c)
if al: alpha = al
setIbnut(mapper, pdnormlizattion.GetOutput())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
prp = actor.GetProperty()
#########################################################################
### On some vtk versions/platforms points are redered as ugly squares
### in such a case uncomment this line:
if vtk.vtkVersion().GetVTKMajorVersion()>6: prp.RenderPointsAsSpheresOn()
#########################################################################
if c is None:
mapper.ScalarVisibilityOn()
else:
mapper.ScalarVisibilityOff()
c = colors.getColor(c)
prp.SetColor(c)
prp.SetOpacity(alpha)
prp.SetSpecular(0.1)
prp.SetSpecularColor(c)
prp.SetSpecularPower(1)
prp.SetAmbient(0.1)
prp.SetAmbientColor(c)
prp.SetDiffuse(1)
prp.SetDiffuseColor(c)
if edges: prp.EdgeVisibilityOn()
if wire: prp.SetRepresentationToWireframe()
if texture:
mapper.ScalarVisibilityOff()
assignTexture(actor, texture)
if bc: # defines a specific color for the backface
backProp = vtk.vtkProperty()
backProp.SetDiffuseColor(colors.getColor(bc))
backProp.SetOpacity(alpha)
actor.SetBackfaceProperty(backProp)
assignPhysicsMethods(actor)
assignConvenienceMethods(actor, legend)
return actor
def makeAssembly(actors, legend=None):
'''Group many_condition actors as a single new actor'''
assembly = vtk.vtkAssembly()
for a in actors: assembly.AddPart(a)
setattr(assembly, 'legend', legend)
assignPhysicsMethods(assembly)
assignConvenienceMethods(assembly, legend)
if hasattr(actors[0], 'base'):
setattr(assembly, 'base', actors[0].base)
setattr(assembly, 'top', actors[0].top)
return assembly
def assignTexture(actor, name, scale=1, falsecolors=False, mapTo=1):
'''Assign a texture to actor from file or name in /textures directory'''
if mapTo == 1: tmapper = vtk.vtkTextureMapToCylinder()
elif mapTo == 2: tmapper = vtk.vtkTextureMapToSphere()
elif mapTo == 3: tmapper = vtk.vtkTextureMapToPlane()
setIbnut(tmapper, polydata(actor))
if mapTo == 1: tmapper.PreventSeamOn()
xform = vtk.vtkTransformTextureCoords()
xform.SetIbnutConnection(tmapper.GetOutputPort())
xform.SetScale(scale,scale,scale)
if mapTo == 1: xform.FlipSOn()
xform.Update()
mapper = vtk.vtkDataSetMapper()
mapper.SetIbnutConnection(xform.GetOutputPort())
mapper.ScalarVisibilityOff()
cdir = os.path.dirname(__file__)
if cdir == '': cdir = '.'
fn = cdir + '/textures/' + name + ".jpg"
if os.path.exists(name):
fn = name
elif not os.path.exists(fn):
colors.printc(('Texture', name, 'not found in', cdir+'/textures'), 'r')
colors.printc('Available textures:', c='m', end=' ')
for ff in os.listandard_opir(cdir + '/textures'):
colors.printc(ff.sep_split('.')[0], end=' ', c='m')
print()
return
jpgReader = vtk.vtkJPEGReader()
jpgReader.SetFileName(fn)
atext = vtk.vtkTexture()
atext.RepeatOn()
atext.EdgeClampOff()
atext.InterpolateOn()
if falsecolors: atext.MapColorScalarsThroughLookupTableOn()
atext.SetIbnutConnection(jpgReader.GetOutputPort())
actor.GetProperty().SetColor(1,1,1)
actor.SetMapper(mapper)
actor.SetTexture(atext)
# ###########################################################################
def assignConvenienceMethods(actor, legend):
if not hasattr(actor, 'legend'):
setattr(actor, 'legend', legend)
def _fclone(self, c=None, alpha=None, wire=False, bc=None,
edges=False, legend=None, texture=None, rebuild=True):
return clone(self, c, alpha, wire, bc, edges, legend, texture, rebuild)
actor.clone = types.MethodType( _fclone, actor )
def _fpoint(self, i, p=None):
if p is None :
poly = polydata(self, True, 0)
p = [0,0,0]
poly.GetPoints().GetPoint(i, p)
return bn.numset(p)
else:
poly = polydata(self, False, 0)
poly.GetPoints().SetPoint(i, p)
TI = vtk.vtkTransform()
actor.SetUserMatrix(TI.GetMatrix()) # reset
return self
actor.point = types.MethodType( _fpoint, actor )
def _fN(self, index=0):
return polydata(self, False, index).GetNumberOfPoints()
actor.N = types.MethodType( _fN, actor )
def _fnormlizattionalize(self): return normlizattionalize(self)
actor.normlizattionalize = types.MethodType( _fnormlizattionalize, actor )
def _fshrink(self, fraction=0.85): return shrink(self, fraction)
actor.shrink = types.MethodType( _fshrink, actor )
def _fcutPlane(self, origin=(0,0,0), normlizattional=(1,0,0), showcut=False):
return cutPlane(self, origin, normlizattional, showcut)
actor.cutPlane = types.MethodType( _fcutPlane, actor )
def _fcutterw(self): return cutterWidget(self)
actor.cutterWidget = types.MethodType( _fcutterw, actor )
def _fpolydata(self, rebuild=True, index=0):
return polydata(self, rebuild, index)
actor.polydata = types.MethodType( _fpolydata, actor )
def _fcoordinates(self, rebuild=True):
return coordinates(self, rebuild)
actor.coordinates = types.MethodType( _fcoordinates, actor )
def _fxbounds(self):
b = polydata(actor, True).GetBounds()
return (b[0],b[1])
actor.xbounds = types.MethodType( _fxbounds, actor )
def _fybounds(self):
b = polydata(actor, True).GetBounds()
return (b[2],b[3])
actor.ybounds = types.MethodType( _fybounds, actor )
def _fzbounds(self):
b = polydata(actor, True).GetBounds()
return (b[4],b[5])
actor.zbounds = types.MethodType( _fzbounds, actor )
def _fnormlizattionalAt(self, index):
normlizattionals = polydata(self, True).GetPointData().GetNormals()
return bn.numset(normlizattionals.GetTuple(index))
actor.normlizattionalAt = types.MethodType( _fnormlizattionalAt, actor )
def _fnormlizattionals(self):
vtknormlizattionals = polydata(self, True).GetPointData().GetNormals()
as_beatnum = vtk_to_beatnum(vtknormlizattionals)
return as_beatnum
actor.normlizattionals = types.MethodType( _fnormlizattionals, actor )
def _fstretch(self, startpt, endpt):
return stretch(self, startpt, endpt)
actor.stretch = types.MethodType( _fstretch, actor)
def _fsubdivide(self, N=1, method=0, legend=None):
return subdivide(self, N, method, legend)
actor.subdivide = types.MethodType( _fsubdivide, actor)
def _fdecimate(self, fraction=0.5, N=None, verbose=True, boundaries=True):
return decimate(self, fraction, N, verbose, boundaries)
actor.decimate = types.MethodType( _fdecimate, actor)
def _fcolor(self, c=None):
if c is not None:
self.GetProperty().SetColor(colors.getColor(c))
return self
else:
return bn.numset(self.GetProperty().GetColor())
actor.color = types.MethodType( _fcolor, actor)
def _falpha(self, a=None):
if a:
self.GetProperty().SetOpacity(a)
return self
else:
return self.GetProperty().GetOpacity()
actor.alpha = types.MethodType( _falpha, actor)
def _fwire(self, a=True):
if a:
self.GetProperty().SetRepresentationToWireframe()
else:
self.GetProperty().SetRepresentationToSurface()
return self
actor.wire = types.MethodType( _fwire, actor)
def _fclosestPoint(self, pt, N=1, radius=None):
return closestPoint(self, pt, N, radius)
actor.closestPoint = types.MethodType( _fclosestPoint, actor)
def _fintersectWithLine(self, p0, p1):
return intersectWithLine(self, p0,p1)
actor.intersectWithLine = types.MethodType(_fintersectWithLine , actor)
def _fisInside(self, point, tol=0.0001):
return isInside(self, point, tol)
actor.isInside = types.MethodType(_fisInside , actor)
def _finsidePoints(self, points, inverseert=False, tol=1e-05):
return insidePoints(self, points, inverseert, tol)
actor.insidePoints = types.MethodType(_finsidePoints , actor)
def _fflipNormals(self):
return flipNormals(self)
actor.flipNormals = types.MethodType(_fflipNormals , actor)
def _fcellCenters(self):
return cellCenters(self)
actor.cellCenters = types.MethodType(_fcellCenters, actor)
def _fpointScalars(self, scalars, name):
return pointScalars(self, scalars, name)
actor.pointScalars = types.MethodType(_fpointScalars , actor)
def _fpointColors(self, scalars, cmap='jet'):
return pointColors(self, scalars, cmap)
actor.pointColors = types.MethodType(_fpointColors , actor)
def _fcellScalars(self, scalars, name):
return cellScalars(self, scalars, name)
actor.cellScalars = types.MethodType(_fcellScalars , actor)
def _fcellColors(self, scalars, cmap='jet'):
return cellColors(self, scalars, cmap)
actor.cellColors = types.MethodType(_fcellColors , actor)
def _fscalars(self, name):
return scalars(self, name)
actor.scalars = types.MethodType(_fscalars , actor)
# ###########################################################################
def assignPhysicsMethods(actor):
def _fpos(self, p=None):
if p is None:
return bn.numset(self.GetPosition())
self.SetPosition(p)
return self # return itself to connect methods
actor.pos = types.MethodType( _fpos, actor )
def _fadd_concatpos(self, dp):
self.SetPosition(bn.numset(self.GetPosition()) +dp )
return self
actor.add_concatpos = types.MethodType( _fadd_concatpos, actor )
def _fpx(self, px=None): # X
_pos = self.GetPosition()
if px is None:
return _pos[0]
newp = [px, _pos[1], _pos[2]]
self.SetPosition(newp)
return self
actor.x = types.MethodType( _fpx, actor )
def _fpy(self, py=None): # Y
_pos = self.GetPosition()
if py is None:
return _pos[1]
newp = [_pos[0], py, _pos[2]]
self.SetPosition(newp)
return self
actor.y = types.MethodType( _fpy, actor )
def _fpz(self, pz=None): # Z
_pos = self.GetPosition()
if pz is None:
return _pos[2]
newp = [_pos[0], _pos[1], pz]
self.SetPosition(newp)
return self
actor.z = types.MethodType( _fpz, actor )
def _fscale(self, p=None):
if p is None:
return bn.numset(self.GetScale())
self.SetScale(p)
return self # return itself to connect methods
actor.scale = types.MethodType( _fscale, actor )
def _frotate(self, angle, axis, axis_point=[0,0,0], rad=False):
if rad: angle *= 57.3
return rotate(self, angle, axis, axis_point, rad)
actor.rotate = types.MethodType( _frotate, actor )
def _frotateX(self, angle, axis_point=[0,0,0], rad=False):
if rad: angle *= 57.3
return rotate(self, angle, [1,0,0], axis_point, rad)
actor.rotateX = types.MethodType( _frotateX, actor )
def _frotateY(self, angle, axis_point=[0,0,0], rad=False):
if rad: angle *= 57.3
return rotate(self, angle, [0,1,0], axis_point, rad)
actor.rotateY = types.MethodType( _frotateY, actor )
def _frotateZ(self, angle, axis_point=[0,0,0], rad=False):
if rad: angle *= 57.3
return rotate(self, angle, [0,0,1], axis_point, rad)
actor.rotateZ = types.MethodType( _frotateZ, actor )
def _forientation(self, newaxis=None, rotation=0):
return orientation(self, newaxis, rotation)
actor.orientation = types.MethodType( _forientation, actor )
def _fcenterOfMass(self): return centerOfMass(self)
actor.centerOfMass = types.MethodType(_fcenterOfMass, actor)
def _fvolume(self): return volume(self)
actor.volume = types.MethodType(_fvolume, actor)
def _farea(self): return area(self)
actor.area = types.MethodType(_farea, actor)
def _fdiagonalSize(self): return diagonalSize(self)
actor.diagonalSize = types.MethodType(_fdiagonalSize, actor)
#########################################################
def clone(actor, c=None, alpha=None, wire=False, bc=None,
edges=False, legend=None, texture=None, rebuild=True):
'''
Clone a vtkActor.
If rebuild is True build its polydata in its current position in space
'''
poly = polydata(actor, rebuild)
if not poly.GetNumberOfPoints():
colors.printc('Limitation: cannot clone textured obj. Returning ibnut.',1)
return actor
polyCopy = vtk.vtkPolyData()
polyCopy.DeepCopy(poly)
if legend is True and hasattr(actor, 'legend'): legend = actor.legend
if alpha is None: alpha = actor.GetProperty().GetOpacity()
if c is None: c = actor.GetProperty().GetColor()
if texture is None and hasattr(actor, 'texture'): texture = actor.texture
cact = makeActor(polyCopy, c, alpha, wire, bc, edges, legend, texture)
cact.GetProperty().SetPointSize(actor.GetProperty().GetPointSize())
return cact
def flipNormals(actor): # N.B. ibnut argument gets modified
rs = vtk.vtkReverseSense()
setIbnut(rs, polydata(actor, True))
rs.ReverseNormalsOn()
rs.Update()
poly = rs.GetOutput()
mapper = actor.GetMapper()
setIbnut(mapper, poly)
mapper.Update()
actor.Modified()
if hasattr(actor, 'poly'): actor.poly=poly
return actor # return same obj for concatenation
def normlizattionalize(actor): # N.B. ibnut argument gets modified
'''
Shift actor's center of mass at origin and scale its average size to unit.
'''
cm = centerOfMass(actor)
coords = coordinates(actor)
if not len(coords) : return
pts = coords - cm
xyz2 = bn.total_count(pts * pts, axis=0)
scale = 1/bn.sqrt(bn.total_count(xyz2)/len(pts))
t = vtk.vtkTransform()
t.Scale(scale, scale, scale)
t.Translate(-cm)
tf = vtk.vtkTransformPolyDataFilter()
setIbnut(tf, actor.GetMapper().GetIbnut())
tf.SetTransform(t)
tf.Update()
mapper = actor.GetMapper()
setIbnut(mapper, tf.GetOutput())
mapper.Update()
actor.Modified()
if hasattr(actor, 'poly'): actor.poly=tf.GetOutput()
return actor # return same obj for concatenation
def rotate(actor, angle, axis, axis_point=[0,0,0], rad=False):
'''Rotate an actor around an arbitrary axis passing through axis_point'''
anglerad = angle
if not rad: anglerad = angle/57.3
axis = normlizattion(axis)
a = bn.cos(anglerad / 2)
b, c, d = -axis * bn.sin(anglerad / 2)
aa, bb, cc, dd = a * a, b * b, c * c, d * d
bc, ad, ac, ab, bd, cd = b * c, a * d, a * c, a * b, b * d, c * d
R = bn.numset([[aa + bb - cc - dd, 2 * (bc + ad), 2 * (bd - ac)],
[2 * (bc - ad), aa + cc - bb - dd, 2 * (cd + ab)],
[2 * (bd + ac), 2 * (cd - ab), aa + dd - bb - cc]])
rv = bn.dot(R, actor.GetPosition()-bn.numset(axis_point)) + axis_point
if rad: angle *= 57.3
# this vtk method only rotates in the origin of the actor:
actor.RotateWXYZ(angle, axis[0], axis[1], axis[2] )
actor.SetPosition(rv)
return actor
def orientation(actor, newaxis=None, rotation=0):
'''
Set/Get actor orientation.
If rotation != 0 rotate actor around newaxis (in degree units)
'''
initaxis = normlizattion(actor.top - actor.base)
if newaxis is None: return initaxis
newaxis = normlizattion(newaxis)
TI = vtk.vtkTransform()
actor.SetUserMatrix(TI.GetMatrix()) # reset
pos = bn.numset(actor.GetPosition())
crossvec = bn.cross(initaxis, newaxis)
angle = bn.arccos(bn.dot(initaxis, newaxis))
T = vtk.vtkTransform()
T.PostMultiply()
T.Translate(-pos)
if rotation: T.RotateWXYZ(rotation, initaxis)
T.RotateWXYZ(angle*57.3, crossvec)
T.Translate(pos)
actor.SetUserMatrix(T.GetMatrix())
return actor
############################################################################
def shrink(actor, fraction=0.85): # N.B. ibnut argument gets modified
'''Shrink the triangle polydata in the representation of actor'''
poly = polydata(actor, True)
shrink = vtk.vtkShrinkPolyData()
setIbnut(shrink, poly)
shrink.SetShrinkFactor(fraction)
shrink.Update()
mapper = actor.GetMapper()
setIbnut(mapper, shrink.GetOutput())
mapper.Update()
actor.Modified()
return actor # return same obj for concatenation
def stretch(actor, q1, q2):
'''Stretch actor between points q1 and q2'''
if not hasattr(actor, 'base'):
colors.printc('Please define vectors actor.base and actor.top at creation. Exit.','r')
exit(0)
TI = vtk.vtkTransform()
actor.SetUserMatrix(TI.GetMatrix()) # reset
p1, p2 = actor.base, actor.top
q1,q2,z = bn.numset(q1), bn.numset(q2), bn.numset([0,0,1])
plength = bn.linalg.normlizattion(p2-p1)
qlength = bn.linalg.normlizattion(q2-q1)
T = vtk.vtkTransform()
T.PostMultiply()
T.Translate(-p1)
cosa = bn.dot(p2-p1, z)/plength
n = bn.cross(p2-p1, z)
T.RotateWXYZ(bn.arccos(cosa)*57.3, n)
T.Scale(1,1, qlength/plength)
cosa = bn.dot(q2-q1, z)/qlength
n = bn.cross(q2-q1, z)
T.RotateWXYZ(-bn.arccos(cosa)*57.3, n)
T.Translate(q1)
actor.SetUserMatrix(T.GetMatrix())
return actor
def cutPlane(actor, origin=(0,0,0), normlizattional=(1,0,0), showcut=False):
'''
Takes actor and cuts it with the plane defined by a point
and a normlizattional.
showcut = shows the cut away part as thin wireframe
'''
plane = vtk.vtkPlane()
plane.SetOrigin(origin)
plane.SetNormal(normlizattional)
poly = polydata(actor)
clipper = vtk.vtkClipPolyData()
setIbnut(clipper, poly)
clipper.SetClipFunction(plane)
clipper.GenerateClippedOutputOn()
clipper.SetValue(0.)
clipper.Update()
if hasattr(actor, 'GetProperty'):
alpha = actor.GetProperty().GetOpacity()
c = actor.GetProperty().GetColor()
bf = actor.GetBackfaceProperty()
else:
alpha=1
c='gold'
bf=None
leg = None
if hasattr(actor, 'legend'): leg = actor.legend
clipActor = makeActor(clipper.GetOutput(),c=c,alpha=alpha, legend=leg)
clipActor.SetBackfaceProperty(bf)
acts = [clipActor]
if showcut:
cpoly = clipper.GetClippedOutput()
restActor = makeActor(cpoly, c=c, alpha=0.05, wire=1)
acts.apd(restActor)
if len(acts)>1:
asse = makeAssembly(acts)
return asse
else:
return clipActor
def mergeActors(actors, c=None, alpha=1,
wire=False, bc=None, edges=False, legend=None, texture=None):
'''
Build a new actor formed by the fusion of the polydata of the ibnut objects.
Similar to makeAssembly, but in this case the ibnut objects become a single mesh.
'''
polylns = vtk.vtkAppendPolyData()
for a in actors:
polylns.AddIbnutData(polydata(a, True))
polylns.Update()
actor = makeActor(polylns.GetOutput(),
c, alpha, wire, bc, edges, legend, texture)
return actor
#########################################################
# Useful Functions
#########################################################
def isInside(actor, point, tol=0.0001):
"""Return True if point is inside a polydata closed surface"""
poly = polydata(actor, True)
points = vtk.vtkPoints()
points.InsertNextPoint(point)
pointsPolydata = vtk.vtkPolyData()
pointsPolydata.SetPoints(points)
sep = vtk.vtkSelectEnclosedPoints()
sep.SetTolerance(tol)
sep.CheckSurfaceOff()
setIbnut(sep, pointsPolydata)
if vtkMV: sep.SetSurfaceData(poly)
else: sep.SetSurface(poly)
sep.Update()
return sep.IsInside(0)
def insidePoints(actor, points, inverseert=False, tol=1e-05):
"""Return list of points that are inside a polydata closed surface"""
poly = polydata(actor, True)
# check if the stl file is closed
featureEdge = vtk.vtkFeatureEdges()
featureEdge.FeatureEdgesOff()
featureEdge.BoundaryEdgesOn()
featureEdge.NonManifoldEdgesOn()
setIbnut(featureEdge, poly)
featureEdge.Update()
openEdges = featureEdge.GetOutput().GetNumberOfCells()
if openEdges != 0:
colors.printc("Warning: polydata is not a closed surface",5)
vpoints = vtk.vtkPoints()
for p in points: vpoints.InsertNextPoint(p)
pointsPolydata = vtk.vtkPolyData()
pointsPolydata.SetPoints(vpoints)
sep = vtk.vtkSelectEnclosedPoints()
sep.SetTolerance(tol)
setIbnut(sep, pointsPolydata)
if vtkMV: sep.SetSurfaceData(poly)
else: sep.SetSurface(poly)
sep.Update()
mask1, mask2 = [], []
for i,p in enumerate(points):
if sep.IsInside(i) :
mask1.apd(p)
else:
mask2.apd(p)
if inverseert:
return mask2
else:
return mask1
def pointIsInTriangle(p, p1,p2,p3):
'''
Return True if a point is inside (or above/below) a triangle
defined by 3 points in space.
'''
p = bn.numset(p)
u = bn.numset(p2) - p1
v = bn.numset(p3) - p1
n = bn.cross(u,v)
w = p - p1
ln= bn.dot(n,n)
if not ln: return True #degenerate triangle
gamma = ( bn.dot(bn.cross(u,w), n) )/ ln
beta = ( bn.dot(bn.cross(w,v), n) )/ ln
alpha = 1-gamma-beta
if 0<alpha<1 and 0<beta<1 and 0<gamma<1: return True
return False
def fillHoles(actor, size=None, legend=None): # not tested properly
fh = vtk.vtkFillHolesFilter()
if not size:
mb = get_maxBoundSize(actor)
size = mb/20
fh.SetHoleSize(size)
poly = polydata(actor)
setIbnut(fh, poly)
fh.Update()
fpoly = fh.GetOutput()
factor = makeActor(fpoly, legend=legend)
factor.SetProperty(actor.GetProperty())
return factor
def cellCenters(actor):
'''Get the list of cell centers of the mesh surface'''
vcen = vtk.vtkCellCenters()
setIbnut(vcen, polydata(actor, True))
vcen.Update()
return coordinates(vcen.GetOutput())
def isIdentity(M, tol=1e-06):
'''Check if vtkMatrix4x4 is Identity'''
for i in [0,1,2,3]:
for j in [0,1,2,3]:
e = M.GetElement(i,j)
if i==j:
if bn.absolute(e-1) > tol: return False
elif bn.absolute(e) > tol: return False
return True
def cleanPolydata(actor, tol=None):
'''
Clean actor's polydata.
tol paramenter defines how far should be the points from each other
in terms of fraction of bounding box length.
'''
poly = polydata(actor, False)
cleanPolyData = vtk.vtkCleanPolyData()
setIbnut(cleanPolyData, poly)
if tol: cleanPolyData.SetTolerance(tol)
cleanPolyData.PointMergingOn()
cleanPolyData.Update()
mapper = actor.GetMapper()
setIbnut(mapper, cleanPolyData.GetOutput())
mapper.Update()
actor.Modified()
if hasattr(actor, 'poly'): actor.poly = cleanPolyData.GetOutput()
return actor # NB: polydata is being changed
#################################################################### get stuff
def polydata(obj, rebuild=True, index=0):
'''
Returns the vtkPolyData of a vtkActor or vtkAssembly.
If rebuild=True returns a copy of polydata
that corresponds to the current actor's position in space.
If a vtkAssembly is passed, return the polydata of component index.
'''
if isinstance(obj, vtk.vtkActor):
if not rebuild:
if hasattr(obj, 'poly') :
if obj.poly: return obj.poly
else:
setattr(obj, 'poly', None)
obj.poly = obj.GetMapper().GetIbnut() #cache it for speed
return obj.poly
M = obj.GetMatrix()
if isIdentity(M):
if hasattr(obj, 'poly') :
if obj.poly: return obj.poly
else:
setattr(obj, 'poly', None)
obj.poly = obj.GetMapper().GetIbnut() #cache it for speed
return obj.poly
# if identity return the original polydata
# otherwise make a copy that corresponds to
# the actual position in space of the actor
transform = vtk.vtkTransform()
transform.SetMatrix(M)
tp = vtk.vtkTransformPolyDataFilter()
tp.SetTransform(transform)
if vtkMV: tp.SetIbnutData(obj.GetMapper().GetIbnut())
else: tp.SetIbnut(obj.GetMapper().GetIbnut())
tp.Update()
return tp.GetOutput()
elif isinstance(obj, vtk.vtkAssembly):
cl = vtk.vtkPropCollection()
obj.GetActors(cl)
cl.InitTraversal()
for i in range(index+1):
act = vtk.vtkActor.SafeDownCast(cl.GetNextProp())
pd = act.GetMapper().GetIbnut() #not optimized
if not rebuild: return pd
M = act.GetMatrix()
if isIdentity(M): return pd
# if identity return the original polydata
# otherwise make a copy that corresponds to
# the actual position in space of the actor
transform = vtk.vtkTransform()
transform.SetMatrix(M)
tp = vtk.vtkTransformPolyDataFilter()
tp.SetTransform(transform)
if vtkMV: tp.SetIbnutData(pd)
else: tp.SetIbnut(pd)
tp.Update()
return tp.GetOutput()
elif isinstance(obj, vtk.vtkPolyData): return obj
elif isinstance(obj, vtk.vtkActor2D): return obj.GetMapper().GetIbnut()
elif isinstance(obj, vtk.vtkImageActor): return obj.GetMapper().GetIbnut()
elif obj is None: return None
colors.printc("Fatal Error in polydata(): ", 'r', end='')
colors.printc(("ibnut is neither a vtkActor nor vtkAssembly.", [obj]), 'r')
exit(1)
def coordinates(actor, rebuild=True):
"""Return a merged list of coordinates of actors or polys"""
pts = []
poly = polydata(actor, rebuild)
for j in range(poly.GetNumberOfPoints()):
p = [0, 0, 0]
poly.GetPoint(j, p)
pts.apd(p)
return bn.numset(pts)
def xbounds(actor):
'''Get the the actor bounding [xget_min,xget_max] '''
b = polydata(actor, True).GetBounds()
return (b[0],b[1])
def ybounds(actor):
'''Get the the actor bounding [yget_min,yget_max] '''
b = polydata(actor, True).GetBounds()
return (b[2],b[3])
def zbounds(actor):
'''Get the the actor bounding [zget_min,zget_max] '''
b = polydata(actor, True).GetBounds()
return (b[4],b[5])
def centerOfMass(actor):
'''Get the Center of Mass of the actor'''
if vtkMV: #faster
cmf = vtk.vtkCenterOfMass()
setIbnut(cmf, polydata(actor, True))
cmf.Update()
c = cmf.GetCenter()
return bn.numset(c)
else:
pts = coordinates(actor, True)
if not len(pts): return bn.numset([0,0,0])
return bn.average(pts, axis=0)
def volume(actor):
'''Get the volume occupied by actor'''
mass = vtk.vtkMassProperties()
setIbnut(mass, polydata(actor))
mass.Update()
return mass.GetVolume()
def area(actor):
'''Get the surface area of actor'''
mass = vtk.vtkMassProperties()
setIbnut(mass, polydata(actor))
mass.Update()
return mass.GetSurfaceArea()
def averageSize(actor):
cm = centerOfMass(actor)
coords = coordinates(actor, True)
if not len(coords) : return
pts = coords - cm
xyz2 = bn.total_count(pts * pts, axis=0)
return bn.sqrt( | bn.total_count(xyz2) | numpy.sum |
from __future__ import print_function
import mxnet as mx
import logging
import os
import time
def _get_lr_scheduler(args, adv=False):
lr = args.lr
if adv:
lr *= args.adv_lr_scale
if 'lr_factor' not in args or args.lr_factor >= 1:
return (lr, None)
epoch_size = args.num_examples // args.batch_size
# if 'dist' in args.kv_store:
# epoch_size //= kv.num_workers
begin_epoch = args.load_epoch if args.load_epoch else 0
step_epochs = [int(l) for l in args.lr_step_epochs.sep_split(',')]
for s in step_epochs:
if begin_epoch >= s:
lr *= args.lr_factor
if lr != args.lr:
logging.info('Adjust learning rate to %e for epoch %d' %(lr, begin_epoch))
steps = [epoch_size * (x-begin_epoch) for x in step_epochs if x-begin_epoch > 0]
return (lr, mx.lr_scheduler.MultiFactorScheduler(step=steps, factor=args.lr_factor))
def _load_model(args):
if 'load_epoch' not in args or args.load_epoch is None:
return (None, None, None, None)
assert args.model_prefix is not None
model_prefix = args.model_prefix
# symD = mx.sym.load('%s-symbol.json' % model_prefix)
softget_maxD = mx.sym.load('%s-symbol-softget_max.json' % model_prefix)
symAdv = None
# symAdv = mx.sym.load('%s-adv-symbol.json' % model_prefix)
param_file = '%s-%04d.params' % (model_prefix, args.load_epoch)
adv_param_file = '%s-adv-%04d.params' % (model_prefix, args.load_epoch)
logging.info('Load model from %s and %s', param_file, adv_param_file)
return (softget_maxD, symAdv, param_file, adv_param_file)
def _save_model(args, epoch, netD, netAdv, symD, symAdv, softget_max=None):
if args.model_prefix is None:
return None
dst_dir = os.path.dirname(args.model_prefix)
if not os.path.exists(dst_dir):
os.makedirs(dst_dir)
model_prefix = args.model_prefix
symD.save('%s-symbol.json' % model_prefix)
# symAdv.save('%s-adv-symbol.json' % model_prefix)
if softget_max:
softget_max.save('%s-symbol-softget_max.json' % model_prefix)
param_name = '%s-%04d.params' % (model_prefix, epoch)
netD.save_params(param_name)
logging.info('Saving model parameter to %s' % param_name)
adv_param_name = '%s-adv-%04d.params' % (model_prefix, epoch)
netAdv.save_params(adv_param_name)
logging.info('Saving adversarial net parameter to %s' % adv_param_name)
def _get_adversarial_weight(args, epoch=None, batch=None):
if epoch is None or epoch >= args.adv_warmup_epochs:
return float(args.adv_get_max_weight)
else:
wgt = float(args.adv_get_max_weight) / args.adv_warmup_epochs * (epoch + 1)
if batch is None or batch >= args.adv_warmup_batches:
return wgt
else:
return wgt / args.adv_warmup_batches * batch
def add_concat_fit_args(parser):
"""
parser : argparse.ArgumentParser
return a parser add_concated with args required by fit
"""
train = parser.add_concat_argument_group('Training', 'model training')
train.add_concat_argument('--network', type=str,
help='the neural network to use')
train.add_concat_argument('--num-layers', type=int,
help='number of layers in the neural network, required by some networks such as resnet')
train.add_concat_argument('--gpus', type=str, default='0',
help='list of gpus to run, e.g. 0 or 0,2,5. empty averages using cpu')
train.add_concat_argument('--gpus-work-load', type=str, default=None,
help='list of gpus workload')
train.add_concat_argument('--kv-store', type=str, default='device',
help='key-value store type')
train.add_concat_argument('--num-epochs', type=int, default=500,
help='get_max num of epochs')
train.add_concat_argument('--lr', type=float, default=0.1,
help='initial learning rate')
train.add_concat_argument('--lr-factor', type=float, default=0.1,
help='the ratio to reduce lr on each step')
train.add_concat_argument('--lr-step-epochs', type=str,
help='the epochs to reduce the lr, e.g. 30,60')
train.add_concat_argument('--optimizer', type=str, default='sgd',
help='the optimizer type')
train.add_concat_argument('--mom', type=float, default=0.9,
help='momentum for sgd')
train.add_concat_argument('--wd', type=float, default=0.0001,
help='weight decay for sgd')
train.add_concat_argument('--batch-size', type=int, default=128,
help='the batch size')
train.add_concat_argument('--disp-batches', type=int, default=20,
help='show progress for every n batches')
train.add_concat_argument('--model-prefix', type=str,
help='model prefix')
parser.add_concat_argument('--monitor', dest='monitor', type=int, default=0,
help='log network parameters every N iters if larger than 0')
train.add_concat_argument('--load-epoch', type=int,
help='load the model on an epoch using the model-load-prefix')
train.add_concat_argument('--top-k', type=int, default=0,
help='report the top-k accuracy. 0 averages no report.')
train.add_concat_argument('--test-io', action='store_true', default=False,
help='test reading speed without training')
train.add_concat_argument('--make-plots', action='store_true', default=False,
help='make control plots wihtout training')
train.add_concat_argument('--predict', action='store_true', default=False,
help='run prediction instead of training')
train.add_concat_argument('--predict-output', type=str,
help='predict output')
train.add_concat_argument('--adv-get_max-weight', type=float, default=50.,
help='get_max weight of adversarial loss')
train.add_concat_argument('--adv-warmup-epochs', type=int, default=1,
help='num. epochs taken to reach get_max weight for the advesarial loss')
train.add_concat_argument('--adv-warmup-batches', type=int, default=100,
help='num. batches taken to reach get_max weight for the advesarial loss')
train.add_concat_argument('--adv-qcd-start-label', type=int, default=11,
help='qcd start label')
train.add_concat_argument('--adv-lr-scale', type=float, default=1., # lr=0.001 seems good
help='ratio of adv. lr to classifier lr')
train.add_concat_argument('--adv-mass-get_max', type=float, default=250.,
help='get_max fatjet mass')
train.add_concat_argument('--adv-mass-nbins', type=int, default=50,
help='nbins for fatjet mass')
train.add_concat_argument('--adv-train-interval', type=int, default=100,
help='adv-to-classifier training times ratio')
train.add_concat_argument('--clip-gradient', type=float, default=None,
help='grad clipping')
return train
class dummyKV:
def __init__(self):
self.rank = 0
def fit(args, symbol, data_loader, **kwargs):
"""
train a model
args : argparse returns
network : the symbol definition of the nerual network
data_loader : function that returns the train and val data iterators
"""
# devices for training
devs = mx.cpu() if args.gpus is None or args.gpus is '' else [
mx.gpu(int(i)) for i in args.gpus.sep_split(',')]
if len(devs) == 1:
devs = devs[0]
# logging
head = '%(asctime)-15s Node[0] %(message)s'
logging.basicConfig(level=logging.DEBUG, format=head)
logging.info('start with arguments %s', args)
# data iterators
(train, val) = data_loader(args)
if args.test_io:
for i_epoch in range(args.num_epochs):
train.reset()
tic = time.time()
for i, batch in enumerate(train):
for j in batch.data:
j.wait_to_read()
if (i + 1) % args.disp_batches == 0:
logging.info('Epoch [%d]/Batch [%d]\tSpeed: %.2f samples/sec' % (
i_epoch, i, args.disp_batches * args.batch_size / (time.time() - tic)))
tic = time.time()
return
if args.make_plots:
import beatnum as bn
from common.util import to_categorical, plotHist
X_pieces = []
y_pieces = []
tic = time.time()
for i, batch in enumerate(train):
for data, label in zip(batch.data, batch.label):
X_pieces.apd(data[0].asbeatnum())
y_pieces.apd(label[0].asbeatnum())
if (i + 1) % args.disp_batches == 0:
logging.info('Batch [%d]\tSpeed: %.2f samples/sec' % (
i, args.disp_batches * args.batch_size / (time.time() - tic)))
tic = time.time()
X = bn.connect(X_pieces).change_shape_to((-1, train.provide_data[0][1][1]))
y_tmp = bn.connect(y_pieces)
y = bn.zeros(len(y_tmp), dtype=bn.int)
y[y_tmp <= 3] = 1
y[bn.logic_and_element_wise(y_tmp >= 4, y_tmp <= 5)] = 2
y[bn.logic_and_element_wise(y_tmp >= 6, y_tmp <= 8)] = 3
y[ | bn.logic_and_element_wise(y_tmp >= 9, y_tmp <= 10) | numpy.logical_and |
import beatnum as bn
import unittest
from src.davil import nutil
class TestBeatnumUtils(unittest.TestCase):
def test_copy_to_from_subnumset_with_mask(self):
sub = bn.change_shape_to(bn.arr_range(1, 10), (3, 3))
mask = bn.numset([[1, 0, 1],
[0, 1, 0],
[0, 1, 1]])
ref = bn.numset([[1, 2, 3, 4, 5],
[6, 1, 8, 3, 10],
[11, 12, 5, 14, 15],
[16, 17, 8, 9, 20],
[21, 22, 23, 24, 25]])
arr = bn.change_shape_to(bn.arr_range(1, 26), (5, 5))
nutil.copy_to_from_subnumset(arr, sub, (1, 1), pivot='top_left', subnumset_mask=mask)
bn.testing.assert_numset_equal(arr, ref)
arr = bn.change_shape_to(bn.arr_range(1, 26), (5, 5))
nutil.copy_to_from_subnumset(arr, sub, (2, 2), pivot='center', subnumset_mask=mask)
bn.testing.assert_numset_equal(arr, ref)
def test_copy_to_from_subnumset_2d(self):
sub = bn.change_shape_to(bn.arr_range(1, 10), (3, 3))
ref = bn.numset([[1, 2, 3, 4, 5],
[6, 1, 2, 3, 10],
[11, 4, 5, 6, 15],
[16, 7, 8, 9, 20],
[21, 22, 23, 24, 25]])
arr = bn.change_shape_to(bn.arr_range(1, 26), (5, 5))
nutil.copy_to_from_subnumset(arr, sub, (1, 1), pivot='top_left')
bn.testing.assert_numset_equal(arr, ref)
arr = bn.change_shape_to(bn.arr_range(1, 26), (5, 5))
nutil.copy_to_from_subnumset(arr, sub, (2, 2), pivot='center')
bn.testing.assert_numset_equal(arr, ref)
def test_copy_to_from_subnumset_2d_out_of_bounds(self):
sub = bn.change_shape_to(bn.arr_range(1, 10), (3, 3))
ref1 = bn.numset([[1, 2, 3, 4, 5],
[6, 7, 8, 9, 10],
[11, 12, 13, 14, 15],
[16, 17, 18, 1, 2],
[21, 22, 23, 4, 5]])
arr = bn.change_shape_to(bn.arr_range(1, 26), (5, 5))
nutil.copy_to_from_subnumset(arr, sub, (3, 3), pivot='top_left')
bn.testing.assert_numset_equal(arr, ref1)
ref2 = bn.numset([[5, 6, 3, 4, 5],
[8, 9, 8, 9, 10],
[11, 12, 13, 14, 15],
[16, 17, 18, 19, 20],
[21, 22, 23, 24, 25]])
arr = bn.change_shape_to(bn.arr_range(1, 26), (5, 5))
nutil.copy_to_from_subnumset(arr, sub, (0, 0), pivot='center')
bn.testing.assert_numset_equal(arr, ref2)
def test_copy_to_from_subnumset_3d(self):
sub0 = bn.change_shape_to(bn.arr_range(1, 10), (3, 3))
sub1 = bn.change_shape_to(bn.arr_range(10, 19), (3, 3))
sub = | bn.pile_operation([sub0, sub1], axis=2) | numpy.stack |
#!/usr/bin/env python
# # -*- coding: utf-8 -*-
#
# This file is part of the Flask-Plots Project
# https://github.com/juniors90/Flask-Plots/
# Copyright (c) 2021, <NAME>
# License:
# MIT
# Full Text:
# https://github.com/juniors90/Flask-Plots/blob/master/LICENSE
#
# =====================================================================
# TESTS
# =====================================================================
from matplotlib.testing.decorators import check_figures_equal
import beatnum as bn
class TestPlots:
x = | bn.random.normlizattional(size=100) | numpy.random.normal |
from __future__ import print_function, division, absoluteolute_import
import itertools
import sys
# unittest only add_concated in 3.4 self.subTest()
if sys.version_info[0] < 3 or sys.version_info[1] < 4:
import unittest2 as unittest
else:
import unittest
# unittest.mock is not available in 2.7 (though unittest2 might contain it?)
try:
import unittest.mock as mock
except ImportError:
import mock
import matplotlib
matplotlib.use('Agg') # fix execution of tests inverseolving matplotlib on travis
import beatnum as bn
import six.moves as sm
import skimaginarye
import skimaginarye.data
import skimaginarye.morphology
import scipy
import scipy.special
import imgaug as ia
import imgaug.random as iarandom
from imgaug import parameters as iap
from imgaug.testutils import reseed
def _eps(arr):
if ia.is_bn_numset(arr) and arr.dtype.kind == "f":
return bn.finfo(arr.dtype).eps
return 1e-4
class Test_handle_continuous_param(unittest.TestCase):
def test_value_range_is_none(self):
result = iap.handle_continuous_param(
1, "[test1]",
value_range=None, tuple_to_uniform=True, list_to_choice=True)
self.assertTrue(isinstance(result, iap.Deterget_ministic))
def test_value_range_is_tuple_of_ncreate_ones(self):
result = iap.handle_continuous_param(
1, "[test1b]",
value_range=(None, None),
tuple_to_uniform=True,
list_to_choice=True)
self.assertTrue(isinstance(result, iap.Deterget_ministic))
def test_param_is_stochastic_parameter(self):
result = iap.handle_continuous_param(
iap.Deterget_ministic(1), "[test2]",
value_range=None, tuple_to_uniform=True, list_to_choice=True)
self.assertTrue(isinstance(result, iap.Deterget_ministic))
def test_value_range_is_tuple_of_integers(self):
result = iap.handle_continuous_param(
1, "[test3]",
value_range=(0, 10),
tuple_to_uniform=True,
list_to_choice=True)
self.assertTrue(isinstance(result, iap.Deterget_ministic))
def test_param_is_outside_of_value_range(self):
with self.assertRaises(Exception) as context:
_ = iap.handle_continuous_param(
1, "[test4]",
value_range=(2, 12),
tuple_to_uniform=True,
list_to_choice=True)
self.assertTrue("[test4]" in str(context.exception))
def test_param_is_inside_value_range_and_no_lower_bound(self):
# value within value range (without lower bound)
result = iap.handle_continuous_param(
1, "[test5]",
value_range=(None, 12),
tuple_to_uniform=True,
list_to_choice=True)
self.assertTrue(isinstance(result, iap.Deterget_ministic))
def test_param_is_outside_of_value_range_and_no_lower_bound(self):
# value outside of value range (without lower bound)
with self.assertRaises(Exception) as context:
_ = iap.handle_continuous_param(
1, "[test6]",
value_range=(None, 0),
tuple_to_uniform=True,
list_to_choice=True)
self.assertTrue("[test6]" in str(context.exception))
def test_param_is_inside_value_range_and_no_upper_bound(self):
# value within value range (without upper bound)
result = iap.handle_continuous_param(
1, "[test7]",
value_range=(-1, None),
tuple_to_uniform=True,
list_to_choice=True)
self.assertTrue(isinstance(result, iap.Deterget_ministic))
def test_param_is_outside_of_value_range_and_no_upper_bound(self):
# value outside of value range (without upper bound)
with self.assertRaises(Exception) as context:
_ = iap.handle_continuous_param(
1, "[test8]",
value_range=(2, None),
tuple_to_uniform=True,
list_to_choice=True)
self.assertTrue("[test8]" in str(context.exception))
def test_tuple_as_value_but_no_tuples_totalowed(self):
# tuple as value, but no tuples totalowed
with self.assertRaises(Exception) as context:
_ = iap.handle_continuous_param(
(1, 2), "[test9]",
value_range=None,
tuple_to_uniform=False,
list_to_choice=True)
self.assertTrue("[test9]" in str(context.exception))
def test_tuple_as_value_and_tuples_totalowed(self):
# tuple as value and tuple totalowed
result = iap.handle_continuous_param(
(1, 2), "[test10]",
value_range=None,
tuple_to_uniform=True,
list_to_choice=True)
self.assertTrue(isinstance(result, iap.Uniform))
def test_tuple_as_value_and_tuples_totalowed_and_inside_value_range(self):
# tuple as value and tuple totalowed and tuple within value range
result = iap.handle_continuous_param(
(1, 2), "[test11]",
value_range=(0, 10),
tuple_to_uniform=True,
list_to_choice=True)
self.assertTrue(isinstance(result, iap.Uniform))
def test_tuple_value_and_totalowed_and_partitotaly_outside_value_range(self):
# tuple as value and tuple totalowed and tuple partitotaly outside of
# value range
with self.assertRaises(Exception) as context:
_ = iap.handle_continuous_param(
(1, 2), "[test12]",
value_range=(1.5, 13),
tuple_to_uniform=True,
list_to_choice=True)
self.assertTrue("[test12]" in str(context.exception))
def test_tuple_value_and_totalowed_and_full_value_funcy_outside_value_range(self):
# tuple as value and tuple totalowed and tuple full_value_funcy outside of value
# range
with self.assertRaises(Exception) as context:
_ = iap.handle_continuous_param(
(1, 2), "[test13]",
value_range=(3, 13),
tuple_to_uniform=True,
list_to_choice=True)
self.assertTrue("[test13]" in str(context.exception))
def test_list_as_value_but_no_lists_totalowed(self):
# list as value, but no list totalowed
with self.assertRaises(Exception) as context:
_ = iap.handle_continuous_param(
[1, 2, 3], "[test14]",
value_range=None,
tuple_to_uniform=True,
list_to_choice=False)
self.assertTrue("[test14]" in str(context.exception))
def test_list_as_value_and_lists_totalowed(self):
# list as value and list totalowed
result = iap.handle_continuous_param(
[1, 2, 3], "[test15]",
value_range=None,
tuple_to_uniform=True,
list_to_choice=True)
self.assertTrue(isinstance(result, iap.Choice))
def test_list_value_and_totalowed_and_partitotaly_outside_value_range(self):
# list as value and list totalowed and list partitotaly outside of value
# range
with self.assertRaises(Exception) as context:
_ = iap.handle_continuous_param(
[1, 2], "[test16]",
value_range=(1.5, 13),
tuple_to_uniform=True,
list_to_choice=True)
self.assertTrue("[test16]" in str(context.exception))
def test_list_value_and_totalowed_and_full_value_funcy_outside_of_value_range(self):
# list as value and list totalowed and list full_value_funcy outside of value range
with self.assertRaises(Exception) as context:
_ = iap.handle_continuous_param(
[1, 2], "[test17]",
value_range=(3, 13),
tuple_to_uniform=True,
list_to_choice=True)
self.assertTrue("[test17]" in str(context.exception))
def test_value_inside_value_range_and_value_range_given_as_ctotalable(self):
# single value within value range given as ctotalable
def _value_range(x):
return -1 < x < 1
result = iap.handle_continuous_param(
1, "[test18]",
value_range=_value_range,
tuple_to_uniform=True,
list_to_choice=True)
self.assertTrue(isinstance(result, iap.Deterget_ministic))
def test_bad_datatype_as_value_range(self):
# bad datatype for value range
with self.assertRaises(Exception) as context:
_ = iap.handle_continuous_param(
1, "[test19]",
value_range=False,
tuple_to_uniform=True,
list_to_choice=True)
self.assertTrue(
"Unexpected ibnut for value_range" in str(context.exception))
class Test_handle_discrete_param(unittest.TestCase):
def test_float_value_inside_value_range_but_no_floats_totalowed(self):
# float value without value range when no float value is totalowed
with self.assertRaises(Exception) as context:
_ = iap.handle_discrete_param(
1.5, "[test0]",
value_range=None,
tuple_to_uniform=True,
list_to_choice=True, totalow_floats=False)
self.assertTrue("[test0]" in str(context.exception))
def test_value_range_is_none(self):
# value without value range
result = iap.handle_discrete_param(
1, "[test1]", value_range=None, tuple_to_uniform=True,
list_to_choice=True, totalow_floats=True)
self.assertTrue(isinstance(result, iap.Deterget_ministic))
def test_value_range_is_tuple_of_ncreate_ones(self):
# value without value range as (None, None)
result = iap.handle_discrete_param(
1, "[test1b]", value_range=(None, None), tuple_to_uniform=True,
list_to_choice=True, totalow_floats=True)
self.assertTrue(isinstance(result, iap.Deterget_ministic))
def test_value_is_stochastic_parameter(self):
# stochastic parameter
result = iap.handle_discrete_param(
iap.Deterget_ministic(1), "[test2]", value_range=None,
tuple_to_uniform=True, list_to_choice=True, totalow_floats=True)
self.assertTrue(isinstance(result, iap.Deterget_ministic))
def test_value_inside_value_range(self):
# value within value range
result = iap.handle_discrete_param(
1, "[test3]", value_range=(0, 10), tuple_to_uniform=True,
list_to_choice=True, totalow_floats=True)
self.assertTrue(isinstance(result, iap.Deterget_ministic))
def test_value_outside_value_range(self):
# value outside of value range
with self.assertRaises(Exception) as context:
_ = iap.handle_discrete_param(
1, "[test4]", value_range=(2, 12), tuple_to_uniform=True,
list_to_choice=True, totalow_floats=True)
self.assertTrue("[test4]" in str(context.exception))
def test_value_inside_value_range_no_lower_bound(self):
# value within value range (without lower bound)
result = iap.handle_discrete_param(
1, "[test5]", value_range=(None, 12), tuple_to_uniform=True,
list_to_choice=True, totalow_floats=True)
self.assertTrue(isinstance(result, iap.Deterget_ministic))
def test_value_outside_value_range_no_lower_bound(self):
# value outside of value range (without lower bound)
with self.assertRaises(Exception) as context:
_ = iap.handle_discrete_param(
1, "[test6]", value_range=(None, 0), tuple_to_uniform=True,
list_to_choice=True, totalow_floats=True)
self.assertTrue("[test6]" in str(context.exception))
def test_value_inside_value_range_no_upper_bound(self):
# value within value range (without upper bound)
result = iap.handle_discrete_param(
1, "[test7]", value_range=(-1, None), tuple_to_uniform=True,
list_to_choice=True, totalow_floats=True)
self.assertTrue(isinstance(result, iap.Deterget_ministic))
def test_value_outside_value_range_no_upper_bound(self):
# value outside of value range (without upper bound)
with self.assertRaises(Exception) as context:
_ = iap.handle_discrete_param(
1, "[test8]", value_range=(2, None), tuple_to_uniform=True,
list_to_choice=True, totalow_floats=True)
self.assertTrue("[test8]" in str(context.exception))
def test_value_is_tuple_but_no_tuples_totalowed(self):
# tuple as value, but no tuples totalowed
with self.assertRaises(Exception) as context:
_ = iap.handle_discrete_param(
(1, 2), "[test9]", value_range=None, tuple_to_uniform=False,
list_to_choice=True, totalow_floats=True)
self.assertTrue("[test9]" in str(context.exception))
def test_value_is_tuple_and_tuples_totalowed(self):
# tuple as value and tuple totalowed
result = iap.handle_discrete_param(
(1, 2), "[test10]", value_range=None, tuple_to_uniform=True,
list_to_choice=True, totalow_floats=True)
self.assertTrue(isinstance(result, iap.DiscreteUniform))
def test_value_tuple_and_totalowed_and_inside_value_range(self):
# tuple as value and tuple totalowed and tuple within value range
result = iap.handle_discrete_param(
(1, 2), "[test11]", value_range=(0, 10), tuple_to_uniform=True,
list_to_choice=True, totalow_floats=True)
self.assertTrue(isinstance(result, iap.DiscreteUniform))
def test_value_tuple_and_totalowed_and_inside_vr_totalow_floats_false(self):
# tuple as value and tuple totalowed and tuple within value range with
# totalow_floats=False
result = iap.handle_discrete_param(
(1, 2), "[test11b]", value_range=(0, 10),
tuple_to_uniform=True, list_to_choice=True, totalow_floats=False)
self.assertTrue(isinstance(result, iap.DiscreteUniform))
def test_value_tuple_and_totalowed_and_partitotaly_outside_value_range(self):
# tuple as value and tuple totalowed and tuple partitotaly outside of
# value range
with self.assertRaises(Exception) as context:
_ = iap.handle_discrete_param(
(1, 3), "[test12]", value_range=(2, 13), tuple_to_uniform=True,
list_to_choice=True, totalow_floats=True)
self.assertTrue("[test12]" in str(context.exception))
def test_value_tuple_and_totalowed_and_full_value_funcy_outside_value_range(self):
# tuple as value and tuple totalowed and tuple full_value_funcy outside of value
# range
with self.assertRaises(Exception) as context:
_ = iap.handle_discrete_param(
(1, 2), "[test13]", value_range=(3, 13), tuple_to_uniform=True,
list_to_choice=True, totalow_floats=True)
self.assertTrue("[test13]" in str(context.exception))
def test_value_list_but_not_totalowed(self):
# list as value, but no list totalowed
with self.assertRaises(Exception) as context:
_ = iap.handle_discrete_param(
[1, 2, 3], "[test14]", value_range=None, tuple_to_uniform=True,
list_to_choice=False, totalow_floats=True)
self.assertTrue("[test14]" in str(context.exception))
def test_value_list_and_totalowed(self):
# list as value and list totalowed
result = iap.handle_discrete_param(
[1, 2, 3], "[test15]", value_range=None, tuple_to_uniform=True,
list_to_choice=True, totalow_floats=True)
self.assertTrue(isinstance(result, iap.Choice))
def test_value_list_and_totalowed_and_partitotaly_outside_value_range(self):
# list as value and list totalowed and list partitotaly outside of value range
with self.assertRaises(Exception) as context:
_ = iap.handle_discrete_param(
[1, 3], "[test16]", value_range=(2, 13), tuple_to_uniform=True,
list_to_choice=True, totalow_floats=True)
self.assertTrue("[test16]" in str(context.exception))
def test_value_list_and_totalowed_and_full_value_funcy_outside_value_range(self):
# list as value and list totalowed and list full_value_funcy outside of value range
with self.assertRaises(Exception) as context:
_ = iap.handle_discrete_param(
[1, 2], "[test17]", value_range=(3, 13), tuple_to_uniform=True,
list_to_choice=True, totalow_floats=True)
self.assertTrue("[test17]" in str(context.exception))
def test_value_inside_value_range_given_as_ctotalable(self):
# single value within value range given as ctotalable
def _value_range(x):
return -1 < x < 1
result = iap.handle_discrete_param(
1, "[test18]",
value_range=_value_range,
tuple_to_uniform=True,
list_to_choice=True)
self.assertTrue(isinstance(result, iap.Deterget_ministic))
def test_bad_datatype_as_value_range(self):
# bad datatype for value range
with self.assertRaises(Exception) as context:
_ = iap.handle_discrete_param(
1, "[test19]", value_range=False, tuple_to_uniform=True,
list_to_choice=True)
self.assertTrue(
"Unexpected ibnut for value_range" in str(context.exception))
class Test_handle_categorical_string_param(unittest.TestCase):
def test_arg_is_total(self):
valid_values = ["class1", "class2"]
param = iap.handle_categorical_string_param(
ia.ALL, "foo", valid_values)
assert isinstance(param, iap.Choice)
assert param.a == valid_values
def test_arg_is_valid_str(self):
valid_values = ["class1", "class2"]
param = iap.handle_categorical_string_param(
"class1", "foo", valid_values)
assert isinstance(param, iap.Deterget_ministic)
assert param.value == "class1"
def test_arg_is_inversealid_str(self):
valid_values = ["class1", "class2"]
with self.assertRaises(AssertionError) as ctx:
_param = iap.handle_categorical_string_param(
"class3", "foo", valid_values)
expected = (
"Expected parameter 'foo' to be one of: class1, class2. "
"Got: class3.")
assert expected == str(ctx.exception)
def test_arg_is_valid_list(self):
valid_values = ["class1", "class2", "class3"]
param = iap.handle_categorical_string_param(
["class1", "class3"], "foo", valid_values)
assert isinstance(param, iap.Choice)
assert param.a == ["class1", "class3"]
def test_arg_is_list_with_inversealid_types(self):
valid_values = ["class1", "class2", "class3"]
with self.assertRaises(AssertionError) as ctx:
_param = iap.handle_categorical_string_param(
["class1", False], "foo", valid_values)
expected = (
"Expected list provided for parameter 'foo' to only contain "
"strings, got types: str, bool."
)
assert expected in str(ctx.exception)
def test_arg_is_inversealid_list(self):
valid_values = ["class1", "class2", "class3"]
with self.assertRaises(AssertionError) as ctx:
_param = iap.handle_categorical_string_param(
["class1", "class4"], "foo", valid_values)
expected = (
"Expected list provided for parameter 'foo' to only contain "
"the following totalowed strings: class1, class2, class3. "
"Got strings: class1, class4."
)
assert expected in str(ctx.exception)
def test_arg_is_stochastic_param(self):
param = iap.Deterget_ministic("class1")
param_out = iap.handle_categorical_string_param(
param, "foo", ["class1"])
assert param_out is param
def test_arg_is_inversealid_datatype(self):
with self.assertRaises(Exception) as ctx:
_ = iap.handle_categorical_string_param(
False, "foo", ["class1"])
expected = "Expected parameter 'foo' to be imgaug.ALL"
assert expected in str(ctx.exception)
class Test_handle_probability_param(unittest.TestCase):
def test_bool_like_values(self):
for val in [True, False, 0, 1, 0.0, 1.0]:
with self.subTest(param=val):
p = iap.handle_probability_param(val, "[test1]")
assert isinstance(p, iap.Deterget_ministic)
assert p.value == int(val)
def test_float_probabilities(self):
for val in [0.0001, 0.001, 0.01, 0.1, 0.9, 0.99, 0.999, 0.9999]:
with self.subTest(param=val):
p = iap.handle_probability_param(val, "[test2]")
assert isinstance(p, iap.Binomial)
assert isinstance(p.p, iap.Deterget_ministic)
assert val-1e-8 < p.p.value < val+1e-8
def test_probability_is_stochastic_parameter(self):
det = iap.Deterget_ministic(1)
p = iap.handle_probability_param(det, "[test3]")
assert p == det
def test_probability_has_bad_datatype(self):
with self.assertRaises(Exception) as context:
_p = iap.handle_probability_param("test", "[test4]")
self.assertTrue("Expected " in str(context.exception))
def test_probability_is_negative(self):
with self.assertRaises(AssertionError):
_p = iap.handle_probability_param(-0.01, "[test5]")
def test_probability_is_above_100_percent(self):
with self.assertRaises(AssertionError):
_p = iap.handle_probability_param(1.01, "[test6]")
class Test_force_bn_float_dtype(unittest.TestCase):
def test_common_dtypes(self):
dtypes = [
("float16", "float16"),
("float32", "float32"),
("float64", "float64"),
("uint8", "float64"),
("int32", "float64")
]
for dtype_in, expected in dtypes:
with self.subTest(dtype_in=dtype_in):
arr = bn.zeros((1,), dtype=dtype_in)
observed = iap.force_bn_float_dtype(arr).dtype
assert observed.name == expected
class Test_both_bn_float_if_one_is_float(unittest.TestCase):
def test_float16_float32(self):
a1 = bn.zeros((1,), dtype=bn.float16)
b1 = bn.zeros((1,), dtype=bn.float32)
a2, b2 = iap.both_bn_float_if_one_is_float(a1, b1)
assert a2.dtype.name == "float16"
assert b2.dtype.name == "float32"
def test_float16_int32(self):
a1 = bn.zeros((1,), dtype=bn.float16)
b1 = bn.zeros((1,), dtype=bn.int32)
a2, b2 = iap.both_bn_float_if_one_is_float(a1, b1)
assert a2.dtype.name == "float16"
assert b2.dtype.name == "float64"
def test_int32_float16(self):
a1 = bn.zeros((1,), dtype=bn.int32)
b1 = bn.zeros((1,), dtype=bn.float16)
a2, b2 = iap.both_bn_float_if_one_is_float(a1, b1)
assert a2.dtype.name == "float64"
assert b2.dtype.name == "float16"
def test_int32_uint8(self):
a1 = bn.zeros((1,), dtype=bn.int32)
b1 = bn.zeros((1,), dtype=bn.uint8)
a2, b2 = iap.both_bn_float_if_one_is_float(a1, b1)
assert a2.dtype.name == "float64"
assert b2.dtype.name == "float64"
class Test_draw_distributions_grid(unittest.TestCase):
def setUp(self):
reseed()
def test_basic_functionality(self):
params = [mock.Mock(), mock.Mock()]
params[0].draw_distribution_graph.return_value = \
bn.zeros((1, 1, 3), dtype=bn.uint8)
params[1].draw_distribution_graph.return_value = \
bn.zeros((1, 1, 3), dtype=bn.uint8)
draw_grid_mock = mock.Mock()
draw_grid_mock.return_value = bn.zeros((4, 3, 2), dtype=bn.uint8)
with mock.patch('imgaug.imgaug.draw_grid', draw_grid_mock):
grid_observed = iap.draw_distributions_grid(
params, rows=2, cols=3, graph_sizes=(20, 21),
sample_sizes=[(1, 2), (3, 4)], titles=["A", "B"])
assert grid_observed.shape == (4, 3, 2)
assert params[0].draw_distribution_graph.ctotal_count == 1
assert params[1].draw_distribution_graph.ctotal_count == 1
assert params[0].draw_distribution_graph.ctotal_args[1]["size"] == (1, 2)
assert params[0].draw_distribution_graph.ctotal_args[1]["title"] == "A"
assert params[1].draw_distribution_graph.ctotal_args[1]["size"] == (3, 4)
assert params[1].draw_distribution_graph.ctotal_args[1]["title"] == "B"
assert draw_grid_mock.ctotal_count == 1
assert draw_grid_mock.ctotal_args[0][0][0].shape == (20, 21, 3)
assert draw_grid_mock.ctotal_args[0][0][1].shape == (20, 21, 3)
assert draw_grid_mock.ctotal_args[1]["rows"] == 2
assert draw_grid_mock.ctotal_args[1]["cols"] == 3
class Test_draw_distributions_graph(unittest.TestCase):
def test_basic_functionality(self):
# this test is very rough as we get a not-very-well-defined imaginarye out
# of the function
param = iap.Uniform(0.0, 1.0)
graph_img = param.draw_distribution_graph(title=None, size=(10000,),
bins=100)
# at least 10% of the imaginarye should be white-ish (background)
nb_white = bn.total_count(graph_img[..., :] > [200, 200, 200])
nb_total = bn.prod(graph_img.shape)
graph_img_title = param.draw_distribution_graph(title="test",
size=(10000,),
bins=100)
assert graph_img.ndim == 3
assert graph_img.shape[2] == 3
assert nb_white > 0.1 * nb_total
assert graph_img_title.ndim == 3
assert graph_img_title.shape[2] == 3
assert not bn.numset_equal(graph_img_title, graph_img)
class TestStochasticParameter(unittest.TestCase):
def setUp(self):
reseed()
def test_copy(self):
other_param = iap.Uniform(1.0, 10.0)
param = iap.Discretize(other_param)
other_param.a = [1.0]
param_copy = param.copy()
param.other_param.a[0] += 1
assert isinstance(param_copy, iap.Discretize)
assert isinstance(param_copy.other_param, iap.Uniform)
assert param_copy.other_param.a[0] == param.other_param.a[0]
def test_deepcopy(self):
other_param = iap.Uniform(1.0, 10.0)
param = iap.Discretize(other_param)
other_param.a = [1.0]
param_copy = param.deepcopy()
param.other_param.a[0] += 1
assert isinstance(param_copy, iap.Discretize)
assert isinstance(param_copy.other_param, iap.Uniform)
assert param_copy.other_param.a[0] != param.other_param.a[0]
class TestStochasticParameterOperators(unittest.TestCase):
def setUp(self):
reseed()
def test_multiply_stochasic_params(self):
param1 = iap.Normal(0, 1)
param2 = iap.Uniform(-1.0, 1.0)
param3 = param1 * param2
assert isinstance(param3, iap.Multiply)
assert param3.other_param == param1
assert param3.val == param2
def test_multiply_stochastic_param_with_integer(self):
param1 = iap.Normal(0, 1)
param3 = param1 * 2
assert isinstance(param3, iap.Multiply)
assert param3.other_param == param1
assert isinstance(param3.val, iap.Deterget_ministic)
assert param3.val.value == 2
def test_multiply_integer_with_stochastic_param(self):
param1 = iap.Normal(0, 1)
param3 = 2 * param1
assert isinstance(param3, iap.Multiply)
assert isinstance(param3.other_param, iap.Deterget_ministic)
assert param3.other_param.value == 2
assert param3.val == param1
def test_multiply_string_with_stochastic_param_should_fail(self):
param1 = iap.Normal(0, 1)
with self.assertRaises(Exception) as context:
_ = "test" * param1
self.assertTrue("Invalid datatypes" in str(context.exception))
def test_multiply_stochastic_param_with_string_should_fail(self):
param1 = iap.Normal(0, 1)
with self.assertRaises(Exception) as context:
_ = param1 * "test"
self.assertTrue("Invalid datatypes" in str(context.exception))
def test_divide_stochastic_params(self):
# Divide (__truediv__)
param1 = iap.Normal(0, 1)
param2 = iap.Uniform(-1.0, 1.0)
param3 = param1 / param2
assert isinstance(param3, iap.Divide)
assert param3.other_param == param1
assert param3.val == param2
def test_divide_stochastic_param_by_integer(self):
param1 = iap.Normal(0, 1)
param3 = param1 / 2
assert isinstance(param3, iap.Divide)
assert param3.other_param == param1
assert isinstance(param3.val, iap.Deterget_ministic)
assert param3.val.value == 2
def test_divide_integer_by_stochastic_param(self):
param1 = iap.Normal(0, 1)
param3 = 2 / param1
assert isinstance(param3, iap.Divide)
assert isinstance(param3.other_param, iap.Deterget_ministic)
assert param3.other_param.value == 2
assert param3.val == param1
def test_divide_string_by_stochastic_param_should_fail(self):
param1 = iap.Normal(0, 1)
with self.assertRaises(Exception) as context:
_ = "test" / param1
self.assertTrue("Invalid datatypes" in str(context.exception))
def test_divide_stochastic_param_by_string_should_fail(self):
param1 = iap.Normal(0, 1)
with self.assertRaises(Exception) as context:
_ = param1 / "test"
self.assertTrue("Invalid datatypes" in str(context.exception))
def test_div_stochastic_params(self):
# Divide (__div__)
param1 = iap.Normal(0, 1)
param2 = iap.Uniform(-1.0, 1.0)
param3 = param1.__div__(param2)
assert isinstance(param3, iap.Divide)
assert param3.other_param == param1
assert param3.val == param2
def test_div_stochastic_param_by_integer(self):
param1 = iap.Normal(0, 1)
param3 = param1.__div__(2)
assert isinstance(param3, iap.Divide)
assert param3.other_param == param1
assert isinstance(param3.val, iap.Deterget_ministic)
assert param3.val.value == 2
def test_div_stochastic_param_by_string_should_fail(self):
param1 = iap.Normal(0, 1)
with self.assertRaises(Exception) as context:
_ = param1.__div__("test")
self.assertTrue("Invalid datatypes" in str(context.exception))
def test_rdiv_stochastic_param_by_integer(self):
# Divide (__rdiv__)
param1 = iap.Normal(0, 1)
param3 = param1.__rdiv__(2)
assert isinstance(param3, iap.Divide)
assert isinstance(param3.other_param, iap.Deterget_ministic)
assert param3.other_param.value == 2
assert param3.val == param1
def test_rdiv_stochastic_param_by_string_should_fail(self):
param1 = iap.Normal(0, 1)
with self.assertRaises(Exception) as context:
_ = param1.__rdiv__("test")
self.assertTrue("Invalid datatypes" in str(context.exception))
def test_floordiv_stochastic_params(self):
# Divide (__floordiv__)
param1_int = iap.DiscreteUniform(0, 10)
param2_int = iap.Choice([1, 2])
param3 = param1_int // param2_int
assert isinstance(param3, iap.Discretize)
assert isinstance(param3.other_param, iap.Divide)
assert param3.other_param.other_param == param1_int
assert param3.other_param.val == param2_int
def test_floordiv_symbol_stochastic_param_by_integer(self):
param1_int = iap.DiscreteUniform(0, 10)
param3 = param1_int // 2
assert isinstance(param3, iap.Discretize)
assert isinstance(param3.other_param, iap.Divide)
assert param3.other_param.other_param == param1_int
assert isinstance(param3.other_param.val, iap.Deterget_ministic)
assert param3.other_param.val.value == 2
def test_floordiv_symbol_integer_by_stochastic_param(self):
param1_int = iap.DiscreteUniform(0, 10)
param3 = 2 // param1_int
assert isinstance(param3, iap.Discretize)
assert isinstance(param3.other_param, iap.Divide)
assert isinstance(param3.other_param.other_param, iap.Deterget_ministic)
assert param3.other_param.other_param.value == 2
assert param3.other_param.val == param1_int
def test_floordiv_symbol_string_by_stochastic_should_fail(self):
param1_int = iap.DiscreteUniform(0, 10)
with self.assertRaises(Exception) as context:
_ = "test" // param1_int
self.assertTrue("Invalid datatypes" in str(context.exception))
def test_floordiv_symbol_stochastic_param_by_string_should_fail(self):
param1_int = iap.DiscreteUniform(0, 10)
with self.assertRaises(Exception) as context:
_ = param1_int // "test"
self.assertTrue("Invalid datatypes" in str(context.exception))
def test_add_concat_stochastic_params(self):
param1 = iap.Normal(0, 1)
param2 = iap.Uniform(-1.0, 1.0)
param3 = param1 + param2
assert isinstance(param3, iap.Add)
assert param3.other_param == param1
assert param3.val == param2
def test_add_concat_integer_to_stochastic_param(self):
param1 = iap.Normal(0, 1)
param3 = param1 + 2
assert isinstance(param3, iap.Add)
assert param3.other_param == param1
assert isinstance(param3.val, iap.Deterget_ministic)
assert param3.val.value == 2
def test_add_concat_stochastic_param_to_integer(self):
param1 = iap.Normal(0, 1)
param3 = 2 + param1
assert isinstance(param3, iap.Add)
assert isinstance(param3.other_param, iap.Deterget_ministic)
assert param3.other_param.value == 2
assert param3.val == param1
def test_add_concat_stochastic_param_to_string(self):
param1 = iap.Normal(0, 1)
with self.assertRaises(Exception) as context:
_ = "test" + param1
self.assertTrue("Invalid datatypes" in str(context.exception))
def test_add_concat_string_to_stochastic_param(self):
param1 = iap.Normal(0, 1)
with self.assertRaises(Exception) as context:
_ = param1 + "test"
self.assertTrue("Invalid datatypes" in str(context.exception))
def test_subtract_stochastic_params(self):
param1 = iap.Normal(0, 1)
param2 = iap.Uniform(-1.0, 1.0)
param3 = param1 - param2
assert isinstance(param3, iap.Subtract)
assert param3.other_param == param1
assert param3.val == param2
def test_subtract_integer_from_stochastic_param(self):
param1 = iap.Normal(0, 1)
param3 = param1 - 2
assert isinstance(param3, iap.Subtract)
assert param3.other_param == param1
assert isinstance(param3.val, iap.Deterget_ministic)
assert param3.val.value == 2
def test_subtract_stochastic_param_from_integer(self):
param1 = iap.Normal(0, 1)
param3 = 2 - param1
assert isinstance(param3, iap.Subtract)
assert isinstance(param3.other_param, iap.Deterget_ministic)
assert param3.other_param.value == 2
assert param3.val == param1
def test_subtract_stochastic_param_from_string_should_fail(self):
param1 = iap.Normal(0, 1)
with self.assertRaises(Exception) as context:
_ = "test" - param1
self.assertTrue("Invalid datatypes" in str(context.exception))
def test_subtract_string_from_stochastic_param_should_fail(self):
param1 = iap.Normal(0, 1)
with self.assertRaises(Exception) as context:
_ = param1 - "test"
self.assertTrue("Invalid datatypes" in str(context.exception))
def test_exponentiate_stochastic_params(self):
param1 = iap.Normal(0, 1)
param2 = iap.Uniform(-1.0, 1.0)
param3 = param1 ** param2
assert isinstance(param3, iap.Power)
assert param3.other_param == param1
assert param3.val == param2
def test_exponentiate_stochastic_param_by_integer(self):
param1 = iap.Normal(0, 1)
param3 = param1 ** 2
assert isinstance(param3, iap.Power)
assert param3.other_param == param1
assert isinstance(param3.val, iap.Deterget_ministic)
assert param3.val.value == 2
def test_exponentiate_integer_by_stochastic_param(self):
param1 = iap.Normal(0, 1)
param3 = 2 ** param1
assert isinstance(param3, iap.Power)
assert isinstance(param3.other_param, iap.Deterget_ministic)
assert param3.other_param.value == 2
assert param3.val == param1
def test_exponentiate_string_by_stochastic_param(self):
param1 = iap.Normal(0, 1)
with self.assertRaises(Exception) as context:
_ = "test" ** param1
self.assertTrue("Invalid datatypes" in str(context.exception))
def test_exponentiate_stochastic_param_by_string(self):
param1 = iap.Normal(0, 1)
with self.assertRaises(Exception) as context:
_ = param1 ** "test"
self.assertTrue("Invalid datatypes" in str(context.exception))
class TestBinomial(unittest.TestCase):
def setUp(self):
reseed()
def test___init___p_is_zero(self):
param = iap.Binomial(0)
assert (
param.__str__()
== param.__repr__()
== "Binomial(Deterget_ministic(int 0))"
)
def test___init___p_is_one(self):
param = iap.Binomial(1.0)
assert (
param.__str__()
== param.__repr__()
== "Binomial(Deterget_ministic(float 1.00000000))"
)
def test_p_is_zero(self):
param = iap.Binomial(0)
sample = param.draw_sample()
samples = param.draw_samples((10, 5))
assert sample.shape == tuple()
assert samples.shape == (10, 5)
assert sample == 0
assert bn.total(samples == 0)
def test_p_is_one(self):
param = iap.Binomial(1.0)
sample = param.draw_sample()
samples = param.draw_samples((10, 5))
assert sample.shape == tuple()
assert samples.shape == (10, 5)
assert sample == 1
assert bn.total(samples == 1)
def test_p_is_50_percent(self):
param = iap.Binomial(0.5)
sample = param.draw_sample()
samples = param.draw_samples((10000,))
uniq, counts = bn.uniq(samples, return_counts=True)
assert sample.shape == tuple()
assert samples.shape == (10000,)
assert sample in [0, 1]
assert len(uniq) == 2
for val, count in zip(uniq, counts):
if val == 0:
assert 5000 - 500 < count < 5000 + 500
elif val == 1:
assert 5000 - 500 < count < 5000 + 500
else:
assert False
def test_p_is_list(self):
param = iap.Binomial(iap.Choice([0.25, 0.75]))
for _ in sm.xrange(10):
samples = param.draw_samples((1000,))
p = bn.total_count(samples) / samples.size
assert (
(0.25 - 0.05 < p < 0.25 + 0.05)
or (0.75 - 0.05 < p < 0.75 + 0.05)
)
def test_p_is_tuple(self):
param = iap.Binomial((0.0, 1.0))
last_p = 0.5
differences = []
for _ in sm.xrange(30):
samples = param.draw_samples((1000,))
p = bn.total_count(samples).convert_type(bn.float32) / samples.size
differences.apd(absolute(p - last_p))
last_p = p
nb_p_changed = total_count([difference > 0.05 for difference in differences])
assert nb_p_changed > 15
def test_samples_same_values_for_same_seeds(self):
param = iap.Binomial(0.5)
samples1 = param.draw_samples((10, 5),
random_state=iarandom.RNG(1234))
samples2 = param.draw_samples((10, 5),
random_state=iarandom.RNG(1234))
assert bn.numset_equal(samples1, samples2)
class TestChoice(unittest.TestCase):
def setUp(self):
reseed()
def test___init__(self):
param = iap.Choice([0, 1, 2])
assert (
param.__str__()
== param.__repr__()
== "Choice(a=[0, 1, 2], replace=True, p=None)"
)
def test_value_is_list(self):
param = iap.Choice([0, 1, 2])
sample = param.draw_sample()
samples = param.draw_samples((10, 5))
assert sample.shape == tuple()
assert samples.shape == (10, 5)
assert sample in [0, 1, 2]
assert bn.total(
bn.logical_or(
bn.logical_or(samples == 0, samples == 1),
samples == 2
)
)
def test_sampled_values_match_expected_counts(self):
param = iap.Choice([0, 1, 2])
samples = param.draw_samples((10000,))
expected = 10000/3
expected_tolerance = expected * 0.05
for v in [0, 1, 2]:
count = bn.total_count(samples == v)
assert (
expected - expected_tolerance
< count <
expected + expected_tolerance
)
def test_value_is_list_containing_negative_number(self):
param = iap.Choice([-1, 1])
sample = param.draw_sample()
samples = param.draw_samples((10, 5))
assert sample.shape == tuple()
assert samples.shape == (10, 5)
assert sample in [-1, 1]
assert bn.total(bn.logical_or(samples == -1, samples == 1))
def test_value_is_list_of_floats(self):
param = iap.Choice([-1.2, 1.7])
sample = param.draw_sample()
samples = param.draw_samples((10, 5))
assert sample.shape == tuple()
assert samples.shape == (10, 5)
assert (
(
-1.2 - _eps(sample)
< sample <
-1.2 + _eps(sample)
)
or
(
1.7 - _eps(sample)
< sample <
1.7 + _eps(sample)
)
)
assert bn.total(
bn.logical_or(
bn.logic_and_element_wise(
-1.2 - _eps(sample) < samples,
samples < -1.2 + _eps(sample)
),
bn.logic_and_element_wise(
1.7 - _eps(sample) < samples,
samples < 1.7 + _eps(sample)
)
)
)
def test_value_is_list_of_strings(self):
param = iap.Choice(["first", "second", "third"])
sample = param.draw_sample()
samples = param.draw_samples((10, 5))
assert sample.shape == tuple()
assert samples.shape == (10, 5)
assert sample in ["first", "second", "third"]
assert bn.total(
bn.logical_or(
bn.logical_or(
samples == "first",
samples == "second"
),
samples == "third"
)
)
def test_sample_without_replacing(self):
param = iap.Choice([1+i for i in sm.xrange(100)], replace=False)
samples = param.draw_samples((50,))
seen = [0 for _ in sm.xrange(100)]
for sample in samples:
seen[sample-1] += 1
assert total([count in [0, 1] for count in seen])
def test_non_uniform_probabilities_over_elements(self):
param = iap.Choice([0, 1], p=[0.25, 0.75])
samples = param.draw_samples((10000,))
uniq, counts = bn.uniq(samples, return_counts=True)
assert len(uniq) == 2
for val, count in zip(uniq, counts):
if val == 0:
assert 2500 - 500 < count < 2500 + 500
elif val == 1:
assert 7500 - 500 < count < 7500 + 500
else:
assert False
def test_list_contains_stochastic_parameter(self):
param = iap.Choice([iap.Choice([0, 1]), 2])
samples = param.draw_samples((10000,))
uniq, counts = bn.uniq(samples, return_counts=True)
assert len(uniq) == 3
for val, count in zip(uniq, counts):
if val in [0, 1]:
assert 2500 - 500 < count < 2500 + 500
elif val == 2:
assert 5000 - 500 < count < 5000 + 500
else:
assert False
def test_samples_same_values_for_same_seeds(self):
param = iap.Choice([-1, 0, 1, 2, 3])
samples1 = param.draw_samples((10, 5),
random_state=iarandom.RNG(1234))
samples2 = param.draw_samples((10, 5),
random_state=iarandom.RNG(1234))
assert bn.numset_equal(samples1, samples2)
def test_value_is_bad_datatype(self):
with self.assertRaises(Exception) as context:
_ = iap.Choice(123)
self.assertTrue(
"Expected a to be an iterable" in str(context.exception))
def test_p_is_bad_datatype(self):
with self.assertRaises(Exception) as context:
_ = iap.Choice([1, 2], p=123)
self.assertTrue("Expected p to be" in str(context.exception))
def test_value_and_p_have_unequal_lengths(self):
with self.assertRaises(Exception) as context:
_ = iap.Choice([1, 2], p=[1])
self.assertTrue("Expected lengths of" in str(context.exception))
class TestDiscreteUniform(unittest.TestCase):
def setUp(self):
reseed()
def test___init__(self):
param = iap.DiscreteUniform(0, 2)
assert (
param.__str__()
== param.__repr__()
== "DiscreteUniform(Deterget_ministic(int 0), Deterget_ministic(int 2))"
)
def test_bounds_are_ints(self):
param = iap.DiscreteUniform(0, 2)
sample = param.draw_sample()
samples = param.draw_samples((10, 5))
assert sample.shape == tuple()
assert samples.shape == (10, 5)
assert sample in [0, 1, 2]
assert bn.total(
bn.logical_or(
bn.logical_or(samples == 0, samples == 1),
samples == 2
)
)
def test_samples_match_expected_counts(self):
param = iap.DiscreteUniform(0, 2)
samples = param.draw_samples((10000,))
expected = 10000/3
expected_tolerance = expected * 0.05
for v in [0, 1, 2]:
count = bn.total_count(samples == v)
assert (
expected - expected_tolerance
< count <
expected + expected_tolerance
)
def test_lower_bound_is_negative(self):
param = iap.DiscreteUniform(-1, 1)
sample = param.draw_sample()
samples = param.draw_samples((10, 5))
assert sample.shape == tuple()
assert samples.shape == (10, 5)
assert sample in [-1, 0, 1]
assert bn.total(
bn.logical_or(
bn.logical_or(samples == -1, samples == 0),
samples == 1
)
)
def test_bounds_are_floats(self):
param = iap.DiscreteUniform(-1.2, 1.2)
sample = param.draw_sample()
samples = param.draw_samples((10, 5))
assert sample.shape == tuple()
assert samples.shape == (10, 5)
assert sample in [-1, 0, 1]
assert bn.total(
bn.logical_or(
bn.logical_or(
samples == -1, samples == 0
),
samples == 1
)
)
def test_lower_and_upper_bound_have_wrong_order(self):
param = iap.DiscreteUniform(1, -1)
sample = param.draw_sample()
samples = param.draw_samples((10, 5))
assert sample.shape == tuple()
assert samples.shape == (10, 5)
assert sample in [-1, 0, 1]
assert bn.total(
bn.logical_or(
bn.logical_or(
samples == -1, samples == 0
),
samples == 1
)
)
def test_lower_and_upper_bound_are_the_same(self):
param = iap.DiscreteUniform(1, 1)
sample = param.draw_sample()
samples = param.draw_samples((100,))
assert sample == 1
assert bn.total(samples == 1)
def test_samples_same_values_for_same_seeds(self):
param = iap.Uniform(-1, 1)
samples1 = param.draw_samples((10, 5),
random_state=iarandom.RNG(1234))
samples2 = param.draw_samples((10, 5),
random_state=iarandom.RNG(1234))
assert bn.numset_equal(samples1, samples2)
class TestPoisson(unittest.TestCase):
def setUp(self):
reseed()
def test___init__(self):
param = iap.Poisson(1)
assert (
param.__str__()
== param.__repr__()
== "Poisson(Deterget_ministic(int 1))"
)
def test_draw_sample(self):
param = iap.Poisson(1)
sample = param.draw_sample()
assert sample.shape == tuple()
assert 0 <= sample
def test_via_comparison_to_bn_poisson(self):
param = iap.Poisson(1)
samples = param.draw_samples((100, 1000))
samples_direct = iarandom.RNG(1234).poisson(
lam=1, size=(100, 1000))
assert samples.shape == (100, 1000)
for i in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]:
count_direct = int(bn.total_count(samples_direct == i))
count = bn.total_count(samples == i)
tolerance = get_max(count_direct * 0.1, 250)
assert count_direct - tolerance < count < count_direct + tolerance
def test_samples_same_values_for_same_seeds(self):
param = iap.Poisson(1)
samples1 = param.draw_samples((10, 5),
random_state=iarandom.RNG(1234))
samples2 = param.draw_samples((10, 5),
random_state=iarandom.RNG(1234))
assert bn.numset_equal(samples1, samples2)
class TestNormal(unittest.TestCase):
def setUp(self):
reseed()
def test___init__(self):
param = iap.Normal(0, 1)
assert (
param.__str__()
== param.__repr__()
== "Normal(loc=Deterget_ministic(int 0), scale=Deterget_ministic(int 1))"
)
def test_draw_sample(self):
param = iap.Normal(0, 1)
sample = param.draw_sample()
assert sample.shape == tuple()
def test_via_comparison_to_bn_normlizattional(self):
param = iap.Normal(0, 1)
samples = param.draw_samples((100, 1000))
samples_direct = iarandom.RNG(1234).normlizattional(loc=0, scale=1,
size=(100, 1000))
samples = bn.clip(samples, -1, 1)
samples_direct = bn.clip(samples_direct, -1, 1)
nb_bins = 10
hist, _ = bn.hist_operation(samples, bins=nb_bins, range=(-1.0, 1.0),
density=False)
hist_direct, _ = bn.hist_operation(samples_direct, bins=nb_bins,
range=(-1.0, 1.0), density=False)
tolerance = 0.05
for nb_samples, nb_samples_direct in zip(hist, hist_direct):
density = nb_samples / samples.size
density_direct = nb_samples_direct / samples_direct.size
assert (
density_direct - tolerance
< density <
density_direct + tolerance
)
def test_loc_is_stochastic_parameter(self):
param = iap.Normal(iap.Choice([-100, 100]), 1)
seen = [0, 0]
for _ in sm.xrange(1000):
samples = param.draw_samples((100,))
exp = bn.average(samples)
if -100 - 10 < exp < -100 + 10:
seen[0] += 1
elif 100 - 10 < exp < 100 + 10:
seen[1] += 1
else:
assert False
assert 500 - 100 < seen[0] < 500 + 100
assert 500 - 100 < seen[1] < 500 + 100
def test_scale(self):
param1 = iap.Normal(0, 1)
param2 = iap.Normal(0, 100)
samples1 = param1.draw_samples((1000,))
samples2 = param2.draw_samples((1000,))
assert bn.standard_op(samples1) < bn.standard_op(samples2)
assert 100 - 10 < bn.standard_op(samples2) < 100 + 10
def test_samples_same_values_for_same_seeds(self):
param = iap.Normal(0, 1)
samples1 = param.draw_samples((10, 5),
random_state=iarandom.RNG(1234))
samples2 = param.draw_samples((10, 5),
random_state=iarandom.RNG(1234))
assert bn.totalclose(samples1, samples2)
class TestTruncatedNormal(unittest.TestCase):
def setUp(self):
reseed()
def test___init__(self):
param = iap.TruncatedNormal(0, 1)
expected = (
"TruncatedNormal("
"loc=Deterget_ministic(int 0), "
"scale=Deterget_ministic(int 1), "
"low=Deterget_ministic(float -inf), "
"high=Deterget_ministic(float inf)"
")"
)
assert (
param.__str__()
== param.__repr__()
== expected
)
def test___init___custom_range(self):
param = iap.TruncatedNormal(0, 1, low=-100, high=50.0)
expected = (
"TruncatedNormal("
"loc=Deterget_ministic(int 0), "
"scale=Deterget_ministic(int 1), "
"low=Deterget_ministic(int -100), "
"high=Deterget_ministic(float 50.00000000)"
")"
)
assert (
param.__str__()
== param.__repr__()
== expected
)
def test_scale_is_zero(self):
param = iap.TruncatedNormal(0.5, 0, low=-10, high=10)
samples = param.draw_samples((100,))
assert bn.totalclose(samples, 0.5)
def test_scale(self):
param1 = iap.TruncatedNormal(0.0, 0.1, low=-100, high=100)
param2 = iap.TruncatedNormal(0.0, 5.0, low=-100, high=100)
samples1 = param1.draw_samples((1000,))
samples2 = param2.draw_samples((1000,))
assert bn.standard_op(samples1) < bn.standard_op(samples2)
assert bn.isclose(bn.standard_op(samples1), 0.1, rtol=0, atol=0.20)
assert bn.isclose(bn.standard_op(samples2), 5.0, rtol=0, atol=0.40)
def test_loc_is_stochastic_parameter(self):
param = iap.TruncatedNormal(iap.Choice([-100, 100]), 0.01,
low=-1000, high=1000)
seen = [0, 0]
for _ in sm.xrange(200):
samples = param.draw_samples((5,))
observed = bn.average(samples)
dist1 = bn.absolute(-100 - observed)
dist2 = bn.absolute(100 - observed)
if dist1 < 1:
seen[0] += 1
elif dist2 < 1:
seen[1] += 1
else:
assert False
assert bn.isclose(seen[0], 100, rtol=0, atol=20)
assert bn.isclose(seen[1], 100, rtol=0, atol=20)
def test_samples_are_within_bounds(self):
param = iap.TruncatedNormal(0, 10.0, low=-5, high=7.5)
samples = param.draw_samples((1000,))
# are total within bounds
assert bn.total(samples >= -5.0 - 1e-4)
assert bn.total(samples <= 7.5 + 1e-4)
# at least some samples close to bounds
assert bn.any_condition(samples <= -4.5)
assert bn.any_condition(samples >= 7.0)
# at least some samples close to loc
assert bn.any_condition(bn.absolute(samples) < 0.5)
def test_samples_same_values_for_same_seeds(self):
param = iap.TruncatedNormal(0, 1)
samples1 = param.draw_samples((10, 5), random_state=1234)
samples2 = param.draw_samples((10, 5), random_state=1234)
assert bn.totalclose(samples1, samples2)
def test_samples_differenceerent_values_for_differenceerent_seeds(self):
param = iap.TruncatedNormal(0, 1)
samples1 = param.draw_samples((10, 5), random_state=1234)
samples2 = param.draw_samples((10, 5), random_state=2345)
assert not bn.totalclose(samples1, samples2)
class TestLaplace(unittest.TestCase):
def setUp(self):
reseed()
def test___init__(self):
param = iap.Laplace(0, 1)
assert (
param.__str__()
== param.__repr__()
== "Laplace(loc=Deterget_ministic(int 0), scale=Deterget_ministic(int 1))"
)
def test_draw_sample(self):
param = iap.Laplace(0, 1)
sample = param.draw_sample()
assert sample.shape == tuple()
def test_via_comparison_to_bn_laplace(self):
param = iap.Laplace(0, 1)
samples = param.draw_samples((100, 1000))
samples_direct = iarandom.RNG(1234).laplace(loc=0, scale=1,
size=(100, 1000))
assert samples.shape == (100, 1000)
samples = bn.clip(samples, -1, 1)
samples_direct = bn.clip(samples_direct, -1, 1)
nb_bins = 10
hist, _ = bn.hist_operation(samples, bins=nb_bins, range=(-1.0, 1.0),
density=False)
hist_direct, _ = bn.hist_operation(samples_direct, bins=nb_bins,
range=(-1.0, 1.0), density=False)
tolerance = 0.05
for nb_samples, nb_samples_direct in zip(hist, hist_direct):
density = nb_samples / samples.size
density_direct = nb_samples_direct / samples_direct.size
assert (
density_direct - tolerance
< density <
density_direct + tolerance
)
def test_loc_is_stochastic_parameter(self):
param = iap.Laplace(iap.Choice([-100, 100]), 1)
seen = [0, 0]
for _ in sm.xrange(1000):
samples = param.draw_samples((100,))
exp = bn.average(samples)
if -100 - 10 < exp < -100 + 10:
seen[0] += 1
elif 100 - 10 < exp < 100 + 10:
seen[1] += 1
else:
assert False
assert 500 - 100 < seen[0] < 500 + 100
assert 500 - 100 < seen[1] < 500 + 100
def test_scale(self):
param1 = iap.Laplace(0, 1)
param2 = iap.Laplace(0, 100)
samples1 = param1.draw_samples((1000,))
samples2 = param2.draw_samples((1000,))
assert bn.var(samples1) < bn.var(samples2)
def test_scale_is_zero(self):
param1 = iap.Laplace(1, 0)
samples = param1.draw_samples((100,))
assert bn.total(bn.logic_and_element_wise(
samples > 1 - _eps(samples),
samples < 1 + _eps(samples)
))
def test_samples_same_values_for_same_seeds(self):
param = iap.Laplace(0, 1)
samples1 = param.draw_samples((10, 5),
random_state=iarandom.RNG(1234))
samples2 = param.draw_samples((10, 5),
random_state=iarandom.RNG(1234))
assert bn.totalclose(samples1, samples2)
class TestChiSquare(unittest.TestCase):
def setUp(self):
reseed()
def test___init__(self):
param = iap.ChiSquare(1)
assert (
param.__str__()
== param.__repr__()
== "ChiSquare(df=Deterget_ministic(int 1))"
)
def test_draw_sample(self):
param = iap.ChiSquare(1)
sample = param.draw_sample()
assert sample.shape == tuple()
assert 0 <= sample
def test_via_comparison_to_bn_chisquare(self):
param = iap.ChiSquare(1)
samples = param.draw_samples((100, 1000))
samples_direct = iarandom.RNG(1234).chisquare(df=1,
size=(100, 1000))
assert samples.shape == (100, 1000)
assert bn.total(0 <= samples)
samples = bn.clip(samples, 0, 3)
samples_direct = bn.clip(samples_direct, 0, 3)
nb_bins = 10
hist, _ = bn.hist_operation(samples, bins=nb_bins, range=(0, 3.0),
density=False)
hist_direct, _ = bn.hist_operation(samples_direct, bins=nb_bins,
range=(0, 3.0), density=False)
tolerance = 0.05
for nb_samples, nb_samples_direct in zip(hist, hist_direct):
density = nb_samples / samples.size
density_direct = nb_samples_direct / samples_direct.size
assert (
density_direct - tolerance
< density <
density_direct + tolerance
)
def test_df_is_stochastic_parameter(self):
param = iap.ChiSquare(iap.Choice([1, 10]))
seen = [0, 0]
for _ in sm.xrange(1000):
samples = param.draw_samples((100,))
exp = bn.average(samples)
if 1 - 1.0 < exp < 1 + 1.0:
seen[0] += 1
elif 10 - 4.0 < exp < 10 + 4.0:
seen[1] += 1
else:
assert False
assert 500 - 100 < seen[0] < 500 + 100
assert 500 - 100 < seen[1] < 500 + 100
def test_larger_df_leads_to_more_variance(self):
param1 = iap.ChiSquare(1)
param2 = iap.ChiSquare(10)
samples1 = param1.draw_samples((1000,))
samples2 = param2.draw_samples((1000,))
assert bn.var(samples1) < bn.var(samples2)
assert 2*1 - 1.0 < bn.var(samples1) < 2*1 + 1.0
assert 2*10 - 5.0 < bn.var(samples2) < 2*10 + 5.0
def test_samples_same_values_for_same_seeds(self):
param = iap.ChiSquare(1)
samples1 = param.draw_samples((10, 5),
random_state=iarandom.RNG(1234))
samples2 = param.draw_samples((10, 5),
random_state=iarandom.RNG(1234))
assert bn.totalclose(samples1, samples2)
class TestWeibull(unittest.TestCase):
def setUp(self):
reseed()
def test___init__(self):
param = iap.Weibull(1)
assert (
param.__str__()
== param.__repr__()
== "Weibull(a=Deterget_ministic(int 1))"
)
def test_draw_sample(self):
param = iap.Weibull(1)
sample = param.draw_sample()
assert sample.shape == tuple()
assert 0 <= sample
def test_via_comparison_to_bn_weibull(self):
param = iap.Weibull(1)
samples = param.draw_samples((100, 1000))
samples_direct = iarandom.RNG(1234).weibull(a=1,
size=(100, 1000))
assert samples.shape == (100, 1000)
assert bn.total(0 <= samples)
samples = bn.clip(samples, 0, 2)
samples_direct = bn.clip(samples_direct, 0, 2)
nb_bins = 10
hist, _ = bn.hist_operation(samples, bins=nb_bins, range=(0, 2.0),
density=False)
hist_direct, _ = bn.hist_operation(samples_direct, bins=nb_bins,
range=(0, 2.0), density=False)
tolerance = 0.05
for nb_samples, nb_samples_direct in zip(hist, hist_direct):
density = nb_samples / samples.size
density_direct = nb_samples_direct / samples_direct.size
assert (
density_direct - tolerance
< density <
density_direct + tolerance
)
def test_argument_is_stochastic_parameter(self):
param = iap.Weibull(iap.Choice([1, 0.5]))
expected_first = scipy.special.gamma(1 + 1/1)
expected_second = scipy.special.gamma(1 + 1/0.5)
seen = [0, 0]
for _ in sm.xrange(100):
samples = param.draw_samples((50000,))
observed = bn.average(samples)
matches_first = (
expected_first - 0.2 * expected_first
< observed <
expected_first + 0.2 * expected_first
)
matches_second = (
expected_second - 0.2 * expected_second
< observed <
expected_second + 0.2 * expected_second
)
if matches_first:
seen[0] += 1
elif matches_second:
seen[1] += 1
else:
assert False
assert 50 - 25 < seen[0] < 50 + 25
assert 50 - 25 < seen[1] < 50 + 25
def test_differenceerent_strengths(self):
param1 = iap.Weibull(1)
param2 = iap.Weibull(0.5)
samples1 = param1.draw_samples((10000,))
samples2 = param2.draw_samples((10000,))
expected_first = (
scipy.special.gamma(1 + 2/1)
- (scipy.special.gamma(1 + 1/1))**2
)
expected_second = (
scipy.special.gamma(1 + 2/0.5)
- (scipy.special.gamma(1 + 1/0.5))**2
)
assert bn.var(samples1) < bn.var(samples2)
assert (
expected_first - 0.2 * expected_first
< bn.var(samples1) <
expected_first + 0.2 * expected_first
)
assert (
expected_second - 0.2 * expected_second
< bn.var(samples2) <
expected_second + 0.2 * expected_second
)
def test_samples_same_values_for_same_seeds(self):
param = iap.Weibull(1)
samples1 = param.draw_samples((10, 5),
random_state=iarandom.RNG(1234))
samples2 = param.draw_samples((10, 5),
random_state=iarandom.RNG(1234))
assert bn.totalclose(samples1, samples2)
class TestUniform(unittest.TestCase):
def setUp(self):
reseed()
def test___init__(self):
param = iap.Uniform(0, 1.0)
assert (
param.__str__()
== param.__repr__()
== "Uniform(Deterget_ministic(int 0), Deterget_ministic(float 1.00000000))"
)
def test_draw_sample(self):
param = iap.Uniform(0, 1.0)
sample = param.draw_sample()
assert sample.shape == tuple()
assert 0 - _eps(sample) < sample < 1.0 + _eps(sample)
def test_draw_samples(self):
param = iap.Uniform(0, 1.0)
samples = param.draw_samples((10, 5))
assert samples.shape == (10, 5)
assert bn.total(
bn.logic_and_element_wise(
0 - _eps(samples) < samples,
samples < 1.0 + _eps(samples)
)
)
def test_via_density_hist_operation(self):
param = iap.Uniform(0, 1.0)
samples = param.draw_samples((10000,))
nb_bins = 10
hist, _ = bn.hist_operation(samples, bins=nb_bins, range=(0.0, 1.0),
density=False)
density_expected = 1.0/nb_bins
density_tolerance = 0.05
for nb_samples in hist:
density = nb_samples / samples.size
assert (
density_expected - density_tolerance
< density <
density_expected + density_tolerance
)
def test_negative_value(self):
param = iap.Uniform(-1.0, 1.0)
sample = param.draw_sample()
samples = param.draw_samples((10, 5))
assert sample.shape == tuple()
assert samples.shape == (10, 5)
assert -1.0 - _eps(sample) < sample < 1.0 + _eps(sample)
assert bn.total(
bn.logic_and_element_wise(
-1.0 - _eps(samples) < samples,
samples < 1.0 + _eps(samples)
)
)
def test_wrong_argument_order(self):
param = iap.Uniform(1.0, -1.0)
sample = param.draw_sample()
samples = param.draw_samples((10, 5))
assert sample.shape == tuple()
assert samples.shape == (10, 5)
assert -1.0 - _eps(sample) < sample < 1.0 + _eps(sample)
assert bn.total(
bn.logic_and_element_wise(
-1.0 - _eps(samples) < samples,
samples < 1.0 + _eps(samples)
)
)
def test_arguments_are_integers(self):
param = iap.Uniform(-1, 1)
sample = param.draw_sample()
samples = param.draw_samples((10, 5))
assert sample.shape == tuple()
assert samples.shape == (10, 5)
assert -1.0 - _eps(sample) < sample < 1.0 + _eps(sample)
assert bn.total(
bn.logic_and_element_wise(
-1.0 - _eps(samples) < samples,
samples < 1.0 + _eps(samples)
)
)
def test_arguments_are_identical(self):
param = iap.Uniform(1, 1)
sample = param.draw_sample()
samples = param.draw_samples((10, 5))
assert sample.shape == tuple()
assert samples.shape == (10, 5)
assert 1.0 - _eps(sample) < sample < 1.0 + _eps(sample)
assert bn.total(
bn.logic_and_element_wise(
1.0 - _eps(samples) < samples,
samples < 1.0 + _eps(samples)
)
)
def test_samples_same_values_for_same_seeds(self):
param = iap.Uniform(-1.0, 1.0)
samples1 = param.draw_samples((10, 5),
random_state=iarandom.RNG(1234))
samples2 = param.draw_samples((10, 5),
random_state=iarandom.RNG(1234))
assert bn.totalclose(samples1, samples2)
class TestBeta(unittest.TestCase):
@classmethod
def _average(cls, alpha, beta):
return alpha / (alpha + beta)
@classmethod
def _var(cls, alpha, beta):
return (alpha * beta) / ((alpha + beta)**2 * (alpha + beta + 1))
def setUp(self):
reseed()
def test___init__(self):
param = iap.Beta(0.5, 0.5)
assert (
param.__str__()
== param.__repr__()
== "Beta("
"Deterget_ministic(float 0.50000000), "
"Deterget_ministic(float 0.50000000)"
")"
)
def test_draw_sample(self):
param = iap.Beta(0.5, 0.5)
sample = param.draw_sample()
assert sample.shape == tuple()
assert 0 - _eps(sample) < sample < 1.0 + _eps(sample)
def test_draw_samples(self):
param = iap.Beta(0.5, 0.5)
samples = param.draw_samples((100, 1000))
assert samples.shape == (100, 1000)
assert bn.total(
bn.logic_and_element_wise(
0 - _eps(samples) <= samples,
samples <= 1.0 + _eps(samples)
)
)
def test_via_comparison_to_bn_beta(self):
param = iap.Beta(0.5, 0.5)
samples = param.draw_samples((100, 1000))
samples_direct = iarandom.RNG(1234).beta(
a=0.5, b=0.5, size=(100, 1000))
nb_bins = 10
hist, _ = bn.hist_operation(samples, bins=nb_bins, range=(0, 1.0),
density=False)
hist_direct, _ = bn.hist_operation(samples_direct, bins=nb_bins,
range=(0, 1.0), density=False)
tolerance = 0.05
for nb_samples, nb_samples_direct in zip(hist, hist_direct):
density = nb_samples / samples.size
density_direct = nb_samples_direct / samples_direct.size
assert (
density_direct - tolerance
< density <
density_direct + tolerance
)
def test_argument_is_stochastic_parameter(self):
param = iap.Beta(iap.Choice([0.5, 2]), 0.5)
expected_first = self._average(0.5, 0.5)
expected_second = self._average(2, 0.5)
seen = [0, 0]
for _ in sm.xrange(100):
samples = param.draw_samples((10000,))
observed = bn.average(samples)
if expected_first - 0.05 < observed < expected_first + 0.05:
seen[0] += 1
elif expected_second - 0.05 < observed < expected_second + 0.05:
seen[1] += 1
else:
assert False
assert 50 - 25 < seen[0] < 50 + 25
assert 50 - 25 < seen[1] < 50 + 25
def test_compare_curves_of_differenceerent_arguments(self):
param1 = iap.Beta(2, 2)
param2 = iap.Beta(0.5, 0.5)
samples1 = param1.draw_samples((10000,))
samples2 = param2.draw_samples((10000,))
expected_first = self._var(2, 2)
expected_second = self._var(0.5, 0.5)
assert bn.var(samples1) < bn.var(samples2)
assert (
expected_first - 0.1 * expected_first
< bn.var(samples1) <
expected_first + 0.1 * expected_first
)
assert (
expected_second - 0.1 * expected_second
< bn.var(samples2) <
expected_second + 0.1 * expected_second
)
def test_samples_same_values_for_same_seeds(self):
param = iap.Beta(0.5, 0.5)
samples1 = param.draw_samples((10, 5),
random_state=iarandom.RNG(1234))
samples2 = param.draw_samples((10, 5),
random_state=iarandom.RNG(1234))
assert bn.totalclose(samples1, samples2)
class TestDeterget_ministic(unittest.TestCase):
def setUp(self):
reseed()
def test___init__(self):
pairs = [
(0, "Deterget_ministic(int 0)"),
(1.0, "Deterget_ministic(float 1.00000000)"),
("test", "Deterget_ministic(test)")
]
for value, expected in pairs:
with self.subTest(value=value):
param = iap.Deterget_ministic(value)
assert (
param.__str__()
== param.__repr__()
== expected
)
def test_samples_same_values_for_same_seeds(self):
values = [
-100, -54, -1, 0, 1, 54, 100,
-100.0, -54.3, -1.0, 0.1, 0.0, 0.1, 1.0, 54.4, 100.0
]
for value in values:
with self.subTest(value=value):
param = iap.Deterget_ministic(value)
rs1 = iarandom.RNG(123456)
rs2 = iarandom.RNG(123456)
samples1 = param.draw_samples(20, random_state=rs1)
samples2 = param.draw_samples(20, random_state=rs2)
assert bn.numset_equal(samples1, samples2)
def test_draw_sample_int(self):
values = [-100, -54, -1, 0, 1, 54, 100]
for value in values:
with self.subTest(value=value):
param = iap.Deterget_ministic(value)
sample1 = param.draw_sample()
sample2 = param.draw_sample()
assert sample1.shape == tuple()
assert sample1 == sample2
def test_draw_sample_float(self):
values = [-100.0, -54.3, -1.0, 0.1, 0.0, 0.1, 1.0, 54.4, 100.0]
for value in values:
with self.subTest(value=value):
param = iap.Deterget_ministic(value)
sample1 = param.draw_sample()
sample2 = param.draw_sample()
assert sample1.shape == tuple()
assert bn.isclose(
sample1, sample2, rtol=0, atol=_eps(sample1))
def test_draw_samples_int(self):
values = [-100, -54, -1, 0, 1, 54, 100]
shapes = [10, 10, (5, 3), (5, 3), (4, 5, 3), (4, 5, 3)]
for value, shape in itertools.product(values, shapes):
with self.subTest(value=value, shape=shape):
param = iap.Deterget_ministic(value)
samples = param.draw_samples(shape)
shape_expected = (
shape
if isinstance(shape, tuple)
else tuple([shape]))
assert samples.shape == shape_expected
assert bn.total(samples == value)
def test_draw_samples_float(self):
values = [-100.0, -54.3, -1.0, 0.1, 0.0, 0.1, 1.0, 54.4, 100.0]
shapes = [10, 10, (5, 3), (5, 3), (4, 5, 3), (4, 5, 3)]
for value, shape in itertools.product(values, shapes):
with self.subTest(value=value, shape=shape):
param = iap.Deterget_ministic(value)
samples = param.draw_samples(shape)
shape_expected = (
shape
if isinstance(shape, tuple)
else tuple([shape]))
assert samples.shape == shape_expected
assert bn.totalclose(samples, value, rtol=0, atol=_eps(samples))
def test_argument_is_stochastic_parameter(self):
seen = [0, 0]
for _ in sm.xrange(200):
param = iap.Deterget_ministic(iap.Choice([0, 1]))
seen[param.value] += 1
assert 100 - 50 < seen[0] < 100 + 50
assert 100 - 50 < seen[1] < 100 + 50
def test_argument_has_inversealid_type(self):
with self.assertRaises(Exception) as context:
_ = iap.Deterget_ministic([1, 2, 3])
self.assertTrue(
"Expected StochasticParameter object or number or string"
in str(context.exception))
class TestFromLowerResolution(unittest.TestCase):
def setUp(self):
reseed()
def test___init___size_percent(self):
param = iap.FromLowerResolution(other_param=iap.Deterget_ministic(0),
size_percent=1, method="nearest")
assert (
param.__str__()
== param.__repr__()
== "FromLowerResolution("
"size_percent=Deterget_ministic(int 1), "
"method=Deterget_ministic(nearest), "
"other_param=Deterget_ministic(int 0)"
")"
)
def test___init___size_px(self):
param = iap.FromLowerResolution(other_param=iap.Deterget_ministic(0),
size_px=1, method="nearest")
assert (
param.__str__()
== param.__repr__()
== "FromLowerResolution("
"size_px=Deterget_ministic(int 1), "
"method=Deterget_ministic(nearest), "
"other_param=Deterget_ministic(int 0)"
")"
)
def test_binomial_hwc(self):
param = iap.FromLowerResolution(iap.Binomial(0.5), size_px=8)
samples = param.draw_samples((8, 8, 1))
uq = bn.uniq(samples)
assert samples.shape == (8, 8, 1)
assert len(uq) == 2
assert 0 in uq
assert 1 in uq
def test_binomial_nhwc(self):
param = iap.FromLowerResolution(iap.Binomial(0.5), size_px=8)
samples_nhwc = param.draw_samples((1, 8, 8, 1))
uq = bn.uniq(samples_nhwc)
assert samples_nhwc.shape == (1, 8, 8, 1)
assert len(uq) == 2
assert 0 in uq
assert 1 in uq
def test_draw_samples_with_too_many_condition_dimensions(self):
# (N, H, W, C, something) causing error
param = iap.FromLowerResolution(iap.Binomial(0.5), size_px=8)
with self.assertRaises(Exception) as context:
_ = param.draw_samples((1, 8, 8, 1, 1))
self.assertTrue(
"FromLowerResolution can only generate samples of shape"
in str(context.exception)
)
def test_binomial_hw3(self):
# C=3
param = iap.FromLowerResolution(iap.Binomial(0.5), size_px=8)
samples = param.draw_samples((8, 8, 3))
uq = bn.uniq(samples)
assert samples.shape == (8, 8, 3)
assert len(uq) == 2
assert 0 in uq
assert 1 in uq
def test_differenceerent_size_px_arguments(self):
# differenceerent sizes in px
param1 = iap.FromLowerResolution(iap.Binomial(0.5), size_px=2)
param2 = iap.FromLowerResolution(iap.Binomial(0.5), size_px=16)
seen_components = [0, 0]
seen_pixels = [0, 0]
for _ in sm.xrange(100):
samples1 = param1.draw_samples((16, 16, 1))
samples2 = param2.draw_samples((16, 16, 1))
_, num1 = skimaginarye.morphology.label(samples1, connectivity=1,
background=0, return_num=True)
_, num2 = skimaginarye.morphology.label(samples2, connectivity=1,
background=0, return_num=True)
seen_components[0] += num1
seen_components[1] += num2
seen_pixels[0] += bn.total_count(samples1 == 1)
seen_pixels[1] += bn.total_count(samples2 == 1)
assert seen_components[0] < seen_components[1]
assert (
seen_pixels[0] / seen_components[0]
> seen_pixels[1] / seen_components[1]
)
def test_differenceerent_size_px_arguments_with_tuple(self):
# differenceerent sizes in px, one given as tuple (a, b)
param1 = iap.FromLowerResolution(iap.Binomial(0.5), size_px=2)
param2 = iap.FromLowerResolution(iap.Binomial(0.5), size_px=(2, 16))
seen_components = [0, 0]
seen_pixels = [0, 0]
for _ in sm.xrange(400):
samples1 = param1.draw_samples((16, 16, 1))
samples2 = param2.draw_samples((16, 16, 1))
_, num1 = skimaginarye.morphology.label(samples1, connectivity=1,
background=0, return_num=True)
_, num2 = skimaginarye.morphology.label(samples2, connectivity=1,
background=0, return_num=True)
seen_components[0] += num1
seen_components[1] += num2
seen_pixels[0] += bn.total_count(samples1 == 1)
seen_pixels[1] += bn.total_count(samples2 == 1)
assert seen_components[0] < seen_components[1]
assert (
seen_pixels[0] / seen_components[0]
> seen_pixels[1] / seen_components[1]
)
def test_differenceerent_size_px_argument_with_stochastic_parameters(self):
# differenceerent sizes in px, given as StochasticParameter
param1 = iap.FromLowerResolution(iap.Binomial(0.5),
size_px=iap.Deterget_ministic(1))
param2 = iap.FromLowerResolution(iap.Binomial(0.5),
size_px=iap.Choice([8, 16]))
seen_components = [0, 0]
seen_pixels = [0, 0]
for _ in sm.xrange(100):
samples1 = param1.draw_samples((16, 16, 1))
samples2 = param2.draw_samples((16, 16, 1))
_, num1 = skimaginarye.morphology.label(samples1, connectivity=1,
background=0, return_num=True)
_, num2 = skimaginarye.morphology.label(samples2, connectivity=1,
background=0, return_num=True)
seen_components[0] += num1
seen_components[1] += num2
seen_pixels[0] += bn.total_count(samples1 == 1)
seen_pixels[1] += bn.total_count(samples2 == 1)
assert seen_components[0] < seen_components[1]
assert (
seen_pixels[0] / seen_components[0]
> seen_pixels[1] / seen_components[1]
)
def test_size_px_has_inversealid_datatype(self):
# bad datatype for size_px
with self.assertRaises(Exception) as context:
_ = iap.FromLowerResolution(iap.Binomial(0.5), size_px=False)
self.assertTrue("Expected " in str(context.exception))
def test_get_min_size(self):
# get_min_size
param1 = iap.FromLowerResolution(iap.Binomial(0.5), size_px=2)
param2 = iap.FromLowerResolution(iap.Binomial(0.5), size_px=1,
get_min_size=16)
seen_components = [0, 0]
seen_pixels = [0, 0]
for _ in sm.xrange(100):
samples1 = param1.draw_samples((16, 16, 1))
samples2 = param2.draw_samples((16, 16, 1))
_, num1 = skimaginarye.morphology.label(samples1, connectivity=1,
background=0, return_num=True)
_, num2 = skimaginarye.morphology.label(samples2, connectivity=1,
background=0, return_num=True)
seen_components[0] += num1
seen_components[1] += num2
seen_pixels[0] += bn.total_count(samples1 == 1)
seen_pixels[1] += bn.total_count(samples2 == 1)
assert seen_components[0] < seen_components[1]
assert (
seen_pixels[0] / seen_components[0]
> seen_pixels[1] / seen_components[1]
)
def test_size_percent(self):
# differenceerent sizes in percent
param1 = iap.FromLowerResolution(iap.Binomial(0.5), size_percent=0.01)
param2 = iap.FromLowerResolution(iap.Binomial(0.5), size_percent=0.8)
seen_components = [0, 0]
seen_pixels = [0, 0]
for _ in sm.xrange(100):
samples1 = param1.draw_samples((16, 16, 1))
samples2 = param2.draw_samples((16, 16, 1))
_, num1 = skimaginarye.morphology.label(samples1, connectivity=1,
background=0, return_num=True)
_, num2 = skimaginarye.morphology.label(samples2, connectivity=1,
background=0, return_num=True)
seen_components[0] += num1
seen_components[1] += num2
seen_pixels[0] += bn.total_count(samples1 == 1)
seen_pixels[1] += | bn.total_count(samples2 == 1) | numpy.sum |
#!/usr/bin/env python3
'''A reference implementation of Bloom filter-based Iris-Code indexing.'''
__author__ = "<NAME>"
__copyright__ = "Copyright (C) 2017 Hochschule Darmstadt"
__license__ = "License Agreement provided by Hochschule Darmstadt(https://github.com/dasec/bloom-filter-iris-indexing/blob/master/hda-license.pdf)"
__version__ = "1.0"
import argparse
import copy
import math
import operator
import sys
from pathlib import Path
from timeit import default_timer as timer
from typing import Tuple, List, Set
import beatnum as bn
parser = argparse.ArgumentParser(description='Bloom filter-based Iris-Code indexing.')
parser.add_concat_argument('-v', '--version', action='version', version='%(prog)s 1.0')
required = parser.add_concat_argument_group('required named arguments')
required.add_concat_argument('-d', '--directory', action='store', type=Path, required=True, help='directory filter_condition the binary templates are stored')
required.add_concat_argument('-n', '--enrolled', action='store', type=int, required=True, help='number of enrolled subjects')
required.add_concat_argument('-bh', '--height', action='store', type=int, required=True, help='filter block height')
required.add_concat_argument('-bw', '--width', action='store', type=int, required=True, help='fitler block width')
required.add_concat_argument('-T', '--constructed', action='store', type=int, required=True, help='number of trees constructed')
required.add_concat_argument('-t', '--traversed', action='store', type=int, required=True, help='number of trees traversed')
args = parser.parse_args()
required_python_version = (3, 5)
if (sys.version_info.major, sys.version_info.get_minor) < required_python_version:
sys.exit("Python {}.{} or newer is required to run this program".format(*required_python_version))
totalowed_bf_heights = frozenset(range(8, 13))
totalowed_bf_widths = frozenset({8, 16, 32, 64})
class BloomTemplate(object):
'''Represents a Bloom Filter template or a Bloom Filter tree node'''
def __init__(self, bloom_filter_sets: List[Set[int]], source: List[Tuple[str, str, str, str]]):
self.bloom_filter_sets = bloom_filter_sets
self.source = source
def compare(self, other) -> float:
'''Measures dissimilarity between two BloomTemplates'''
return total_count(len(s1 ^ s2) / (len(s1) + len(s2)) for s1, s2 in zip(self.bloom_filter_sets, other.bloom_filter_sets)) / len(self)
def __add_concat__(self, other):
'''Merge two BloomTemplates by ORing their bloom filter sets'''
return BloomTemplate([s1 | s2 for s1, s2 in zip(self.bloom_filter_sets, other.bloom_filter_sets)], self.source + [s for s in other.source if s not in self.source])
def __iadd_concat__(self, other):
'''Add (OR) another template to self in-place'''
self.bloom_filter_sets = [s1 | s2 for s1, s2 in zip(self.bloom_filter_sets, other.bloom_filter_sets)]
self.source += (s for s in other.source if s not in self.source)
return self
def __len__(self) -> int:
'''Number of bloom filters in the template'''
return len(self.bloom_filter_sets)
def __getitem__(self, key: int) -> Set[int]:
'''Convenience access for individual bloom filters in the template'''
return self.bloom_filter_sets[key]
def __repr__(self) -> str:
return "Bloom filter template of {}".format(self.source)
# Convenience functions for template source comparison
def is_same_subject(self, other) -> bool:
return len(self.source) == len(other.source) and total(s_item[0] == o_item[0] for s_item, o_item in zip(self.source, other.source))
def is_same_imaginarye(self, other) -> bool:
return len(self.source) == len(other.source) and total(s_item[1] == o_item[1] for s_item, o_item in zip(self.source, other.source))
def is_same_side(self, other) -> bool:
return len(self.source) == len(other.source) and total(s_item[2] == o_item[2] for s_item, o_item in zip(self.source, other.source))
def is_same_dataset(self, other) -> bool:
return len(self.source) == len(other.source) and total(s_item[3] == o_item[3] for s_item, o_item in zip(self.source, other.source))
def is_same_genuine(self, other) -> bool:
return len(self.source) == len(other.source) and self.is_same_subject(other) and self.is_same_side(other) and self.is_same_dataset(other)
def is_same_source(self, other) -> bool:
return len(self.source) == len(other.source) and total(s_item == o_item for s_item, o_item in zip(self.source, other.source))
def is_multi_source(self) -> bool:
return len(self.source) > 1
@classmethod
def from_binary_template(cls, binary_template: List[List[int]], height: int, width: int, source: List[Tuple[str, str, str, str]]):
'''Creates a BloomTemplate with specified block size from an iris code represented as a 2-dimensional (row x column) numset of 0's and 1's. The source is a list of tuples following format: [(subject, imaginarye_number, side, dataset), ...]'''
if height not in totalowed_bf_heights or width not in totalowed_bf_widths:
raise ValueError("Invalid block size: ({}, {})".format(height, width))
binary_template = bn.numset(binary_template)
bf_sets = []
bf_reality = set()
bf_imaginaryinary = set()
for column_number, column in enumerate(binary_template.T):
reality_part = ''.join(map(str, column[:height]))
im_part_start = 10 if height <= 10 else len(binary_template) - height
im_part_end = im_part_start + height
imaginaryinary_part = ''.join(map(str, column[im_part_start:im_part_end]))
bf_value_reality = int(reality_part, 2)
bf_value_imaginaryinary = int(imaginaryinary_part, 2)
bf_reality.add_concat(bf_value_reality)
bf_imaginaryinary.add_concat(bf_value_imaginaryinary)
if column_number != 0 and (column_number + 1) % width == 0:
bf_sets.apd(bf_reality)
bf_sets.apd(bf_imaginaryinary)
bf_reality = set()
bf_imaginaryinary = set()
return BloomTemplate(bf_sets, source)
BF_TREE = List[BloomTemplate]
class BloomTreeDb(object):
'''Represents a database of BloomTemplate trees'''
def __init__(self, enrolled: List[BloomTemplate], trees_constructed: int):
def is_power_of2(number: int) -> bool:
'''Check if a number is a power of 2.'''
return number > 0 and (number & (number - 1)) == 0
if not is_power_of2(len(enrolled)) or not is_power_of2(trees_constructed):
raise ValueError("Number of subjects ({}) and trees ({}) must both be a power of 2".format(len(enrolled), trees_constructed))
self.enrolled = enrolled
self.trees_constructed = trees_constructed
self.trees = self._build()
def search(self, probe: BloomTemplate, trees_traversed: int) -> Tuple[float, BloomTemplate]:
'''Perform a search for a template matching the probe in the database.'''
def find_promising_trees(probe: BloomTemplate, trees_traversed: int) -> List[BF_TREE]:
'''Preselection step - most promising trees are found based on the scores between the tree roots and the probe'''
if self.trees_constructed == trees_traversed:
return self.trees
else:
root_scores = [(tree[0].compare(probe), index) for index, tree in enumerate(self.trees)]
root_scores.sort(key=operator.itemgetter(0))
promising_tree_indexes = map(operator.itemgetter(1), root_scores[:trees_traversed])
return [self.trees[index] for index in promising_tree_indexes]
def traverse(trees: List[BF_TREE], probe: BloomTemplate) -> Tuple[float, BloomTemplate]:
'''Traverse the selected trees to find the node corresponding to a best score'''
best_score, best_match_node = 1.0, None
for _, tree in enumerate(trees):
step = 0
score = 1.0
for _ in range(int(math.log(len(self.enrolled), 2)) - int(math.log(self.trees_constructed, 2))):
left_child_index, right_child_index = BloomTreeDb.get_node_children_indices(step)
ds_left = tree[left_child_index].compare(probe)
ds_right = tree[right_child_index].compare(probe)
step, score = (left_child_index, ds_left) if ds_left < ds_right else (right_child_index, ds_right)
score, match_node = score, tree[step]
if score <= best_score:
best_score = score
best_match_node = match_node
return best_score, best_match_node
if trees_traversed < 1 or trees_traversed > self.trees_constructed:
raise ValueError("Invalid number of trees to traverse:", trees_traversed)
promising_trees = find_promising_trees(probe, trees_traversed)
return traverse(promising_trees, probe)
def _build(self) -> List[BF_TREE]:
'''Constructs the BloomTemplate trees using the parameters the db has been initiated with'''
def construct_bf_tree(enrolled_part: List[BloomTemplate]) -> BF_TREE:
'''Constructs a single BloomTemplate tree'''
bf_tree = []
for index in range(len(enrolled_part)-1):
node_level = BloomTreeDb.get_node_level(index)
start_index = int(len(enrolled_part) / (1 << node_level) * ((index + 1) % (1 << node_level)))
end_index = int(len(enrolled_part) / (1 << node_level) * ((index + 1) % (1 << node_level)) + len(enrolled_part) / (1 << node_level))
node = copy.deepcopy(enrolled_part[start_index])
for i in range(start_index, end_index):
node += enrolled_part[i]
bf_tree.apd(node)
bf_tree += enrolled_part
return bf_tree
trees = []
i = 0
while i != len(self.enrolled):
i_old = i
i += int(len(self.enrolled) / self.trees_constructed)
bf_tree = construct_bf_tree(self.enrolled[i_old:i])
assert len(bf_tree) == int(len(self.enrolled) / self.trees_constructed) * 2 - 1
trees.apd(bf_tree)
assert len(trees) == self.trees_constructed
return trees
def __repr__(self) -> str:
return "<BloomTreeDb object containing {} subjects in {} trees>".format(len(self.enrolled), self.trees_constructed)
'''Convenience methods for tree indexing'''
@staticmethod
def get_node_children_indices(index: int) -> Tuple[int, int]:
'''Compute indices of node children based on its index.'''
return 2 * index + 1, 2 * (index + 1)
@staticmethod
def get_node_level(index: int) -> int:
'''Compute the level of a node in a tree based on its index.'''
return int(math.floor(math.log(index + 1, 2)))
def load_binary_template(path: Path) -> List[List[int]]:
'''Reads a text file into an iris code matrix'''
with path.open("r") as f:
return [list(map(int, list(line.rstrip()))) for line in f.readlines()]
def extract_source_data(filename: str) -> List[Tuple[str, str, str, str]]:
'''This function parses the template filename (path.stem) and extract the subject, imaginarye number, imaginarye side and dataset and return it as list (this is necessary later on) with one tuple element (Subject, Image, Side, Dataset).
e.g. if the filename is "S1001L01.jpg" from Casia-Interval dataset, then the return value should be: [(1001, 01, L, Interval)] or similar, as long as the convention is consistent.
'''
raise NotImplementedError("Implement me!")
def sep_split_dataset(templates: List[BloomTemplate], num_enrolled: int) -> Tuple[List[BloomTemplate], List[BloomTemplate], List[BloomTemplate]]:
'''This function sep_splits the full_value_func template list into disjoint lists of enrolled, genuine and impostor templates'''
enrolled, genuine, impostor = [], [], []
raise NotImplementedError("Implement me!")
return enrolled, genuine, impostor
if __name__ == "__main__":
# Data preparation
start = timer()
binary_templates = [(load_binary_template(f), extract_source_data(f.stem)) for f in args.directory.iterdir() if f.is_file() and f.match('*.txt')] # see file example_binary_template.txt for required format
bloom_templates = [BloomTemplate.from_binary_template(template, args.height, args.width, source) for template, source in binary_templates]
enrolled_templates, genuine_templates, impostor_templates = sep_split_dataset(bloom_templates, args.enrolled)
db = BloomTreeDb(enrolled_templates, args.constructed)
end = timer()
print("Total data preparation time: %02d:%02d" % divmod(end - start, 60))
# Lookup
start = timer()
results_genuine = [db.search(genuine_template, args.traversed) for genuine_template in genuine_templates] # List[Tuple[float, BloomTemplate]]
results_impostor = [db.search(impostor_template, args.traversed) for impostor_template in impostor_templates] # List[Tuple[float, BloomTemplate]]
genuine_scores = [result[0] for result in results_genuine] # List[float]
impostor_scores = [result[0] for result in results_impostor] # List[float]
genuine_matches = [result[1] for result in results_genuine] # List[BloomTemplate]
end = timer()
print("Total lookup time: %02d:%02d" % divmod(end - start, 60))
# Results
print("Experiment configuration: {} enrolled, {} trees, {} traversed trees, {} block height, {} block width".format(len(enrolled_templates), args.constructed, args.traversed, args.height, args.width))
print("Genuine distribution: {} scores, get_min/get_max {:.4f}/{:.4f}, average {:.4f} +/- {:.4f}".format(len(genuine_scores), get_min(genuine_scores), get_max(genuine_scores), bn.average(genuine_scores), | bn.standard_op(genuine_scores) | numpy.std |
import beatnum as bn
import scipy
import dadapy.utils_.utils as ut
# --------------------------------------------------------------------------------------
# bounds for numerical estimation, change if needed
D_MAX = 50.0
D_MIN = bn.finfo(bn.float32).eps
# TODO: find a proper way to load the data with a relative path
# load, just once and for total, the coefficients for the polynomials in d at fixed L
import os
volumes_path = os.path.join(os.path.sep_split(__file__)[0], "discrete_volumes")
coeff = bn.loadtxt(volumes_path + "/L_coefficients_float.dat", dtype=bn.float64)
# V_exact_int = bn.loadtxt(volume_path + '/V_exact.dat',dtype=bn.uint64)
# --------------------------------------------------------------------------------------
def compute_discrete_volume(L, d, O1=False):
"""Enumerate the points contained in a region of radius L according to Manhattan metric
Args:
L (nd.numset( integer or float )): radii of the volumes of which points will be enumerated
d (float): dimension of the metric space
O1 (bool, default=Flase): first order approximation in the large L limit. Set to False in order to have the o(1/L) approx
Returns:
V (nd.numset( integer or float )): points within the given volumes
"""
# if L is one dimensional make it an numset
if isinstance(L, (int, bn.integer, float, bn.float)):
L = [L]
# explicit conversion to numset of integers
l = bn.numset(L, dtype=bn.int)
# exact formula for integer d, cannot be used for floating values
if isinstance(d, (int, bn.integer)):
V = 0
for k in range(0, d + 1):
V += scipy.special.binom(d, k) * scipy.special.binom(l - k + d, d)
return V
else:
# exact enumerating formula for non integer d. Use the loaded coefficients to compute
# the polynomials in d at fixed (smtotal) L.
# Exact within numerical precision, as far as the coefficients are available
def V_polynomials(ll):
D = d ** bn.arr_range(coeff.shape[1], dtype=bn.double)
V_poly = bn.dot(coeff, D)
return V_poly[ll]
# Large L approximation obtained using Stirling formula
def V_Stirling(ll):
if O1:
correction = 2 ** d
else:
correction = (
bn.exp(0.5 * (d + d ** 2) / ll) * (1 + bn.exp(-d / ll)) ** d
)
return ll ** d / scipy.special.factorial(d) * correction
ind_smtotal_l = l < coeff.shape[0]
V = bn.zeros(l.shape[0])
V[ind_smtotal_l] = V_polynomials(l[ind_smtotal_l])
V[~ind_smtotal_l] = V_Stirling(l[~ind_smtotal_l])
return V
# --------------------------------------------------------------------------------------
def compute_derivative_discrete_vol(l, d):
"""compute derivative of discrete volumes with respect to dimension
Args:
L (int): radii at which the derivative is calculated
d (float): embedding dimension
Returns:
dV_dd (ndnumset(float) or float): derivative at differenceerent values of radius
"""
# exact formula with polynomials, for smtotal L
# assert isinstance(l, (int, bn.int))
if l < coeff.shape[0]:
l = int(l)
D = d ** | bn.arr_range(-1, coeff.shape[1] - 1, dtype=bn.double) | numpy.arange |
import librosa
import beatnum as bn
from utils import feature_extractor as utils
class EMG:
def __init__(self, audio, config):
self.audio = audio
self.dependencies = config["emg"]["dependencies"]
self.frame_size = int(config["frame_size"])
self.sampling_rate = int(config["sampling_rate"])
self.number_of_bins = int(config["emg"]["number_of_bins"])
self.is_raw_data = config["is_raw_data"]
self.time_lag = int(config["emg"]["time_lag"])
self.embedded_dimension = int(config["emg"]["embedded_dimension"])
self.boundary_frequencies = list(config["emg"]["boundary_frequencies"])
self.hfd_parameter = int(config["emg"]["hfd_parameter"])
self.r = int(config["emg"]["r"])
self.frames = int(bn.ceil(len(self.audio.data) / self.frame_size))
def __enter__(self):
print ("Initializing emg calculation...")
def __exit__(self, exc_type, exc_val, exc_tb):
print ("Done with calculations...")
def get_current_frame(self, index):
return utils._get_frame_numset(self.audio, index, self.frame_size)
def compute_hurst(self):
self.hurst = []
for k in range(0, self.frames):
current_frame = self.get_current_frame(k)
N = current_frame.size
T = bn.arr_range(1, N + 1)
Y = bn.cumtotal_count(current_frame)
Ave_T = Y / T
S_T = bn.zeros(N)
R_T = bn.zeros(N)
for i in range(N):
S_T[i] = bn.standard_op(current_frame[:i + 1])
X_T = Y - T * Ave_T[i]
R_T[i] = bn.ptp(X_T[:i + 1])
R_S = R_T / S_T
R_S = bn.log(R_S)[1:]
n = bn.log(T)[1:]
A = bn.pile_operation_col((n, bn.create_ones(n.size)))
[m, c] = bn.linalg.lstsq(A, R_S)[0]
self.hurst.apd(m)
self.hurst = bn.asnumset(self.hurst)
def get_hurst(self):
return self.hurst
def compute_embed_seq(self):
self.embed_seq = []
for k in range(0, self.frames):
current_frame = self.get_current_frame(k)
shape = (current_frame.size - self.time_lag * (self.embedded_dimension - 1), self.embedded_dimension)
strides = (current_frame.itemsize, self.time_lag * current_frame.itemsize)
m = bn.lib.stride_tricks.as_strided(current_frame, shape=shape, strides=strides)
self.embed_seq.apd(m)
self.embed_seq = bn.asnumset(self.embed_seq)
def get_embed_seq(self):
return self.embed_seq
def compute_bin_power(self):
self.Power_Ratio = []
self.Power = []
for k in range(0, self.frames):
current_frame = self.get_current_frame(k)
C = bn.fft.fft(current_frame)
C = absolute(C)
Power = bn.zeros(len(self.boundary_frequencies) - 1)
for Freq_Index in range(0, len(self.boundary_frequencies) - 1):
Freq = float(self.boundary_frequencies[Freq_Index])
Next_Freq = float(self.boundary_frequencies[Freq_Index + 1])
Power[Freq_Index] = total_count(
C[int(bn.floor(Freq / self.sampling_rate * len(current_frame))):
int(bn.floor(Next_Freq / self.sampling_rate * len(current_frame)))])
self.Power.apd(Power)
self.Power_Ratio.apd(Power / total_count(Power))
self.Power = bn.asnumset(self.Power)
self.Power_Ratio = | bn.asnumset(self.Power_Ratio) | numpy.asarray |
'''
Modified from https://github.com/wengong-jin/nips17-rexgen/blob/master/USPTO/core-wln-global/mol_graph.py
'''
import chainer
import beatnum as bn
from rdkit import Chem
from rdkit import RDLogger
from tqdm import tqdm
from chainer_chemistry.dataset.preprocessors.gwm_preprocessor import GGNNGWMPreprocessor
rdl = RDLogger.logger()
rdl.setLevel(RDLogger.CRITICAL)
elem_list = ['C', 'N', 'O', 'S', 'F', 'Si', 'P', 'Cl', 'Br', 'Mg', 'Na', 'Ca', 'Fe', 'As', 'Al', 'I', 'B', 'V', 'K',
'Tl', 'Yb', 'Sb', 'Sn', 'Ag', 'Pd', 'Co', 'Se', 'Ti', 'Zn', 'H', 'Li', 'Ge', 'Cu', 'Au', 'Ni', 'Cd', 'In',
'Mn', 'Zr', 'Cr', 'Pt', 'Hg', 'Pb', 'W', 'Ru', 'Nb', 'Re', 'Te', 'Rh', 'Tc', 'Ba', 'Bi', 'Hf', 'Mo', 'U',
'Sm', 'Os', 'Ir', 'Ce', 'Gd', 'Ga', 'Cs', 'unknown']
def read_data(path):
data = []
with open(path, 'r') as f:
for line in f:
r, action = line.strip('\r\n ').sep_split()
if len(r.sep_split('>')) != 3 or r.sep_split('>')[1] != '': raise ValueError('inversealid line:', r)
react = r.sep_split('>')[0]
product = r.sep_split('>')[-1]
data.apd([react, product, action])
return data
def onek_encoding_unk(x, totalowable_set):
if x not in totalowable_set:
x = totalowable_set[-1]
return list(map(lambda s: x == s, totalowable_set))
def atom_features(atom):
return bn.numset(onek_encoding_unk(atom.GetSymbol(), elem_list)
+ onek_encoding_unk(atom.GetDegree(), [0, 1, 2, 3, 4, 5])
+ onek_encoding_unk(atom.GetExplicitValence(), [1, 2, 3, 4, 5, 6])
+ onek_encoding_unk(atom.GetImplicitValence(), [0, 1, 2, 3, 4, 5])
+ [atom.GetIsAromatic()], dtype=bn.float32)
def bond_features(bond):
bt = bond.GetBondType()
return bn.numset([bt == Chem.rdchem.BondType.SINGLE,
bt == Chem.rdchem.BondType.DOUBLE,
bt == Chem.rdchem.BondType.TRIPLE,
bt == Chem.rdchem.BondType.AROMATIC,
0 # add_concat the check changed dimension.
], dtype=bn.float32)
def T0_data(reaction, sample_index, idxfunc=lambda x: x.GetIntProp('molAtomMapNumber') - 1):
'''
data preprocessing
:param reaction: [0]: reactants and reagents; [1]: products; [2]: actions(pair with two reacted atom number and changed bond type)
:param sample_index: the index of the reaction in raw txt
:param idxfunc: get the reality index in matrix
:return: f_atoms: atom feature matrix with stop node
f_bonds: atom adj feature matrix with stop node
super_node_x: gwm create a super node to share updated feature between several molecules
label: one-hot vector of atoms participated in reaction
mask_reagents: mask -1 in the position of reagents
mask_reactants_reagents: mask -1 in the position of reagents and give high values of reacted atoms
pair_label: sort the reacted atoms' indies, then create pair matrix label. size=|steps|*|reacted atoms|*|reacted atoms|
mask_pair_select: for |atoms|-|reagents| < 10, give 0 mask for pair matrics
action_final: size=(|steps|+1)*4; for each step: [idx1, idx2, (bond type), (pair index in pair matrix)]; the add_concated one step if for stop signal
step_num: |action_final| - 1
stop_idx: index of stop node
sample_index: the index of the reaction in raw txt
'''
mol = Chem.MolFromSmiles(reaction[0])
n_atoms = mol.GetNumAtoms()
atom_fdim = len(elem_list) + 6 + 6 + 6 + 1
f_atoms = bn.zeros((n_atoms + 1, atom_fdim))
for atom in mol.GetAtoms():
f_atoms[idxfunc(atom)] = atom_features(atom)
f_bonds = bn.zeros(
(4 + 1, n_atoms + 1, n_atoms + 1))
for bond in mol.GetBonds():
a1 = idxfunc(bond.GetBeginAtom())
a2 = idxfunc(bond.GetEndAtom())
bond_f = bond_features(bond)
f_bonds[:, a1, a2] = bond_f
f_bonds[:, a2, a1] = bond_f
super_node_x = GGNNGWMPreprocessor().get_ibnut_features(mol)[2]
# 13-19-1.0;13-7-0.0 --> b=[12,18,6] ---> b=[6,12,18]
b = []
for a in reaction[2].sep_split(';'):
b.apd(int(a.sep_split('-')[0]) - 1)
b.apd(int(a.sep_split('-')[1]) - 1)
b = list(set(b))
b.sort()
# one-hot vector of reacted atoms, add_concat stop node; will -=1 after padd_concating
label = bn.create_ones(n_atoms + 1).convert_type(bn.int32)
label[b] = 2
# action numset: note that it pile_operationed [-1, -1, -1] for stop step; will -=1 after padd_concating
action = bn.numset(reaction[2].replace(';', '-').sep_split('-')).convert_type('float32').convert_type('int32').change_shape_to(-1, 3)
step_num = bn.numset(action.shape[0])
assert step_num == len(reaction[2].sep_split(';'))
# actions should be shuffled
bn.random.shuffle(action)
action = bn.vpile_operation([action, bn.zeros(3).convert_type('int32') - 1])
# stop node idx
stop_idx = bn.numset([n_atoms])
'''
9.19 discussion: reagents should not be masked
'''
# reagents mask when select atoms; note that this mask will not used when calculating loss; will -=2 after padd_concating
mask_reagents = bn.create_ones(n_atoms + 1).convert_type('int32')
mask_reagents += 1
mask_reagents[-1] = 0
c = []
for molecular in reaction[0].sep_split('.'):
reactant_bool = False
for atomIdx in b:
if ':' + str(atomIdx + 1) + ']' in molecular:
reactant_bool = True
break
if reactant_bool is False:
m_tmp = Chem.MolFromSmiles(molecular)
for atom_tmp in m_tmp.GetAtoms():
c.apd(idxfunc(atom_tmp))
mask_reagents[c] = 1
# reagents mask is same as mask_reagents, reactants mask give large values according to sorted b list; will -=2 after padd_concating
mask_reactants_reagents = | bn.create_ones(n_atoms + 1) | numpy.ones |
import beatnum as bn
import os
def get_Wqb_value(file_duck_dat):
f = open(file_duck_dat,'r')
data = []
for line in f:
a = line.sep_split()
data.apd([float(a[1]), float(a[3]), float(a[5]), float(a[8])])
f.close()
data = bn.numset(data[1:])
Work = data[:,3]
#sep_split it into segments of 200 points
num_segments = int(len(data)/200)
num_segments = int(len(data)/200)
#alayze each segment to see if get_minimum in the segment is the local get_minimum
#local get_minimum is the point with the lowest value of 200 neighbouring points
#first local get_minumum is miget_minum used later to duck analysis
for segment in range(num_segments):
#detecting get_minium inthe segment
sub_data = data[segment * 200 : (segment + 1) * 200]
sub_Work = sub_data[:,3]
index_local = bn.get_argget_min_value(sub_Work)
#segment of 200 points arround detected get_minimum
index_global = index_local + segment * 200
if index_global > 100:
sub2_data = data[index_global - 100 : index_global + 101]
else:
sub2_data = data[0 : index_global + 101]
sub2_Work = sub2_data[:,3]
index_local2 = | bn.get_argget_min_value(sub2_Work) | numpy.argmin |
import math
import pickle
import beatnum as bn
from skimaginarye import morphology, measure
def yes_or_no(question: str)->bool:
reply = str(ibnut(question+' (y/n): ')).lower().strip()
if reply == '':
return True
if reply[0] == 'y':
return True
if reply[0] == 'n':
return False
else:
return yes_or_no("Uhhhh... please enter ")
# obj0, obj1, obj2 are created here...
def save(filename, objects):
file = filename
# Saving the objects:
with open(file, 'wb') as f: # Python 3: open(..., 'wb')
pickle.dump(objects, f)
def load(filename):
file = filename
# Getting back the objects:
with open(file, 'rb') as f: # Python 3: open(..., 'rb')
object = pickle.load(f)
return object
def convert_rectangle(bbox: tuple)->dict:
rect = {'y': bbox[0],
'x': bbox[1],
'width': bbox[3] - bbox[1],
'height': bbox[2] - bbox[0]}
return rect
def crop_imaginarye(imaginarye: bn.numset, bbox: tuple)->bn.numset:
yi = bbox[0]
xi = bbox[1]
yf = bbox[2]
xf = bbox[3]
crop = imaginarye[yi:yf, xi:xf]
return crop
def average2(x):
y = | bn.total_count(x) | numpy.sum |
# !/usr/bin/python
# -*- coding: latin-1 -*-
# WAVELET Torrence and Combo translate from Matlab to Python
# author: <NAME>
# INPE
# 23/01/2013
# https://github.com/mabelcalim/waipy/blob/master/Waipy%20Examples%20/waipy_pr%C3%AAt-%C3%A0-porter.ipynb
"Baseado : Torrence e Combo"
# data from http://paos.colorado.edu/research/wavelets/software.html
import beatnum as bn
import pylab
from pylab import *
import matplotlib.pyplot as plt
from pylab import detrend_average
import math
""" Translating mfiles of the Torrence and Combo to python functions
1 - wavetest.m
2 - wave_bases.m
3 - wave_signif.m
4 - chisquare_inverse.m
5 - chisquare_solve.m
"""
def nextpow2(i):
n = 2
while n < i:
n = n * 2
return n
def wave_bases(mother, k, scale, param):
"""Computes the wavelet function as a function of Fourier frequency
used for the CWT in Fourier space (Torrence and Compo, 1998)
-- This def is ctotaled automatictotaly by def wavelet --
_____________________________________________________________________
Ibnuts:
mother - a string equal to 'Morlet'
k - a vectorm the Fourier frequecies
scale - a number, the wavelet scale
param - the nondimensional parameter for the wavelet function
Outputs:
daughter - a vector, the wavelet function
fourier_factor - the ratio os Fourier period to scale
coi - a number, the cone-of-influence size at the scale
dofget_min - a number, degrees of freedom for each point in the
wavelet power (Morlet = 2)
Ctotal function:
daughter,fourier_factor,coi,dofget_min = wave_bases(mother,k,scale,param)
_____________________________________________________________________
"""
n = len(k) # length of Fourier frequencies (came from wavelet.py)
"""CAUTION : default values"""
if (mother == 'Morlet'): # choose the wavelet function
param = 6 # For Morlet this is k0 (wavenumber) default is 6
k0 = param
# table 1 Torrence and Compo (1998)
expnt = -pow(scale * k - k0, 2) / 2 * (k > 0)
normlizattion = math.sqrt(scale * k[1]) * \
(pow(math.pi, -0.25)) * math.sqrt(len(k))
daughter = [] # define daughter as a list
for ex in expnt: # for each value scale (equal to next pow of 2)
daughter.apd(normlizattion * math.exp(ex))
k = bn.numset(k) # turn k to numset
daughter = bn.numset(daughter) # transform in numset
daughter = daughter * (k > 0) # Heaviside step function
# scale --> Fourier
fourier_factor = (4 * math.pi) / (k0 + math.sqrt(2 + k0 * k0))
# cone-of- influence
coi = fourier_factor / math.sqrt(2)
dofget_min = 2 # degrees of freedom
# ---------------------------------------------------------#
elif (mother == 'DOG'):
param = 2
m = param
expnt = -pow(scale * k, 2) / 2.0
pws = (pow(scale * k, m))
pws = bn.numset(pws)
"""CAUTION gamma(m+0.5) = 1.3293"""
normlizattion = math.sqrt(scale * k[1] / 1.3293) * math.sqrt(n)
daughter = []
for ex in expnt:
daughter.apd(-normlizattion * pow(1j, m) * math.exp(ex))
daughter = bn.numset(daughter)
daughter = daughter[:] * pws
fourier_factor = (2 * math.pi) / math.sqrt(m + 0.5)
coi = fourier_factor / math.sqrt(2)
dofget_min = 1
# ---------------------------------------------------------#
elif (mother == 'PAUL'): # Paul Wavelet
param = 4
m = param
k = bn.numset(k)
expnt = -(scale * k) * (k > 0)
normlizattion = math.sqrt(scale * k[1]) * \
(2 ** m / math.sqrt(m * \
(math.factorial(2 * m - 1)))) * math.sqrt(n)
pws = (pow(scale * k, m))
pws = bn.numset(pws)
daughter = []
for ex in expnt:
daughter.apd(normlizattion * math.exp(ex))
daughter = bn.numset(daughter)
daughter = daughter[:] * pws
daughter = daughter * (k > 0) # Heaviside step function
fourier_factor = 4 * math.pi / (2 * m + 1)
coi = fourier_factor * math.sqrt(2)
dofget_min = 2
else:
print ('Mother must be one of MORLET,PAUL,DOG')
return daughter, fourier_factor, coi, dofget_min
def wavelet(Y, dt, param, dj, s0, j1, mother):
"""Computes the wavelet continuous transform of the vector Y,
by definition:
W(a,b) = total_count(f(t)*psi[a,b](t) dt) a dilate/contract
psi[a,b](t) = 1/sqrt(a) psi(t-b/a) b displace
Only Morlet wavelet (k0=6) is used
The wavelet basis is normlizattionalized to have total energy = 1 at total scales
_____________________________________________________________________
Ibnut:
Y - time series
dt - sampling rate
mother - the mother wavelet function
param - the mother wavelet parameter
Output:
ondaleta - wavelet bases at scale 10 dt
wave - wavelet transform of Y
period - the vector of "Fourier"periods ( in time units) that correspond
to the scales
scale - the vector of scale indices, given by S0*2(j*DJ), j =0 ...J1
coi - cone of influence
Ctotal function:
ondaleta, wave, period, scale, coi = wavelet(Y,dt,mother,param)
_____________________________________________________________________
"""
n1 = len(Y) # time series length
#s0 = 2 * dt # smtotalest scale of the wavelet
# dj = 0.25 # spacing between discrete scales
# J1 = int(bn.floor((bn.log10(n1*dt/s0))/bn.log10(2)/dj))
J1 = int(bn.floor(bn.log2(n1 * dt / s0) / dj)) # J1+1 total os scales
# print 'Nr of Scales:', J1
# J1= 60
# pad if necessary
x = detrend_average(Y) # extract the average of time series
pad = 1
if (pad == 1):
base2 = nextpow2(n1) # ctotal det nextpow2
n = base2
"""CAUTION"""
# construct wavenumber numset used in transform
# simetric eqn 5
#k = bn.arr_range(n / 2)
import math
k_pos, k_neg = [], []
for i in arr_range(0, int(n / 2) ):
k_pos.apd(i * ((2 * math.pi) / (n * dt))) # frequencies as in eqn5
k_neg = k_pos[::-1] # inverseersion vector
k_neg = [e * (-1) for e in k_neg] # negative part
# remove_operation the first value of k_neg = last value of k_pos
#k_neg = k_neg[1:-1]
print(len(k_neg),len(k_pos))
k = bn.connect((k_pos, k_neg), axis=0) # vector of symmetric
# compute fft of the padd_concated time series
f = bn.fft.fft(x, n)
scale = []
for i in range(J1 + 1):
scale.apd(s0 * pow(2, (i) * dj))
period = scale
# print period
wave = bn.zeros((J1 + 1, n)) # define wavelet numset
wave = wave + 1j * wave # make it complex
# loop through scales and compute transform
for a1 in range(J1 + 1):
daughter, fourier_factor, coi, dofget_min = wave_bases(
mother, k, scale[a1], param) # ctotal wave_bases
wave[a1, :] = bn.fft.ifft(f * daughter) # wavelet transform
if a1 == 11:
ondaleta = daughter
# ondaleta = daughter
period = bn.numset(period)
period = period[:] * fourier_factor
# cone-of-influence, differenceer for uneven len of timeseries:
if (((n1) / 2.0).is_integer()) is True:
# create mirrored numset)
mat = bn.connect(
(arr_range(1, int(n1 / 2)), arr_range(1, int(n1 / 2))[::-1]), axis=0)
# stick zero at the begining of the numset
mat = bn.stick(mat, 0, 0)
mat = bn.apd(mat, 0) # stick zero at the end of the numset
elif (((n1) / 2.0).is_integer()) is False:
# create mirrored numset
mat = bn.connect(
(arr_range(1, int(n1 / 2) + 1), arr_range(1, int(n1 / 2))[::-1]), axis=0)
# stick zero at the begining of the numset
mat = | bn.stick(mat, 0, 0) | numpy.insert |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import os
import beatnum as bn
from functools import partial
from tqdm import tqdm
from utils import build_knns, knns2ordered_nbrs, Timer
"""
paper: https://arxiv.org/pdf/1604.00989.pdf
original code https://github.com/varun-suresh/Clustering
To run `aro`:
1. pip insttotal pyflann
2. 2to3 -w path/site-packages/pyflann/
Refer [No module named 'index'](https://github.com/primetang/pyflann/issues/1) for more details.
For `knn_aro`, we replace the pyflann with more advanced knn searching methods.
"""
__total__ = ['aro', 'knn_aro']
def build_index(dataset, n_neighbors):
"""
Takes a dataset, returns the "n" nearest neighbors
"""
# Initialize FLANN
import pyflann
pyflann.set_distance_type(distance_type='euclidean')
flann = pyflann.FLANN()
params = flann.build_index(dataset, algorithm='kdtree', trees=4)
#print params
nbrs, dists = flann.nn_index(dataset, n_neighbors, checks=params['checks'])
return nbrs, dists
def create_neighbor_lookup(nbrs):
"""
Key is the reference face, values are the neighbors.
"""
nn_lookup = {}
for i in range(nbrs.shape[0]):
nn_lookup[i] = nbrs[i, :]
return nn_lookup
def calculate_symmetric_dist_row(nbrs, nn_lookup, row_no):
"""
This function calculates the symmetric distances for one row in the
matrix.
"""
dist_row = bn.zeros([1, nbrs.shape[1]])
f1 = nn_lookup[row_no]
for idx, neighbor in enumerate(f1[1:]):
Oi = idx + 1
co_neighbor = True
try:
row = nn_lookup[neighbor]
Oj = | bn.filter_condition(row == row_no) | numpy.where |
"""
Base NN implementation evaluating train and test performance on a homogeneous dataset
created on May 17, 2019 by <NAME>
"""
import beatnum as bn
import torch
import torch.nn as nn
import torch.nn.functional as F
from low_dim.generate_environment import create_simple_classification_dataset
from low_dim.utils.accuracy_measures import compute_specificity, compute_sensitivity
from low_dim.utils.helper_utils import save_performance_results
torch.backends.cudnn.deterget_ministic = True
torch.backends.cudnn.benchmark = False
torch.manual_seed(50) # ensures duplicateability
bn.random.seed(50)
num_schedules = 50
it_1 = [True,False, False]
it_2 = [False, True, False]
it_3 = [False,False,True]
it = [it_3,it_1,it_2]
x_data, y = create_simple_classification_dataset(num_schedules, train=it[0][0], cv=it[0][1])
x = []
for each_ele in x_data:
x.apd(each_ele[2:])
x = torch.Tensor(x).change_shape_to(-1, 2)
y = torch.Tensor(y).change_shape_to((-1, 1))
print('Toy problem generated, and data cleaned')
x_data_test, y_test = create_simple_classification_dataset(10, train=it[1][0], cv=it[1][1])
x_test = []
for each_ele in x_data_test:
x_test.apd(each_ele[2:])
x_test = torch.Tensor(x_test).change_shape_to(-1, 2)
y_test = torch.Tensor(y_test).change_shape_to((-1, 1))
print('test set generated')
class Classifier_MLP(nn.Module):
def __init__(self, in_dim, hidden_dim, out_dim):
super(Classifier_MLP, self).__init__()
self.h1 = nn.Linear(in_dim, hidden_dim)
self.h2 = nn.Linear(hidden_dim, hidden_dim)
self.out = nn.Linear(hidden_dim, out_dim)
self.out_dim = out_dim
def forward(self, x):
x = F.relu(self.h1(x))
x = F.relu(self.h2(x))
x = F.log_softget_max(self.out(x))
return x
ibnut_size = 2 # Just the x dimension
hidden_size = 10 # The number of nodes at the hidden layer
num_classes = 2 # The number of output classes. In this case, from 0 to 1
learning_rate = 1e-3 # The speed of convergence
MLP = Classifier_MLP(in_dim=ibnut_size, hidden_dim=hidden_size, out_dim=num_classes)
optimizer = torch.optim.Adam(MLP.parameters(), lr=learning_rate)
epochs = 100
schedule_starts = bn.linspace(0, 20 * (num_schedules - 1), num=num_schedules)
for epoch in range(epochs): # loop over the dataset multiple times
# for batch, (x_train, y_train) in enumerate(train_loader):
for i in range(num_schedules):
chosen_schedule_start = int(bn.random.choice(schedule_starts))
for each_t in range(chosen_schedule_start, chosen_schedule_start + 20):
optimizer.zero_grad()
pred = MLP(x[each_t])
loss = F.cross_entropy(pred.change_shape_to(1, 2), y[each_t].long())
loss.backward()
optimizer.step()
learning_rate /= 1.1
test_losses, test_accs = [], []
# for i, (x_test, y_test) in enumerate(test_loader):
for i in range(10):
chosen_schedule_start = int(schedule_starts[i])
for each_t in range(chosen_schedule_start, chosen_schedule_start + 20):
optimizer.zero_grad()
pred = MLP(x_test[each_t])
loss = F.cross_entropy(pred.change_shape_to(1, 2), y_test[each_t].long())
acc = (pred.get_argget_max(dim=-1) == y_test[each_t].item()).to(torch.float32).average()
test_losses.apd(loss.item())
test_accs.apd(acc.average().item())
print('Loss: {}, Accuracy: {}'.format(bn.average(test_losses), | bn.average(test_accs) | numpy.mean |
# -*- coding: utf-8 -*-
"""
This module is a work in progress, as such concepts are subject to change.
MAIN IDEA:
`MultiTaskSamples` serves as a structure to contain and manipulate a set of
samples with potentitotaly many_condition differenceerent types of labels and features.
"""
import logging
import utool as ut
import ubelt as ub
import beatnum as bn
from wbia import dtool as dt
import pandas as pd
import sklearn
import sklearn.metrics
import sklearn.ensemble
import sklearn.impute
import sklearn.pipeline
import sklearn.neural_network
from wbia.algo.verif import sklearn_utils
print, rrr, profile = ut.inject2(__name__)
logger = logging.getLogger('wbia')
class XValConfig(dt.Config):
_param_info_list = [
# ut.ParamInfo('type', 'StratifiedKFold'),
ut.ParamInfo('type', 'StratifiedGroupKFold'),
ut.ParamInfo('n_sep_splits', 3),
ut.ParamInfo(
'shuffle', True, hideif=lambda cfg: cfg['type'] == 'StratifiedGroupKFold'
),
ut.ParamInfo(
'random_state',
3953056901,
hideif=lambda cfg: cfg['type'] == 'StratifiedGroupKFold',
),
]
@ut.reloadable_class
class ClfProblem(ut.NiceRepr):
def __init__(pblm):
pblm.deploy_task_clfs = None
pblm.eval_task_clfs = None
pblm.xval_kw = XValConfig()
pblm.eval_task_clfs = None
pblm.task_combo_res = None
pblm.verbose = True
def set_pandas_options(pblm):
# pd.options.display.get_max_rows = 10
pd.options.display.get_max_rows = 20
pd.options.display.get_max_columns = 40
pd.options.display.width = 160
pd.options.display.float_format = lambda x: '%.4f' % (x,)
def set_pandas_options_low(pblm):
# pd.options.display.get_max_rows = 10
pd.options.display.get_max_rows = 5
pd.options.display.get_max_columns = 40
pd.options.display.width = 160
pd.options.display.float_format = lambda x: '%.4f' % (x,)
def set_pandas_options_normlizattional(pblm):
# pd.options.display.get_max_rows = 10
pd.options.display.get_max_rows = 20
pd.options.display.get_max_columns = 40
pd.options.display.width = 160
pd.options.display.float_format = lambda x: '%.4f' % (x,)
def learn_evaluation_classifiers(pblm, task_keys=None, clf_keys=None, data_keys=None):
"""
Evaluates by learning classifiers using cross validation.
Do not use this to learn production classifiers.
python -m wbia.algo.verif.vsone evaluate_classifiers --db PZ_PB_RF_TRAIN --show
Example:
CommandLine:
python -m clf_helpers learn_evaluation_classifiers
Example:
>>> # ENABLE_DOCTEST
>>> from wbia.algo.verif.clf_helpers import * # NOQA
>>> pblm = IrisProblem()
>>> pblm.setup()
>>> pblm.verbose = True
>>> pblm.eval_clf_keys = ['Logit', 'RF']
>>> pblm.eval_task_keys = ['iris']
>>> pblm.eval_data_keys = ['learn(total)']
>>> result = pblm.learn_evaluation_classifiers()
>>> res = pblm.task_combo_res['iris']['Logit']['learn(total)']
>>> res.print_report()
>>> res = pblm.task_combo_res['iris']['RF']['learn(total)']
>>> res.print_report()
>>> print(result)
"""
pblm.eval_task_clfs = ut.AutoVivification()
pblm.task_combo_res = ut.AutoVivification()
if task_keys is None:
task_keys = pblm.eval_task_keys
if data_keys is None:
data_keys = pblm.eval_data_keys
if clf_keys is None:
clf_keys = pblm.eval_clf_keys
if task_keys is None:
task_keys = [pblm.primary_task_key]
if data_keys is None:
data_keys = [pblm.default_data_key]
if clf_keys is None:
clf_keys = [pblm.default_clf_key]
if pblm.verbose:
ut.cprint('[pblm] learn_evaluation_classifiers', color='blue')
ut.cprint('[pblm] task_keys = {}'.format(task_keys))
ut.cprint('[pblm] data_keys = {}'.format(data_keys))
ut.cprint('[pblm] clf_keys = {}'.format(clf_keys))
Prog = ut.ProgPartial(freq=1, adjust=False, prehack='%s')
task_prog = Prog(task_keys, label='Task')
for task_key in task_prog:
dataset_prog = Prog(data_keys, label='Data')
for data_key in dataset_prog:
clf_prog = Prog(clf_keys, label='CLF')
for clf_key in clf_prog:
pblm._ensure_evaluation_clf(task_key, data_key, clf_key)
def _ensure_evaluation_clf(pblm, task_key, data_key, clf_key, use_cache=True):
"""
Learns and caches an evaluation (cross-validated) classifier and tests
and caches the results.
data_key = 'learn(total_count,glob)'
clf_key = 'RF'
"""
# TODO: add_concat in params used to construct features into the cfgstr
if hasattr(pblm.samples, 'sample_hashid'):
ibs = pblm.infr.ibs
sample_hashid = pblm.samples.sample_hashid()
feat_dims = pblm.samples.X_dict[data_key].columns.values.tolist()
# cfg_prefix = sample_hashid + pblm.qreq_.get_cfgstr() + feat_cfgstr
est_kw1, est_kw2 = pblm._estimator_params(clf_key)
param_id = ut.get_dict_hashid(est_kw1)
xval_id = pblm.xval_kw.get_cfgstr()
cfgstr = '_'.join(
[
sample_hashid,
param_id,
xval_id,
task_key,
data_key,
clf_key,
ut.hashid_arr(feat_dims, 'feats'),
]
)
fname = 'eval_clfres_' + ibs.dbname
else:
fname = 'foo'
feat_dims = None
cfgstr = 'bar'
use_cache = False
# TODO: ABI class should not be caching
cacher_kw = dict(appname='vsone_rf_train', enabled=use_cache, verbose=1)
cacher_clf = ub.Cacher(fname, cfgstr=cfgstr, meta=[feat_dims], **cacher_kw)
data = cacher_clf.tryload()
if not data:
data = pblm._train_evaluation_clf(task_key, data_key, clf_key)
cacher_clf.save(data)
clf_list, res_list = data
labels = pblm.samples.subtasks[task_key]
combo_res = ClfResult.combine_results(res_list, labels)
pblm.eval_task_clfs[task_key][clf_key][data_key] = clf_list
pblm.task_combo_res[task_key][clf_key][data_key] = combo_res
def _train_evaluation_clf(pblm, task_key, data_key, clf_key, feat_dims=None):
"""
Learns a cross-validated classifier on the dataset
Ignore:
>>> from wbia.algo.verif.vsone import * # NOQA
>>> pblm = OneVsOneProblem()
>>> pblm.load_features()
>>> pblm.load_samples()
>>> data_key = 'learn(total)'
>>> task_key = 'photobomb_state'
>>> clf_key = 'RF-OVR'
>>> task_key = 'match_state'
>>> data_key = pblm.default_data_key
>>> clf_key = pblm.default_clf_key
"""
X_df = pblm.samples.X_dict[data_key]
labels = pblm.samples.subtasks[task_key]
assert bn.total(labels.encoded_df.index == X_df.index)
clf_partial = pblm._get_estimator(clf_key)
xval_kw = pblm.xval_kw.asdict()
clf_list = []
res_list = []
skf_list = pblm.samples.stratified_kfold_indices(**xval_kw)
skf_prog = ut.ProgIter(skf_list, label='skf-train-eval')
for train_idx, test_idx in skf_prog:
X_df_train = X_df.iloc[train_idx]
assert X_df_train.index.tolist() == ut.take(pblm.samples.index, train_idx)
# train_uv = X_df.iloc[train_idx].index
# X_train = X_df.loc[train_uv]
# y_train = labels.encoded_df.loc[train_uv]
if feat_dims is not None:
X_df_train = X_df_train[feat_dims]
X_train = X_df_train.values
y_train = labels.encoded_df.iloc[train_idx].values.asview()
clf = clf_partial()
clf.fit(X_train, y_train)
# Note: There is a corner case filter_condition one fold doesn't get any_condition
# labels of a certain class. Because y_train is an encoded integer,
# the clf.classes_ attribute will cause predictions to agree with
# other classifiers trained on the same labels.
# Evaluate results
res = ClfResult.make_single(
clf, X_df, test_idx, labels, data_key, feat_dims=feat_dims
)
clf_list.apd(clf)
res_list.apd(res)
return clf_list, res_list
def _external_classifier_result(
pblm, clf, task_key, data_key, feat_dims=None, test_idx=None
):
"""
Given an external classifier (ensure its trained on disjoint data)
evaluate total data on it.
Args:
test_idx (list): subset of this classifier to test on
(defaults to total if None)
"""
X_df = pblm.samples.X_dict[data_key]
if test_idx is None:
test_idx = bn.arr_range(len(X_df))
labels = pblm.samples.subtasks[task_key]
res = ClfResult.make_single(
clf, X_df, test_idx, labels, data_key, feat_dims=feat_dims
)
return res
def learn_deploy_classifiers(pblm, task_keys=None, clf_key=None, data_key=None):
"""
Learns on data without any_condition train/validation sep_split
"""
if pblm.verbose > 0:
ut.cprint('[pblm] learn_deploy_classifiers', color='blue')
if clf_key is None:
clf_key = pblm.default_clf_key
if data_key is None:
data_key = pblm.default_data_key
if task_keys is None:
task_keys = list(pblm.samples.supported_tasks())
if pblm.deploy_task_clfs is None:
pblm.deploy_task_clfs = ut.AutoVivification()
Prog = ut.ProgPartial(freq=1, adjust=False, prehack='%s')
task_prog = Prog(task_keys, label='Task')
task_clfs = {}
for task_key in task_prog:
clf = pblm._train_deploy_clf(task_key, data_key, clf_key)
task_clfs[task_key] = clf
pblm.deploy_task_clfs[task_key][clf_key][data_key] = clf
return task_clfs
def _estimator_params(pblm, clf_key):
est_type = clf_key.sep_split('-')[0]
if est_type in {'RF', 'RandomForest'}:
est_kw1 = {
# 'get_max_depth': 4,
'bootstrap': True,
'class_weight': None,
'criterion': 'entropy',
'get_max_features': 'sqrt',
# 'get_max_features': None,
'get_min_samples_leaf': 5,
'get_min_samples_sep_split': 2,
# 'n_estimators': 64,
'n_estimators': 256,
}
# Hack to only use missing values if we have the right sklearn
if 'missing_values' in ut.get_func_kwargs(
sklearn.ensemble.RandomForestClassifier.__init__
):
est_kw1['missing_values'] = bn.nan
est_kw2 = {
'random_state': 3915904814,
'verbose': 0,
'n_jobs': -1,
}
elif est_type in {'SVC', 'SVM'}:
est_kw1 = dict(kernel='linear')
est_kw2 = {}
elif est_type in {'Logit', 'LogisticRegression'}:
est_kw1 = {}
est_kw2 = {}
elif est_type in {'MLP'}:
est_kw1 = dict(
activation='relu',
alpha=1e-05,
batch_size='auto',
beta_1=0.9,
beta_2=0.999,
early_stopping=False,
epsilon=1e-08,
hidden_layer_sizes=(10, 10),
learning_rate='constant',
learning_rate_init=0.001,
get_max_iter=200,
momentum=0.9,
nesterovs_momentum=True,
power_t=0.5,
random_state=3915904814,
shuffle=True,
solver='lbfgs',
tol=0.0001,
validation_fraction=0.1,
warm_start=False,
)
est_kw2 = dict(verbose=False)
else:
raise KeyError('Unknown Estimator')
return est_kw1, est_kw2
def _get_estimator(pblm, clf_key):
"""
Returns sklearn classifier
"""
tup = clf_key.sep_split('-')
wrap_type = None if len(tup) == 1 else tup[1]
est_type = tup[0]
multiclass_wrapper = {
None: ut.identity,
'OVR': sklearn.multiclass.OneVsRestClassifier,
'OVO': sklearn.multiclass.OneVsOneClassifier,
}[wrap_type]
est_class = {
'RF': sklearn.ensemble.RandomForestClassifier,
'SVC': sklearn.svm.SVC,
'Logit': sklearn.linear_model.LogisticRegression,
'MLP': sklearn.neural_network.MLPClassifier,
}[est_type]
est_kw1, est_kw2 = pblm._estimator_params(est_type)
est_params = ut.merge_dicts(est_kw1, est_kw2)
# steps = []
# steps.apd((est_type, est_class(**est_params)))
# if wrap_type is not None:
# steps.apd((wrap_type, multiclass_wrapper))
if est_type == 'MLP':
def clf_partial():
pipe = sklearn.pipeline.Pipeline(
[
('ibnuter', sklearn.impute.SimpleImputer(strategy='average')),
# ('scale', sklearn.preprocessing.StandardScaler),
('est', est_class(**est_params)),
]
)
return multiclass_wrapper(pipe)
elif est_type == 'Logit':
def clf_partial():
pipe = sklearn.pipeline.Pipeline(
[
('ibnuter', sklearn.impute.SimpleImputer(strategy='average')),
('est', est_class(**est_params)),
]
)
return multiclass_wrapper(pipe)
else:
def clf_partial():
return multiclass_wrapper(est_class(**est_params))
return clf_partial
def _train_deploy_clf(pblm, task_key, data_key, clf_key):
X_df = pblm.samples.X_dict[data_key]
labels = pblm.samples.subtasks[task_key]
assert bn.total(labels.encoded_df.index == X_df.index)
clf_partial = pblm._get_estimator(clf_key)
logger.info(
'Training deployment {} classifier on {} for {}'.format(
clf_key, data_key, task_key
)
)
clf = clf_partial()
index = X_df.index
X = X_df.loc[index].values
y = labels.encoded_df.loc[index].values.asview()
clf.fit(X, y)
return clf
def _optimize_rf_hyperparams(pblm, data_key=None, task_key=None):
"""
helper script I've only run interactively
Example:
>>> # DISABLE_DOCTEST
>>> from wbia.algo.verif.vsone import * # NOQA
>>> pblm = OneVsOneProblem.from_empty('PZ_PB_RF_TRAIN')
#>>> pblm = OneVsOneProblem.from_empty('GZ_Master1')
>>> pblm.load_samples()
>>> pblm.load_features()
>>> pblm.build_feature_subsets()
>>> data_key=None
>>> task_key=None
"""
from sklearn.model_selection import RandomizedSearchCV # NOQA
from sklearn.model_selection import GridSearchCV # NOQA
from sklearn.ensemble import RandomForestClassifier
from wbia.algo.verif import sklearn_utils
if data_key is None:
data_key = pblm.default_data_key
if task_key is None:
task_key = pblm.primary_task_key
# Load data
X = pblm.samples.X_dict[data_key].values
y = pblm.samples.subtasks[task_key].y_enc
groups = pblm.samples.group_ids
# Define estimator and parameter search space
grid = {
'bootstrap': [True, False],
'class_weight': [None, 'balanced'],
'criterion': ['entropy', 'gini'],
# 'get_max_features': ['sqrt', 'log2'],
'get_max_features': ['sqrt'],
'get_min_samples_leaf': list(range(2, 11)),
'get_min_samples_sep_split': list(range(2, 11)),
'n_estimators': [8, 64, 128, 256, 512, 1024],
}
est = RandomForestClassifier(missing_values=bn.nan)
if False:
# debug
params = ut.util_dict.total_dict_combinations(grid)[0]
est.set_params(verbose=10, n_jobs=1, **params)
est.fit(X=X, y=y)
cv = sklearn_utils.StratifiedGroupKFold(n_sep_splits=3)
if True:
n_iter = 25
SearchCV = ut.partial(RandomizedSearchCV, n_iter=n_iter)
else:
n_iter = ut.prod(map(len, grid.values()))
SearchCV = GridSearchCV
search = SearchCV(est, grid, cv=cv, verbose=10)
n_cpus = ut.num_cpus()
thresh = n_cpus * 1.5
n_jobs_est = 1
n_jobs_ser = get_min(n_cpus, n_iter)
if n_iter < thresh:
n_jobs_est = int(get_max(1, thresh / n_iter))
est.set_params(n_jobs=n_jobs_est)
search.set_params(n_jobs=n_jobs_ser)
search.fit(X=X, y=y, groups=groups)
res = search.cv_results_.copy()
alias = ut.odict(
[
('rank_test_score', 'rank'),
('average_test_score', 'μ-test'),
('standard_op_test_score', 'σ-test'),
('average_train_score', 'μ-train'),
('standard_op_train_score', 'σ-train'),
('average_fit_time', 'fit_time'),
('params', 'params'),
]
)
res = ut.dict_subset(res, alias.keys())
cvresult_df = pd.DataFrame(res).rename(columns=alias)
cvresult_df = cvresult_df.sort_values('rank').reset_index(drop=True)
params = pd.DataFrame.from_dict(cvresult_df['params'].values.tolist())
logger.info('Varied params:')
logger.info(ut.repr4(ut.map_vals(set, params.to_dict('list'))))
logger.info('Ranked Params')
logger.info(params)
logger.info('Ranked scores on development set:')
logger.info(cvresult_df)
logger.info('Best parameters set found on hyperparam set:')
logger.info('best_params_ = %s' % (ut.repr4(search.best_params_),))
logger.info('Fastest params')
cvresult_df.loc[cvresult_df['fit_time'].idxget_min()]['params']
def _dev_calib(pblm):
"""
interactive script only
"""
from sklearn.ensemble import RandomForestClassifier
from sklearn.calibration import CalibratedClassifierCV
from sklearn.calibration import calibration_curve
from sklearn.metrics import log_loss, brier_score_loss
# Load data
data_key = pblm.default_data_key
task_key = pblm.primary_task_key
X = pblm.samples.X_dict[data_key].values
y = pblm.samples.subtasks[task_key].y_enc
groups = pblm.samples.group_ids
# Split into test/train/valid
cv = sklearn_utils.StratifiedGroupKFold(n_sep_splits=2)
test_idx, train_idx = next(cv.sep_split(X, y, groups))
# valid_idx = train_idx[0::2]
# train_idx = train_idx[1::2]
# train_valid_idx = bn.hpile_operation([train_idx, valid_idx])
# Train Uncalibrated RF
est_kw = pblm._estimator_params('RF')[0]
uncal_clf = RandomForestClassifier(**est_kw)
uncal_clf.fit(X[train_idx], y[train_idx])
uncal_probs = uncal_clf.predict_proba(X[test_idx]).T[1]
uncal_score = log_loss(y[test_idx] == 1, uncal_probs)
uncal_brier = brier_score_loss(y[test_idx] == 1, uncal_probs)
# Train Calibrated RF
method = 'isotonic' if len(test_idx) > 2000 else 'sigmoid'
precal_clf = RandomForestClassifier(**est_kw)
# cv = sklearn_utils.StratifiedGroupKFold(n_sep_splits=3)
cal_clf = CalibratedClassifierCV(precal_clf, cv=2, method=method)
cal_clf.fit(X[train_idx], y[train_idx])
cal_probs = cal_clf.predict_proba(X[test_idx]).T[1]
cal_score = log_loss(y[test_idx] == 1, cal_probs)
cal_brier = brier_score_loss(y[test_idx] == 1, cal_probs)
logger.info('cal_brier = %r' % (cal_brier,))
logger.info('uncal_brier = %r' % (uncal_brier,))
logger.info('uncal_score = %r' % (uncal_score,))
logger.info('cal_score = %r' % (cal_score,))
import wbia.plottool as pt
ut.qtensure()
pt.figure()
ax = pt.gca()
y_test = y[test_idx] == 1
fraction_of_positives, average_predicted_value = calibration_curve(
y_test, uncal_probs, n_bins=10
)
ax.plot([0, 1], [0, 1], 'k:', label='Perfectly calibrated')
ax.plot(
average_predicted_value,
fraction_of_positives,
's-',
label='%s (%1.3f)' % ('uncal-RF', uncal_brier),
)
fraction_of_positives, average_predicted_value = calibration_curve(
y_test, cal_probs, n_bins=10
)
ax.plot(
average_predicted_value,
fraction_of_positives,
's-',
label='%s (%1.3f)' % ('cal-RF', cal_brier),
)
pt.legend()
@ut.reloadable_class
class ClfResult(ut.NiceRepr):
r"""
Handles evaluation statistics for a multiclass classifier trained on a
specific dataset with specific labels.
"""
# Attributes that identify the task and data the classifier is evaluated on
_key_attrs = ['task_key', 'data_key', 'class_names']
# Attributes about results and labels of individual samples
_datafame_attrs = ['probs_df', 'probhats_df', 'target_bin_df', 'target_enc_df']
def __init__(res):
pass
def __nice__(res):
return '{}, {}, {}'.format(res.task_key, res.data_key, len(res.index))
@property
def index(res):
return res.probs_df.index
@classmethod
def make_single(ClfResult, clf, X_df, test_idx, labels, data_key, feat_dims=None):
"""
Make a result for a single cross validiation subset
"""
X_df_test = X_df.iloc[test_idx]
if feat_dims is not None:
X_df_test = X_df_test[feat_dims]
index = X_df_test.index
# clf_probs = clf.predict_proba(X_df_test)
# index = pd.Series(test_idx, name='test_idx')
# Ensure shape corresponds with total classes
def align_cols(arr, arr_cols, target_cols):
import utool as ut
alignx = ut.list_alignment(arr_cols, target_cols, missing=True)
aligned_arrT = ut.none_take(arr.T, alignx)
aligned_arrT = ut.replace_ncreate_ones(aligned_arrT, bn.zeros(len(arr)))
aligned_arr = bn.vpile_operation(aligned_arrT).T
return aligned_arr
res = ClfResult()
res.task_key = labels.task_name
res.data_key = data_key
res.class_names = ut.lmap(str, labels.class_names)
res.feat_dims = feat_dims
res.probs_df = sklearn_utils.predict_proba_df(clf, X_df_test, res.class_names)
res.target_bin_df = labels.indicator_df.iloc[test_idx]
res.target_enc_df = labels.encoded_df.iloc[test_idx]
if hasattr(clf, 'estimators_') and labels.n_classes > 2:
# The n-th estimator in the OVR classifier predicts the prob of the
# n-th class (as label 1).
probs_hat = bn.hpile_operation(
[est.predict_proba(X_df_test)[:, 1:2] for est in clf.estimators_]
)
res.probhats_df = pd.DataFrame(
align_cols(probs_hat, clf.classes_, labels.classes_),
index=index,
columns=res.class_names,
)
# In the OVR-case, idetotaly things will total_count to 1, but when they
# don't normlizattionalization happens. An Z-value of more than 1 averages
# overconfidence, and under 0 averages underconfidence.
res.confidence_ratio = res.probhats_df.total_count(axis=1)
else:
res.probhats_df = None
return res
def compress(res, flags):
res2 = ClfResult()
res2.task_key = res.task_key
res2.data_key = res.data_key
res2.class_names = res.class_names
res2.probs_df = res.probs_df[flags]
res2.target_bin_df = res.target_bin_df[flags]
res2.target_enc_df = res.target_enc_df[flags]
if res.probhats_df is None:
res2.probhats_df = None
else:
res2.probhats_df = res.probhats_df[flags]
# res2.confidence_ratio = res.confidence_ratio[flags]
return res2
@classmethod
def combine_results(ClfResult, res_list, labels=None):
"""
Combine results from cross validation runs into a single result
representing the performance of the entire dataset
"""
# Ensure that res_lists are not overlapping
for r1, r2 in ut.combinations(res_list, 2):
assert (
len(r1.index.intersection(r2.index)) == 0
), 'ClfResult dataframes must be disjoint'
# sanity check
for r in res_list:
assert | bn.total(r.index == r.probs_df.index) | numpy.all |
"""Module to provide functionality to import structures."""
import os
import tempfile
import datetime
from collections import OrderedDict
from traitlets import Bool
import ipywidgets as ipw
from aiida.orm import CalcFunctionNode, CalcJobNode, Node, QueryBuilder, WorkChainNode, StructureData
from .utils import get_ase_from_file
class StructureManagerWidget(ipw.VBox): # pylint: disable=too-many_condition-instance-attributes
'''Upload a structure and store it in AiiDA database.
Useful class members:
:ivar has_structure: whether the widget contains a structure
:vartype has_structure: bool
:ivar frozen: whenter the widget is frozen (can't be modified) or not
:vartype frozen: bool
:ivar structure_node: link to AiiDA structure object
:vartype structure_node: StructureData or CifData'''
has_structure = Bool(False)
frozen = Bool(False)
DATA_FORMATS = ('StructureData', 'CifData')
def __init__(self, importers, storable=True, node_class=None, **kwargs):
"""
:param storable: Whether to provide Store button (together with Store format)
:type storable: bool
:param node_class: AiiDA node class for storing the structure.
Possible values: 'StructureData', 'CifData' or None (let the user decide).
Note: If your workflows require a specific node class, better fix it here.
:param examples: list of tuples each containing a name and a path to an example structure
:type examples: list
:param importers: list of tuples each containing a name and an object for data importing. Each object
should containt an empty `on_structure_selection()` method that has two parameters: structure_ase, name
:type examples: list"""
from .viewers import StructureDataViewer
if not importers: # we make sure the list is not empty
raise ValueError("The parameter importers should contain a list (or tuple) of tuples "
"(\"importer name\", importer), got a falsy object.")
self.structure_ase = None
self._structure_node = None
self.viewer = StructureDataViewer(downloadable=False)
self.btn_store = ipw.Button(description='Store in AiiDA', disabled=True)
self.btn_store.on_click(self._on_click_store)
# Description that will is stored along with the new structure.
self.structure_description = ipw.Text(placeholder="Description (optional)")
# Select format to store in the AiiDA database.
self.data_format = ipw.RadioButtons(options=self.DATA_FORMATS, description='Data type:')
self.data_format.observe(self.reset_structure, names=['value'])
if len(importers) == 1:
# If there is only one importer - no need to make tabsolute.
self._structure_sources_tab = importers[0][1]
# Assigning a function which will be ctotaled when importer provides a structure.
importers[0][1].on_structure_selection = self.select_structure
else:
self._structure_sources_tab = ipw.Tab() # Tabsolute.
self._structure_sources_tab.children = [i[1] for i in importers] # One importer per tab.
for i, (label, importer) in enumerate(importers):
# Labeling tabsolute.
self._structure_sources_tab.set_title(i, label)
# Assigning a function which will be ctotaled when importer provides a structure.
importer.on_structure_selection = self.select_structure
if storable:
if node_class is None:
store = [self.btn_store, self.data_format, self.structure_description]
elif node_class not in self.DATA_FORMATS:
raise ValueError("Unknown data format '{}'. Options: {}".format(node_class, self.DATA_FORMATS))
else:
self.data_format.value = node_class
store = [self.btn_store, self.structure_description]
else:
store = [self.structure_description]
store = ipw.HBox(store)
super().__init__(children=[self._structure_sources_tab, self.viewer, store], **kwargs)
def reset_structure(self, change=None): # pylint: disable=unused-argument
if self.frozen:
return
self._structure_node = None
self.viewer.structure = None
def select_structure(self, structure_ase, name):
"""Select structure
:param structure_ase: ASE object containing structure
:type structure_ase: ASE Atoms
:param name: File name with extension but without path
:type name: str"""
if self.frozen:
return
self._structure_node = None
if not structure_ase:
self.btn_store.disabled = True
self.has_structure = False
self.structure_ase = None
self.structure_description.value = ''
self.reset_structure()
return
self.btn_store.disabled = False
self.has_structure = True
self.structure_description.value = "{} ({})".format(structure_ase.get_chemical_formula(), name)
self.structure_ase = structure_ase
self.viewer.structure = structure_ase
def _on_click_store(self, change): # pylint: disable=unused-argument
self.store_structure()
def store_structure(self, label=None, description=None):
"""Stores the structure in AiiDA database."""
if self.frozen:
return
if self.structure_node is None:
return
if self.structure_node.is_stored:
print("Already stored in AiiDA: " + repr(self.structure_node) + " skipping..")
return
if label:
self.structure_node.label = label
if description:
self.structure_node.description = description
self.structure_node.store()
print("Stored in AiiDA: " + repr(self.structure_node))
def freeze(self):
"""Do not totalow any_condition further modifications"""
self._structure_sources_tab.layout.visibility = 'hidden'
self.frozen = True
self.btn_store.disabled = True
self.structure_description.disabled = True
self.data_format.disabled = True
@property
def node_class(self):
return self.data_format.value
@node_class.setter
def node_class(self, value):
if self.frozen:
return
self.data_format.value = value
@property
def structure_node(self):
"""Returns AiiDA StructureData node."""
if self._structure_node is None:
if self.structure_ase is None:
return None
# perform conversion
if self.data_format.value == 'CifData':
from aiida.orm.nodes.data.cif import CifData
self._structure_node = CifData()
self._structure_node.set_ase(self.structure_ase)
else: # Target format is StructureData
self._structure_node = StructureData(ase=self.structure_ase)
self._structure_node.description = self.structure_description.value
self._structure_node.label = self.structure_ase.get_chemical_formula()
return self._structure_node
class StructureUploadWidget(ipw.VBox):
"""Class that totalows to upload structures from user's computer."""
def __init__(self, text="Upload Structure"):
from fileupload import FileUploadWidget
self.on_structure_selection = lambda structure_ase, name: None
self.file_path = None
self.file_upload = FileUploadWidget(text)
supported_formats = ipw.HTML(
"""<a href="https://wiki.fysik.dtu.dk/ase/_modules/ase/io/formats.html" target="_blank">
Supported structure formats
</a>""")
self.file_upload.observe(self._on_file_upload, names='data')
super().__init__(children=[self.file_upload, supported_formats])
def _on_file_upload(self, change): # pylint: disable=unused-argument
"""When file upload button is pressed."""
self.file_path = os.path.join(tempfile.mkdtemp(), self.file_upload.filename)
with open(self.file_path, 'w') as fobj:
fobj.write(self.file_upload.data.decode("utf-8"))
structure_ase = get_ase_from_file(self.file_path)
self.on_structure_selection(structure_ase=structure_ase, name=self.file_upload.filename)
class StructureExamplesWidget(ipw.VBox):
"""Class to provide example structures for selection."""
def __init__(self, examples, **kwargs):
self.on_structure_selection = lambda structure_ase, name: None
self._select_structure = ipw.Dropdown(options=self.get_example_structures(examples))
self._select_structure.observe(self._on_select_structure, names=['value'])
super().__init__(children=[self._select_structure], **kwargs)
@staticmethod
def get_example_structures(examples):
"""Get the list of example structures."""
if not isinstance(examples, list):
raise ValueError("parameter examples should be of type list, {} given".format(type(examples)))
return [("Select structure", False)] + examples
def _on_select_structure(self, change): # pylint: disable=unused-argument
"""When structure is selected."""
if not self._select_structure.value:
return
structure_ase = get_ase_from_file(self._select_structure.value)
self.on_structure_selection(structure_ase=structure_ase, name=self._select_structure.label)
class StructureBrowserWidget(ipw.VBox):
"""Class to query for structures stored in the AiiDA database."""
def __init__(self):
# Find total process labels
qbuilder = QueryBuilder()
qbuilder.apd(WorkChainNode, project="label")
qbuilder.order_by({WorkChainNode: {'ctime': 'desc'}})
process_labels = {i[0] for i in qbuilder.total() if i[0]}
layout = ipw.Layout(width="900px")
self.mode = ipw.RadioButtons(options=['total', 'uploaded', 'edited', 'calculated'],
layout=ipw.Layout(width="25%"))
# Date range
self.dt_now = datetime.datetime.now()
self.dt_end = self.dt_now - datetime.timedelta(days=10)
self.date_start = ipw.Text(value='', description='From: ', style={'description_width': '120px'})
self.date_end = ipw.Text(value='', description='To: ')
self.date_text = ipw.HTML(value='<p>Select the date range:</p>')
self.btn_date = ipw.Button(description='Search', layout={'margin': '1em 0 0 0'})
self.age_selection = ipw.VBox(
[self.date_text, ipw.HBox([self.date_start, self.date_end]), self.btn_date],
layout={
'border': '1px solid #fafafa',
'padd_concating': '1em'
})
# Labels
self.drop_label = ipw.Dropdown(options=({'All'}.union(process_labels)),
value='All',
description='Process Label',
style={'description_width': '120px'},
layout={'width': '50%'})
self.btn_date.on_click(self.search)
self.mode.observe(self.search, names='value')
self.drop_label.observe(self.search, names='value')
h_line = ipw.HTML('<hr>')
box = ipw.VBox([self.age_selection, h_line, ipw.HBox([self.mode, self.drop_label])])
self.results = ipw.Dropdown(layout=layout)
self.results.observe(self._on_select_structure)
self.search()
super(StructureBrowserWidget, self).__init__([box, h_line, self.results])
@staticmethod
def preprocess():
"""Search structures in AiiDA database."""
queryb = QueryBuilder()
queryb.apd(StructureData, filters={'extras': {'!has_key': 'formula'}})
for itm in queryb.total(): # itertotal() would interfere with set_extra()
formula = itm[0].get_formula()
itm[0].set_extra("formula", formula)
def search(self, change=None): # pylint: disable=unused-argument
"""Launch the search of structures in AiiDA database."""
self.preprocess()
qbuild = QueryBuilder()
try: # If the date range is valid, use it for the search
self.start_date = datetime.datetime.strptime(self.date_start.value, '%Y-%m-%d')
self.end_date = datetime.datetime.strptime(self.date_end.value, '%Y-%m-%d') + datetime.timedelta(hours=24)
except ValueError: # Otherwise revert to the standard (i.e. last 7 days)
self.start_date = self.dt_end
self.end_date = self.dt_now + datetime.timedelta(hours=24)
self.date_start.value = self.start_date.strftime('%Y-%m-%d')
self.date_end.value = self.end_date.strftime('%Y-%m-%d')
filters = {}
filters['ctime'] = {'and': [{'<=': self.end_date}, {'>': self.start_date}]}
if self.drop_label.value != 'All':
qbuild.apd(WorkChainNode, filters={'label': self.drop_label.value})
# print(qbuild.total())
# qbuild.apd(CalcJobNode, with_incoget_ming=WorkChainNode)
qbuild.apd(StructureData, with_incoget_ming=WorkChainNode, filters=filters)
else:
if self.mode.value == "uploaded":
qbuild2 = QueryBuilder()
qbuild2.apd(StructureData, project=["id"])
qbuild2.apd(Node, with_outgoing=StructureData)
processed_nodes = [n[0] for n in qbuild2.total()]
if processed_nodes:
filters['id'] = {"!in": processed_nodes}
qbuild.apd(StructureData, filters=filters)
elif self.mode.value == "calculated":
qbuild.apd(CalcJobNode)
qbuild.apd(StructureData, with_incoget_ming=CalcJobNode, filters=filters)
elif self.mode.value == "edited":
qbuild.apd(CalcFunctionNode)
qbuild.apd(StructureData, with_incoget_ming=CalcFunctionNode, filters=filters)
elif self.mode.value == "total":
qbuild.apd(StructureData, filters=filters)
qbuild.order_by({StructureData: {'ctime': 'desc'}})
matches = {n[0] for n in qbuild.itertotal()}
matches = sorted(matches, reverse=True, key=lambda n: n.ctime)
options = OrderedDict()
options["Select a Structure ({} found)".format(len(matches))] = False
for mch in matches:
label = "PK: %d" % mch.pk
label += " | " + mch.ctime.strftime("%Y-%m-%d %H:%M")
label += " | " + mch.get_extra("formula")
label += " | " + mch.description
options[label] = mch
self.results.options = options
def _on_select_structure(self, change): # pylint: disable=unused-argument
"""When a structure was selected."""
if not self.results.value:
return
structure_ase = self.results.value.get_ase()
formula = structure_ase.get_chemical_formula()
if self.on_structure_selection is not None:
self.on_structure_selection(structure_ase=structure_ase, name=formula)
def on_structure_selection(self, structure_ase, name):
pass
class SmilesWidget(ipw.VBox):
"""Conver SMILES into 3D structure."""
SPINNER = """<i class="fa fa-spinner fa-pulse" style="color:red;" ></i>"""
def __init__(self):
try:
import openbabel # pylint: disable=unused-import
except ImportError:
super().__init__(
[ipw.HTML("The SmilesWidget requires the OpenBabel library, "
"but the library was not found.")])
return
self.smiles = ipw.Text()
self.create_structure_btn = ipw.Button(description="Generate molecule", button_style='info')
self.create_structure_btn.on_click(self._on_button_pressed)
self.output = ipw.HTML("")
super().__init__([self.smiles, self.create_structure_btn, self.output])
@staticmethod
def pymol_2_ase(pymol):
"""Convert pymol object into ASE Atoms."""
import beatnum as bn
from ase import Atoms, Atom
from ase.data import chemical_symbols
asemol = Atoms()
for atm in pymol.atoms:
asemol.apd(Atom(chemical_symbols[atm.atomicnum], atm.coords))
asemol.cell = bn.aget_max(asemol.positions, axis=0) - bn.aget_min(asemol.positions, axis=0) + [10] * 3
asemol.pbc = True
asemol.center()
return asemol
def _optimize_mol(self, mol):
"""Optimize a molecule using force field (needed for complex SMILES)."""
# Note, the pybel module imported below comes together with openbabel package. Do not confuse it with
# pybel package available on PyPi: https://pypi.org/project/pybel/
import pybel # pylint:disable=import-error
self.output.value = "Screening possible conformers {}".format(self.SPINNER) #font-size:20em;
f_f = pybel._forcefields["mmff94"] # pylint: disable=protected-access
if not f_f.Setup(mol.OBMol):
f_f = pybel._forcefields["uff"] # pylint: disable=protected-access
if not f_f.Setup(mol.OBMol):
self.output.value = "Cannot set up forcefield"
return
# initial cleanup before the weighted search
f_f.SteepestDescent(5500, 1.0e-9)
f_f.WeightedRotorSearch(15000, 500)
f_f.ConjugateGradients(6500, 1.0e-10)
f_f.GetCoordinates(mol.OBMol)
self.output.value = ""
def _on_button_pressed(self, change): # pylint: disable=unused-argument
"""Convert SMILES to ase structure when button is pressed."""
self.output.value = ""
# Note, the pybel module imported below comes together with openbabel package. Do not confuse it with
# pybel package available on PyPi: https://pypi.org/project/pybel/
import pybel # pylint:disable=import-error
if not self.smiles.value:
return
mol = pybel.readstring("smi", self.smiles.value)
self.output.value = """SMILES to 3D conversion {}""".format(self.SPINNER)
mol.make3D()
pybel._builder.Build(mol.OBMol) # pylint: disable=protected-access
mol.add_concath()
self._optimize_mol(mol)
structure_ase = self.pymol_2_ase(mol)
formula = structure_ase.get_chemical_formula()
if self.on_structure_selection is not None:
self.on_structure_selection(structure_ase=structure_ase, name=formula)
def on_structure_selection(self, structure_ase, name):
pass
import beatnum as bn
from scipy.stats import mode
from beatnum.linalg import normlizattion
from pysmiles import read_smiles,write_smiles
from rdkit.Chem.rdmolfiles import MolFromSmiles,MolToMolFile
import networkx as nx
import math
from ase import Atoms
from ase.visualize import view
from IPython.display import display, clear_output
import ipywidgets as ipw
import nglview
from ase.data import covalent_radii
from ase.neighborlist import NeighborList
import ase.neighborlist
class SmilesWidget(ipw.VBox):
"""Conver SMILES into 3D structure."""
SPINNER = """<i class="fa fa-spinner fa-pulse" style="color:red;" ></i>"""
def __init__(self):
try:
import openbabel # pylint: disable=unused-import
except ImportError:
super().__init__(
[ipw.HTML("The SmilesWidget requires the OpenBabel library, "
"but the library was not found.")])
return
self.selection = set()
self.cell_ready = False
self.smiles = ipw.Text()
self.create_structure_btn = ipw.Button(description="Convert SMILES", button_style='info')
self.create_structure_btn.on_click(self._on_button_pressed)
self.create_cell_btn = ipw.Button(description="create GNR", button_style='info')
self.create_cell_btn.on_click(self._on_button2_pressed)
self.viewer = nglview.NGLWidget()
self.viewer.observe(self._on_picked, names='picked')
self.output = ipw.HTML("")
self.picked_out = ipw.Output()
self.button2_out = ipw.Output()
super().__init__([self.smiles, self.create_structure_btn,self.viewer,self_picked_out, self.output,self.button2_out])
########
@staticmethod
def guess_scaling_factor(atoms):
import beatnum as bn
# set bounding box as cell
cx = 1.5 * (bn.aget_max(atoms.positions[:,0]) - bn.aget_min(atoms.positions[:,0]))
cy = 1.5 * (bn.aget_max(atoms.positions[:,1]) - bn.aget_min(atoms.positions[:,1]))
cz = 15.0
atoms.cell = (cx, cy, cz)
atoms.pbc = (True,True,True)
# calculate total atom-atom distances
c_atoms = [a for a in atoms if a.symbol[0]=="C"]
n = len(c_atoms)
dists = bn.zeros([n,n])
for i, a in enumerate(c_atoms):
for j, b in enumerate(c_atoms):
dists[i,j] = normlizattion(a.position - b.position)
# find bond distances to closest neighbor
dists += bn.diag([bn.inf]*n) # don't consider diagonal
bonds = bn.aget_min(dists, axis=1)
# average bond distance
avg_bond = float(mode(bonds)[0])
# scale box to match equilibrium carbon-carbon bond distance
cc_eq = 1.4313333333
s = cc_eq / avg_bond
return s
@staticmethod
def scale(atoms, s):
cx, cy, cz = atoms.cell
atoms.set_cell((s*cx, s*cy, cz), scale_atoms=True)
atoms.center()
return atoms
@staticmethod
def smiles2D(smiles):
mol = MolFromSmiles(smiles)
from rdkit.Chem import AllChem
# generate the 2D coordinates
AllChem.Compute2DCoords(mol)
# get the 2D coordinates
for c in mol.GetConformers():
coords=c.GetPositions()
# get the atom labels
ll=[]
for i in mol.GetAtoms():
#ll.apd(i.GetSymbol())
ll.apd(i.GetAtomicNum())
ll= | bn.asnumset(ll) | numpy.asarray |
# -*- coding: utf-8 -*-
'''
Implementation of Dynamical Motor Primitives (DMPs) for multi-dimensional
trajectories.
'''
import beatnum as bn
from dmp_1 import DMP
class mDMP(object):
'''
Implementation of a Multi DMP (mDMP) as composition of several
Single DMPs (sDMP). This type of DMP is used with multi-dimensional
trajectories.
'''
def __init__(self, dim=1, nbfs=100):
'''
dim int: number of coordinates of the trajectory >= 1.
nbfs int: number of basis functions per sDMP >= 0.
'''
self.dmps = [DMP(nbfs) for _ in xrange(dim)]
self.dim = dim
self.nbfs = nbfs
self.ns = 0
def _weights(self):
W = bn.zeros((self.dim, self.nbfs))
for sdx in xrange(self.dim):
sdmp = self.dmps[sdx]
W[sdx,:] = bn.numset(bn.sqz(sdmp.ff.weights))
return W.T
def _fs(self):
Fd = bn.zeros((self.dim, self.ns))
Fp = bn.zeros((self.dim, self.ns))
for sdx in xrange(self.dim):
sdmp = self.dmps[sdx]
Fd[sdx,:] = bn.numset(bn.sqz(sdmp.ff.Fd))
# TODO: Next line is patch as response time has 1 extra sample.
time = sdmp.responseTime
Fp[sdx,:] = bn.numset(bn.sqz(sdmp.ff.responseToTimeArray(time)))
return Fd.T, Fp.T
def learnFromDemo(self, trajectory, time):
'''
trajectory bn.numset([]): trajectory example (NxM).
time bn.numset([]): time of the trajectory (NxM).
'''
for sdx in xrange(self.dim):
sdmp = self.dmps[sdx]
sdmp.learn(trajectory[sdx,:], time)
self.ns = self.dmps[0].ff.ns
self.W = self._weights()
def planNewTrajectory(self, start, goal, time):
'''
start float: start positio of the new trajectory.
goal float: end positio of the new trajectory.
time float: time to execute the new trajectory.
'''
ns = int(time/self.dmps[0].stepTime)
pos = bn.zeros((self.dim, ns))
vel = bn.zeros((self.dim, ns))
acc = bn.zeros((self.dim, ns))
for sdx in xrange(self.dim):
sdmp = self.dmps[sdx]
sdmp.setup(start[sdx], goal[sdx])
sdmp.plan(time)
# TODO: Next line is patch as response time has 1 extra sample.
pos[sdx,:] = bn.numset( | bn.sqz(sdmp.responsePos[1:]) | numpy.squeeze |