code stringlengths 17 6.64M |
|---|
def Adam(dx, learner, learning_rate, t, eps=1e-08, beta1=0.9, beta2=0.999):
learner.m = ((beta1 * learner.m) + ((1 - beta1) * dx))
mt = (learner.m / (1 - (beta1 ** t)))
learner.v = ((beta2 * learner.v) + ((1 - beta2) * (dx ** 2)))
vt = (learner.v / (1 - (beta2 ** t)))
update = ((learning_rate * mt... |
@ray.remote
def create_shared_noise():
'\n Create a large array of noise to be shared by all workers. Used \n for avoiding the communication of the random perturbations delta.\n '
seed = 12345
count = 2500000
noise = np.random.RandomState(seed).randn(count).astype(np.float64)
return noise... |
class SharedNoiseTable(object):
def __init__(self, noise, seed=11):
self.rg = np.random.RandomState(seed)
self.noise = noise
assert (self.noise.dtype == np.float64)
def get(self, i, dim):
return self.noise[i:(i + dim)]
def sample_index(self, dim):
return self.rg.... |
def rbf_kernel(x, y, sigma):
return np.exp(((- (np.linalg.norm((x - y)) ** 2)) / (2 * (sigma ** 2))))
|
def rbf_kernel_grad(x, y, sigma):
return (((x - y) / (sigma ** 2)) * rbf_kernel(x, y, sigma))
|
class Filter(object):
'Processes input, possibly statefully.'
def update(self, other, *args, **kwargs):
'Updates self with "new state" from other filter.'
raise NotImplementedError
def copy(self):
'Creates a new object with same state as self.\n Returns:\n copy ... |
class NoFilter(Filter):
def __init__(self, *args):
pass
def __call__(self, x, update=True):
return np.asarray(x, dtype=np.float64)
def update(self, other, *args, **kwargs):
pass
def copy(self):
return self
def sync(self, other):
pass
def stats_incr... |
class RunningStat(object):
def __init__(self, shape=None):
self._n = 0
self._M = np.zeros(shape, dtype=np.float64)
self._S = np.zeros(shape, dtype=np.float64)
self._M2 = np.zeros(shape, dtype=np.float64)
def copy(self):
other = RunningStat()
other._n = self._n... |
class MeanStdFilter(Filter):
'Keeps track of a running mean for seen states'
def __init__(self, shape, demean=True, destd=True):
self.shape = shape
self.demean = demean
self.destd = destd
self.rs = RunningStat(shape)
self.buffer = RunningStat(shape)
self.mean =... |
def get_filter(filter_config, shape=None):
if (filter_config == 'MeanStdFilter'):
return MeanStdFilter(shape)
elif (filter_config == 'NoFilter'):
return NoFilter()
else:
raise Exception(('Unknown observation_filter: ' + str(filter_config)))
|
@ray.remote
class Worker(object):
import simpleenvs
def __init__(self, env_seed, env_name='', shift=0, policy='FC', h_dim=64, layers=2, deltas=None, rollout_length=1000, delta_std=0.02, num_evals=0, ob_filter='NoFilter'):
self.params = {}
self.env_name = env_name
self.params['env_name... |
def explore(config):
if (config['train_batch_size'] < (config['sgd_minibatch_size'] * 2)):
config['train_batch_size'] = (config['sgd_minibatch_size'] * 2)
if (config['num_sgd_iter'] < 1):
config['num_sgd_iter'] = 1
config['target_delay'] = int(config['target_delay'])
return config
|
def explore(config):
if (config['train_batch_size'] < (config['sgd_minibatch_size'] * 2)):
config['train_batch_size'] = (config['sgd_minibatch_size'] * 2)
if (config['lambda'] > 1):
config['lambda'] = 1
config['train_batch_size'] = int(config['train_batch_size'])
return config
|
def create_eval_set(fold):
data = urbansound8k.load_dataset()
(folds, test) = urbansound8k.folds(data)
test = test.copy()
train = folds[fold][0].copy()
val = folds[fold][1].copy()
test['set'] = 'test'
train['set'] = 'train'
val['set'] = 'val'
df = pandas.concat([test, val])
ret... |
def load_sample(sample):
fsettings = features.settings(exsettings)
return features.load_sample(sample, fsettings, start_time=sample.start, window_frames=exsettings['frames'], feature_dir='data/features')
|
def predict(model, data):
return features.predict_voted(exsettings, model, data, loader=load_sample, method=exsettings['voting'], overlap=exsettings['voting_overlap'])
|
def model_predict(predictor, model_path, data):
model = keras.models.load_model(model_path)
p = predictor(model, data)
return p
|
def threshold(df, q=0.8):
q = df[(df.correct == False)].best_p.quantile(q=q)
return q
|
def plot_errors(df, ax=None, q=0.8, bins=20, ylim=None):
if (ax is None):
(fig, ax) = plt.subplots(1)
((_, wrong), (isright, right)) = df.groupby('correct')
assert (isright == True)
right.best_p.hist(ax=ax, color='green', alpha=0.4, bins=bins)
wrong.best_p.hist(ax=ax, color='red', alpha=0.... |
def plot_errors_classwise(df, figsize=(12, 4)):
groups = eval_set.groupby('class')
(fig, axs) = plt.subplots(2, (len(groups) // 2), figsize=figsize)
for (i, (classname, data)) in enumerate(groups):
x = (i // 2)
y = (i % 2)
ax = axs[(y, x)]
ax.set_title(classname)
if... |
def score(df, average=None, threshold=0.0):
y_true = df.classID
y_pred = df.best_y
uncertain = (df.best_p < threshold)
uncertain_ratio = (numpy.count_nonzero(uncertain.astype(int)) / len(y_pred))
y_pred = y_pred.mask(uncertain, 11)
labels = list(range(0, 10))
precision = sklearn.metrics.pr... |
def plot_precision_recall(data, ax=None):
df = pandas.DataFrame({'threshold': numpy.linspace(0, 1.0, 50, endpoint=False)})
micro = df.apply((lambda r: score(data, average='micro', threshold=r.threshold)), axis=1)
micro['threshold'] = df.threshold
micro['micro'] = micro.precision
macro = df.apply((... |
def load_device_results(results_dir):
frames = []
for filename in os.listdir(results_dir):
if filename.endswith('.device.json'):
experiment = filename.rstrip('.device.json')
p = os.path.join(results_dir, filename)
with open(p, 'r') as f:
contents = f... |
def plot_layers_ram(layers_ram, ax=None, max_ram=64000.0):
if (not ax):
(fig, ax) = plt.subplots(1, figsize=(4, 6))
l = layers_ram.sort_index(ascending=False)
l['activations_ram'] = (4 * l.activations)
l = l[l.activations_ram.notna()]
l.plot(kind='barh', ax=ax, y='activations_ram', x='name... |
def read_report(ser):
lines = []
state = 'wait-for-start'
while (state != 'ended'):
raw = ser.readline()
line = raw.decode('utf-8').strip()
if (state == 'wait-for-start'):
if line.startswith('Results for'):
state = 'started'
if (state == 'started... |
def parse_report(report):
out = {}
result_regexp = '@(\\d*)MHz\\/(\\d*)MHz.*complexity:\\s(\\d*)\\sMACC'
matches = list(re.finditer(result_regexp, report, re.MULTILINE))
(cpu_freq, cpu_freq_max, macc) = matches[0].groups()
out['cpu_mhz'] = int(cpu_freq)
out['macc'] = int(macc)
key_value_re... |
def test_parse_report():
out = parse_report(example_report)
assert (out['duration_avg'] == 0.325142)
assert (out['cycles_avg'] == 26011387)
assert (out['stack'] == 276)
assert (out['cpu_mhz'] == 80)
assert (out['macc'] == 2980798)
|
def main():
test_parse_report()
device = '/dev/ttyACM0'
baudrate = 115200
with serial.Serial(device, baudrate, timeout=0.5) as ser:
thrash = ser.read(10000)
report = read_report(ser)
out = parse_report(report)
print(json.dumps(out))
|
def ensure_dir(directory):
if (not os.path.exists(directory)):
os.makedirs(directory)
|
def ensure_dir_for_file(path):
directory = os.path.dirname(path)
ensure_dir(directory)
|
def ensure_directories(*dirs):
for dir in dirs:
ensure_dir(dir)
|
def add_arguments(parser):
a = parser.add_argument
a('--datasets', dest='datasets_dir', default='./data/datasets', help='%(default)s')
a('--features', dest='features_dir', default='./data/features', help='%(default)s')
a('--models', dest='models_dir', default='./data/models', help='%(default)s')
a... |
def load_settings_path(path):
with open(path, 'r') as config_file:
settings = yaml.load(config_file.read())
return settings
|
def arglist(options):
def format_arg(k, v):
if (v is None):
return '--{}'.format(k)
else:
return '--{}={}'.format(k, v)
args = [format_arg(k, v) for (k, v) in options.items()]
return args
|
def command_for_job(options):
args = ['python3', 'train.py']
args += arglist(options)
return args
|
def generate_train_jobs(experiments, settings_path, folds, overrides, ignored=['nickname']):
timestamp = datetime.datetime.now().strftime('%Y%m%d-%H%M')
unique = str(uuid.uuid4())[0:4]
def name(experiment, fold):
name = '-'.join([experiment, timestamp, unique])
return (name + '-fold{}'.fo... |
def run_job(jobdata, out_dir, verbose=2):
args = command_for_job(jobdata)
job_dir = os.path.join(out_dir, jobdata['name'])
common.ensure_directories(job_dir)
log_path = os.path.join(job_dir, 'stdout.log')
cmdline = ' '.join(args)
with open(os.path.join(job_dir, 'cmdline'), 'w') as f:
f... |
def run_jobs(commands, out_dir, n_jobs=5, verbose=1):
jobs = [joblib.delayed(run_job)(cmd, out_dir) for cmd in commands]
out = joblib.Parallel(n_jobs=n_jobs, verbose=verbose)(jobs)
return out
|
def parse(args):
import argparse
parser = argparse.ArgumentParser(description='Generate jobs')
common.add_arguments(parser)
a = parser.add_argument
a('--experiments', default='models.csv', help='%(default)s')
a('--check', action='store_true', help='Only run a pre-flight check')
a('--jobs',... |
def main():
args = parse(sys.argv[1:])
experiments = pandas.read_csv(args.experiments)
settings = common.load_settings_path(args.settings_path)
stop = (len(experiments) if (args.stop is None) else args.stop)
experiments = experiments.loc[range(args.start, stop)]
overrides = {}
folds = list... |
def build(settings):
builder = families.get(settings['model'])
options = dict(frames=settings['frames'], bands=settings['n_mels'], channels=settings.get('channels', 1))
known_settings = ['conv_size', 'conv_block', 'downsample_size', 'n_stages', 'dropout', 'fully_connected', 'n_blocks_per_stage', 'filters'... |
def build_model(frames=128, bands=40, channels=1, n_classes=10, conv_size=(3, 3), conv_block='conv', downsample_size=(2, 2), n_stages=3, n_blocks_per_stage=1, filters=128, kernels_growth=1.0, fully_connected=64, rnn_units=32, temporal='bigru', dropout=0.5, l2=0.001, backend='detection'):
from tensorflow.keras imp... |
def test_model():
model = build_model(filters=24, bands=64, rnn_units=16, n_classes=3, temporal='tcn')
print(model.summary())
|
def dcnn_head(input, head_name, filters=80, kernel=(3, 3)):
def n(base):
return ((base + '_') + head_name)
from keras.layers import Convolution2D, Flatten, MaxPooling2D
x = input
x = Convolution2D(filters, kernel, dilation_rate=(1, 1), name=n('DilaConv1'))(x)
x = MaxPooling2D(pool_size=(4... |
def dcnn(bands=60, frames=31, n_classes=10, fully_connected=5000, filters=80, activation='relu'):
'\n Dilated Convolution Neural Network with LeakyReLU for Environmental Sound Classification\n\n https://ieeexplore.ieee.org/document/8096153\n '
from keras.models import Sequential, Model
from keras... |
def dcnn_nodelta(bands=60, frames=31, n_classes=10, channels=1, fully_connected=5000, filters=80, activation='relu'):
from keras.models import Sequential, Model
from keras.layers import Dense, Dropout, Activation, Input, Concatenate
import keras.layers
input_shape = (bands, frames, channels)
def ... |
def main():
m = dcnn()
m.save('dcnn.hdf5')
m.summary()
m = dcnn_nodelta()
m.save('dcnn.nodelta.hdf5')
m.summary()
|
def build_model(bands=60, frames=41, channels=1, n_labels=10, dropout=0.0, depth=7, block=2, growth=15, pooling='avg', bottleneck=False, reduction=0.0, subsample=True):
'\n DenseNet\n '
from keras_contrib.applications import densenet
input_shape = (bands, frames, channels)
model = densenet.Dense... |
def main():
m = build_model()
m.save('densenet.hdf5')
m.summary()
|
def dilaconv(bands=64, frames=41, channels=2, dilation=(2, 2), kernel=(3, 3), n_labels=10, dropout=0.5, kernels=[32, 32, 64, 64]):
'\n Environmental sound classification with dilated convolutions\n\n https://www.sciencedirect.com/science/article/pii/S0003682X18306121\n '
from keras.models import Sequ... |
def main():
m = dilaconv()
m.summary()
m.save('dilaconv.hdf5')
m = ldcnn()
m.save('ldcnn.hdf5')
m.summary()
m = ldcnn_nodelta()
m.save('ldcnn.nodelta.hdf5')
m.summary()
|
def build_model(bands=128, frames=128, channels=2, n_classes=10, filters=80, L=57, W=6, fully_connected=5000):
'\n Deep Convolutional Neural Network with Mixup for Environmental Sound Classification\n \n https://link.springer.com/chapter/10.1007/978-3-030-03335-4_31\n '
from keras.models import Seq... |
def main():
m = build_model()
m.summary()
m.save('dmix.orig.hdf5')
|
def get_post(x_in):
x = Activation('relu')(x_in)
x = BatchNormalization()(x)
return x
|
def get_block(x_in, ch_in, ch_out, kernel=3, downsample=2, strides=(1, 1)):
x = Conv2D(ch_in, kernel_size=(1, 1), strides=strides, padding='same', use_bias=False)(x_in)
x = get_post(x)
x = DepthwiseConv2D(kernel_size=(1, kernel), padding='same', use_bias=False)(x)
x = get_post(x)
x = MaxPool2D(poo... |
def Effnet(input_shape, nb_classes, n_blocks=2, initial_filters=16, filter_growth=2.0, dropout=0.5, kernel=5, downsample=2, pool=None, include_top='flatten', weights=None):
if getattr(kernel, '__iter__', None):
assert (kernel[0] == kernel[1])
kernel = kernel[0]
x_in = Input(shape=input_shape)
... |
def build_model(frames=31, bands=60, channels=1, n_classes=10, **kwargs):
shape = (bands, frames, channels)
return Effnet(shape, nb_classes=n_classes, **kwargs)
|
def main():
m = build_model()
m.summary()
m.save('effnet.hdf5')
|
def ldcnn_head(input, head_name, filters=80, L=57, W=6):
def n(base):
return ((base + '_') + head_name)
from keras.layers import Convolution2D, Flatten, MaxPooling2D, BatchNormalization
x = input
x = Convolution2D(filters, (L, 1), activation='relu', name=n('SFCL1'))(x)
x = BatchNormalizat... |
def ldcnn(bands=60, frames=31, n_classes=10, filters=80, L=57, W=6, fully_connected=5000, dropout=0.25):
'\n LD-CNN: A Lightweight Dilated Convolutional Neural Network for Environmental Sound Classification\n \n http://epubs.surrey.ac.uk/849351/1/LD-CNN.pdf\n '
from keras.models import Sequential,... |
def ldcnn_nodelta(bands=60, frames=31, n_classes=10, filters=80, L=57, W=6, channels=1, fully_connected=5000, dropout=0.5):
'Variation of LD-CNN with only mel input (no deltas)'
from keras.models import Sequential, Model
from keras.layers import Dense, Dropout, Activation, Input, Concatenate
from kera... |
def relu6(x, name):
if False:
x = layers.ReLU(6.0, name=name)(x)
else:
x = layers.Activation('relu')(x)
return x
|
def _conv_block(inputs, filters, alpha, kernel=(3, 3), strides=(1, 1)):
channel_axis = (1 if (backend.image_data_format() == 'channels_first') else (- 1))
filters = int((filters * alpha))
padding = ((0, (kernel[1] // 2)), (0, (kernel[1] // 2)))
x = layers.ZeroPadding2D(padding=padding, name='conv1_pad... |
def _depthwise_conv_block(inputs, pointwise_conv_filters, alpha, depth_multiplier=1, strides=(1, 1), kernel=(3, 3), block_id=1):
channel_axis = (1 if (backend.image_data_format() == 'channels_first') else (- 1))
pointwise_conv_filters = int((pointwise_conv_filters * alpha))
layers = keras.layers
if (s... |
def build_model(frames=32, bands=32, channels=1, n_classes=10, dropout=0.5, depth_multiplier=1, alpha=0.5, n_stages=2, initial_filters=24, kernel=(5, 5), pool=(2, 2)):
'\n '
(stride_f, stride_t) = pool
from keras.applications import mobilenet
conv = _conv_block
dwconv = _depthwise_conv_block
... |
def build_model(bands=60, frames=41, channels=2, n_labels=10, fc=5000, dropout=0.5):
'\n Implements the short-segment CNN from\n\n ENVIRONMENTAL SOUND CLASSIFICATION WITH CONVOLUTIONAL NEURAL NETWORKS\n Karol J. Piczak, 2015.\n https://karol.piczak.com/papers/Piczak2015-ESC-ConvNet.pdf\n '
from... |
def main():
m = build_model()
m.save('piczak.orig.hdf5')
m.summary()
|
def build_model(frames=128, bands=128, channels=1, n_classes=10, conv_size=(5, 5), conv_block='conv', downsample_size=(4, 2), fully_connected=64, n_stages=None, n_blocks_per_stage=None, filters=24, kernels_growth=2, dropout=0.5, use_strides=False):
'\n Implements SB-CNN model from\n Deep Convolutional Neura... |
def build_model(frames=172, shingles=8, bands=40, channels=1, codebook=2000):
'\n Implements convolution part of SKM model from\n\n UNSUPERVISED FEATURE LEARNING FOR URBAN SOUND CLASSIFICATION\n Justin Salamon and Juan Pablo Bello, 2015\n '
input_shape = (bands, frames, channels)
kernel = (ban... |
def main():
print('original')
m = build_model()
m.summary()
|
def build_tiny_conv(input_frames, input_bins, n_classes=12, dropout=0.5):
'\n Ported from Tensorflow examples. create_tiny_conv_model\n '
from keras.layers import Conv2D, Dense, Dropout, Flatten
input_shape = (input_bins, input_frames, 1)
model = keras.Sequential([Conv2D(8, (8, 10), strides=(2, ... |
def build_one(frames=64, bands=40, n_classes=10, dropout=0.0, tstride=1, fstride=4):
"\n Ported from Tensorflow examples. create_low_latency_conv\n\n This is roughly the network labeled as 'cnn-one-fstride4' in the\n 'Convolutional Neural Networks for Small-footprint Keyword Spotting' paper:\n http://... |
def build_low_latency_conv(input_frames, input_bins, n_classes=12, dropout=0.5):
"\n Ported from Tensorflow examples. create_low_latency_conv\n\n This is roughly the network labeled as 'cnn-one-fstride4' in the\n 'Convolutional Neural Networks for Small-footprint Keyword Spotting' paper:\n http://www.... |
def build_aclnet_lowlevel(input_samples, c1=32, s1=8, s2=4, input_tensor=None):
'\n\n The following values were tested in the paper.\n c1= 8,16,32\n s1= 2,4,8\n s2= 2,4\n '
from keras.layers import Conv1D, MaxPooling1D, InputLayer, Flatten, Dense
input_shape = (input_samples, 1)
model =... |
def main():
m = build_low_latency_conv(41, 40)
m.summary()
m = build_tiny_conv(32, 40)
m.summary()
m = build_one()
m.summary()
|
def fire_module(x, fire_id, squeeze=16, expand=64):
sq1x1 = 'squeeze1x1'
exp1x1 = 'expand1x1'
exp3x3 = 'expand3x3'
relu = 'relu_'
s_id = (('fire' + str(fire_id)) + '/')
from keras.layers import concatenate
x = Convolution2D(squeeze, (1, 1), padding='valid', name=(s_id + sq1x1))(x)
x = ... |
def build_model(frames=32, bands=32, channels=1, n_classes=10, dropout=0.5, n_stages=3, modules_per_stage=2, initial_filters=64, squeeze_ratio=0.2, pool=(2, 2), kernel=(3, 3), stride_f=2, stride_t=2):
from keras.models import Model
from keras.layers import Input, GlobalAveragePooling2D, Dropout, MaxPooling2D
... |
def add_common(x, name):
x = BatchNormalization(name=(name + '_bn'))(x)
x = Activation('relu', name=(name + '_relu'))(x)
return x
|
def conv(x, kernel, filters, downsample, name, padding='same'):
'Regular convolutional block'
x = Conv2D(filters, kernel, strides=downsample, name=name, padding=padding)(x)
return add_common(x, name)
|
def conv_ds(x, kernel, filters, downsample, name, padding='same'):
'Depthwise Separable convolutional block\n (Depthwise->Pointwise)\n\n MobileNet style'
x = SeparableConv2D(filters, kernel, padding=padding, strides=downsample, name=(name + '_ds'))(x)
return add_common(x, name=(name + '_ds'))
|
def conv_bottleneck_ds(x, kernel, filters, downsample, name, padding='same', bottleneck=0.5):
'\n Bottleneck -> Depthwise Separable\n (Pointwise->Depthwise->Pointswise)\n\n MobileNetV2 style\n '
if (padding == 'valid'):
pad = ((0, (kernel[0] // 2)), (0, (kernel[0] // 2)))
x = ZeroP... |
def conv_effnet(x, kernel, filters, downsample, name, bottleneck=0.5, strides=(1, 1), padding='same', bias=False):
'Pointwise -> Spatially Separable conv&pooling \n Effnet style'
assert (downsample[0] == downsample[1])
downsample = downsample[0]
assert (kernel[0] == kernel[1])
kernel = kernel[... |
def backend_dense1(x, n_classes, fc=64, regularization=0.001, dropout=0.5):
from keras.regularizers import l2
'\n SB-CNN style classification backend\n '
x = Flatten()(x)
x = Dropout(dropout)(x)
x = Dense(fc, kernel_regularizer=l2(regularization))(x)
x = Activation('relu')(x)
x = Dro... |
def build_model(frames=128, bands=128, channels=1, n_classes=10, conv_size=(5, 5), conv_block='conv', downsample_size=(2, 2), n_stages=3, n_blocks_per_stage=1, filters=24, kernels_growth=1.5, fully_connected=64, dropout=0.5, l2=0.001):
'\n \n '
input = Input(shape=(bands, frames, channels))
x = inpu... |
def plot():
models = pandas.read_csv('models.csv')
(fig, ax) = plt.subplots(1)
print(models.head(10))
print(models.index)
n_labels = len(models['name'])
colors = matplotlib.cm.rainbow(numpy.linspace(0, 1, n_labels))
for (i, r) in models.iterrows():
ax.plot((r['parameters'] / 1000),... |
def augmentations(audio, sr):
ts = [0.81, 0.93, 1.07, 1.23]
ps = [(- 2), (- 1), 1, 2, (- 3.5), (- 2.5), 2.5, 3.5]
out = {}
for stretch in ts:
name = 'ts{:.2f}'.format(stretch)
out[name] = librosa.effects.time_stretch(audio, stretch)
for shift in ps:
name = 'ps{:.2f}'.format... |
def compute(inp, outp, settings, force):
sr = settings['samplerate']
_lazy_y = None
def load():
nonlocal _lazy_y
if (_lazy_y is None):
(_lazy_y, _sr) = librosa.load(inp, sr=sr)
assert (_sr == sr), _sr
return _lazy_y
exists = os.path.exists(outp)
siz... |
def precompute(samples, settings, out_dir, n_jobs=8, verbose=1, force=False):
out_folder = out_dir
def job_spec(sample):
path = urbansound8k.sample_path(sample)
out_path = features.feature_path(sample, out_folder)
f = os.path.split(out_path)[0]
if (not os.path.exists(f)):
... |
def parse():
import argparse
parser = argparse.ArgumentParser(description='Preprocess audio into features')
common.add_arguments(parser)
a = parser.add_argument
a('--archive', dest='archive_dir', default='', help='')
a('--jobs', type=int, default=8, help='Number of parallel jobs')
a('--for... |
def main():
args = parse()
archive = args.archive_dir
urbansound8k.default_path = os.path.join(args.datasets_dir, 'UrbanSound8K/')
urbansound8k.maybe_download_dataset(args.datasets_dir)
data = urbansound8k.load_dataset()
settings = common.load_settings_path(args.settings_path)
settings = f... |
def populate_defaults():
s = {}
for n in names:
v = default_model_settings.get(n, None)
if (v is None):
v = default_training_settings.get(n, None)
if (v is None):
v = default_feature_settings.get(n, None)
s[n] = v
return s
|
def test_no_overlapping_settings():
f = default_feature_settings.keys()
t = default_training_settings.keys()
m = default_model_settings.keys()
assert (len(names) == ((len(f) + len(t)) + len(m)))
|
def parse_dimensions(s):
pieces = s.split('x')
return tuple((int(d) for d in pieces))
|
def test_parse_dimensions():
valid_examples = [('3x3', (3, 3)), ('4x2', (4, 2))]
for (inp, expect) in valid_examples:
out = parse_dimensions(inp)
assert (out == expect), (out, '!=', expect)
|
def load_settings(args):
settings = {}
for key in names:
string = args.get(key, defaults[key])
parser = parsers.get(key, (lambda x: x))
value = parser(string)
settings[key] = value
return settings
|
def test_settings_empty():
load_settings({})
|
def add_arguments(parser):
a = parser.add_argument
for name in names:
data_type = type(defaults[name])
default = None
a('--{}'.format(name), default=default, type=data_type, help='%(default)s')
|
def compute_conv2d(in_h, in_w, in_ch, out_ch, k_w, k_h):
'Compute complexity for standard Conv2D\n\n '
return ((((in_h * in_w) * in_ch) * out_ch) * (k_w * k_h))
|
def compute_conv2d_pw(in_h, in_w, in_ch, out_ch):
'Compute complexity for Pointwise (1x1) Conv2D\n\n $$ O_{pw} = HWNM $$\n '
return (((in_h * in_w) * in_ch) * out_ch)
|
def compute_conv2d_dw(in_h, in_w, in_ch, k_w, k_h):
'Compute complexity for Depthwise Conv2D\n\n $$ O_{dw} = HWNK_wK_h $$\n '
return (((in_h * in_w) * in_ch) * (k_w * k_h))
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.