def __init__(self, D, H, W, K, iternum):
Classifier.__init__(self, D, H, W, K, iternum)
self.L = 100 # size of hidden layer
""" Layer 1 Parameters """
# weight matrix: [M * L]
self.A1 = 0.01 * np.random.randn(self.M, self.L)
# bias: [1 * L]
self.b1 = np.zeros((1, self.L))
""" Layer 3 Parameters """
# weight matrix: [L * K]
self.A3 = 0.01 * np.random.randn(self.L, K)
# bias: [1 * K]
self.b3 = np.zeros((1, K))
""" Hyperparams """
# learning rate
self.rho = 1e-2
# momentum
self.mu = 0.9
# reg strencth
self.lam = 0.1
# velocity for A1: [M * L]
self.v1 = np.zeros((self.M, self.L))
# velocity for A3: [L * K]
self.v3 = np.zeros((self.L, K))
return
def __init__(self, D, H, W, K, iternum):
Classifier.__init__(self, D, H, W, K, iternum)
self.L = 100 # size of hidden layer
""" Layer 1 Parameters """
# weight matrix: [M * L]
self.A1 = 0.01 * np.random.randn(self.M, self.L)
# bias: [1 * L]
self.b1 = np.zeros((1,self.L))
""" Layer 3 Parameters """
# weight matrix: [L * K]
self.A3 = 0.01 * np.random.randn(self.L, K)
# bias: [1 * K]
self.b3 = np.zeros((1,K))
""" Hyperparams """
# learning rate
self.rho = 1e-2
# momentum
self.mu = 0.9
# reg strencth
self.lam = 0.1
# velocity for A1: [M * L]
self.v1 = np.zeros((self.M, self.L))
# velocity for A3: [L * K]
self.v3 = np.zeros((self.L, K))
return
def __init__(self,
engine,
recorder,
window_size=2.0,
window_step=0.5,
freqs=[60 / 4., 60 / 5., 60 / 6., 60 / 7.],
bandpass=[2, 45],
cl_type='MNEC',
nharmonics=3):
""" Constructor.
Required parameters:
recorder: The Recorder object to read data from
Keyword parameters (configures the classifier):
window_size: The window size in seconds to use on the data
window_step: The window step in seconds to use on the data
freqs: The frequencies in Hertz of the SSVEP stimuli to look for.
bandpass: [lo, hi] cutoff frequencies for the bandpass filter to use on the data
"""
self.window_size = window_size
self.window_step = window_step
self.freqs = freqs
self.bandpass = bandpass
self.nharmonics = nharmonics
self.pipeline = None
self.cl_type = cl_type
# Figure out a sane target sample rate, using only a decimation factor
self.target_sample_rate = np.floor(
recorder.sample_rate /
np.max([1, np.floor(recorder.sample_rate / 200)]))
Classifier.__init__(self, engine, recorder)
def __init__(self, fname, *args, **kargs):
Classifier.__init__(self, fname, *args, **kargs)
# sometimes a threshold value is trained during Bayesian
# classification to avoid classifying too many 'documents' as
# one kind or the other
self.thresholds = [1.0, 1.0]
def __init__(self, engine, recorder, window=(0, 1.0), bandpass=[0.5, 15]):
""" Constructor.
Required parameters:
recorder: The imec.Recorder object to read data from
Keyword parameters (configures the classifier):
window: A pair (from, to) in samples of the window to extract around the stimulation onset
bandpass: [lo, hi] cutoff frequencies for the bandpass filter to use on the data
"""
assert len(window) == 2
# Create pipeline
self.bp_node = psychic.nodes.OnlineFilter(
lambda s: scipy.signal.iirfilter(
3, [bandpass[0] / (s / 2.0), bandpass[1] / (s / 2.0)]))
self.preprocessing = psychic.nodes.Chain([self.bp_node])
self.window = window
self.cl_lab = None
self.format = 'png'
Classifier.__init__(self, engine, recorder)
self.logger.info('sample_rate: %d Hz' % recorder.sample_rate)
self.logger.info('bandpass: %s' % bandpass)
def __init__(self, engine, recorder, window_size=2.0, window_step=0.5, ncomp=4, bandpass=[8, 15]):
""" Constructor.
Required parameters:
recorder: The Recorder object to read data from
Keyword parameters (configures the classifier):
window_size: The window size in seconds to use on the data
window_step: The window step in seconds to use on the data
ncomp: Number of ICA components to use
bandpass: [lo, hi] cutoff frequencies for the bandpass filter to use on the data
"""
self.window_size = window_size
self.window_step = window_step
self.ncomp = ncomp
self.bandpass = bandpass
self.pipeline = None
self.target_sample_rate = 256
Classifier.__init__(self, engine, recorder)
self.logger.info("sample_rate: %f" % recorder.sample_rate)
self.logger.info("window_size: %f" % window_size)
self.logger.info("window_step: %f" % window_step)
self.logger.info("ncomp: %d" % ncomp)
self.logger.info("bandpass: %s" % bandpass)
def __init__(self, engine, recorder, num_repetitions=10, num_options=7, window=(0.0, 1.0), bandpass=[0.5, 15]):
""" Constructor.
Required parameters:
recorder: The imec.Recorder object to read data from
Keyword parameters (configures the classifier):
window: A pair (from, to) in samples of the window to extract around the stimulation onset
bandpass: [lo, hi] cutoff frequencies for the bandpass filter to use on the data
"""
assert len(window) == 2
self.num_repetitions = num_repetitions
self.num_options = num_options
self.target_sample_rate = 128
self.window = window
self.window_samples = (int(recorder.sample_rate*window[0]), int(recorder.sample_rate*window[1]))
self.target_window = (int(self.target_sample_rate*window[0]), int(self.target_sample_rate*window[1]))
self.mdict = {}
for i in range(1,self.num_options+1):
self.mdict[i] = 'target %02d' % i
# Create pipelines
self.preprocessing = psychic.nodes.Chain([
psychic.nodes.OnlineFilter( lambda s : scipy.signal.iirfilter(3, [bandpass[0]/(s/2.0), bandpass[1]/(s/2.0)]) ),
psychic.nodes.Resample(self.target_sample_rate, max_marker_delay=1),
])
self.slice_node = psychic.nodes.OnlineSlice(self.mdict, window)
self.classification = psychic.nodes.Chain([
#psychic.nodes.Blowup(100),
psychic.nodes.Mean(axis=2),
sklearn.grid_search.GridSearchCV(
sklearn.svm.LinearSVC(),
{'C': numpy.logspace(-3, 5, 10)},
cv=5,
)
])
Classifier.__init__(self, engine, recorder)
self.logger.info('sample_rate: %d Hz' % recorder.sample_rate)
self.logger.info('bandpass: %s' % bandpass)
self.logger.info('window: %s' % str(window))
self.logger.info('num_repetitions: %d' % num_repetitions)
# Construct feature labels
self.channel_labels = recorder.channel_names
self.time_labels = (\
(numpy.arange(self.target_window[1]-self.target_window[0])
+ self.target_window[0]) \
/ float(self.target_sample_rate)).tolist()
self.repetition_labels = range(self.num_repetitions)
self.feat_lab = [
[self.channel_labels[i] for i in self.recorder.target_channels],
self.time_labels,
self.repetition_labels]
def __init__(self, fname, *args, **kargs):
Classifier.__init__(self, fname, *args, **kargs)
# sometimes a threshold value is trained during Bayesian
# classification to avoid classifying too many 'documents' as
# one kind or the other
self.thresholds = [1.0, 1.0]
def __init__(self,
train_set,
epochs=10,
eta=None,
ratio=None,
validate_set=None,
num_classes=3):
Classifier.__init__(self, train_set, epochs, eta, ratio, validate_set,
num_classes)
def __init__(self,
chars,
maxsentlen,
maxwordlen,
use_alphabets=False,
hyper_parameters=classifier.DEFAULT_HYPER_PARAMETERS,
model=None):
Classifier.__init__(self, chars, self.labels, maxsentlen, maxwordlen,
use_alphabets, hyper_parameters, model)
def __init__(self,
train_set,
test_set,
epochs=10,
eta=0.1,
lamda=0.1,
ratio=None,
validate_set=None,
num_classes=3):
Classifier.__init__(self, train_set, test_set, epochs, eta, ratio,
validate_set, num_classes)
self.lamda = lamda
def __init__(self, rawfname, min_occurences=5, **kargs):
Classifier.__init__(self, rawfname, **kargs)
self.min_occurences = min_occurences
self.all_training_examples = []
self.all_features = {}
self.model = None
self.filesubset = kargs.get('filesubset', 3000)
self.max_iter = kargs.get('max_iter', 4)
def __init__(self):
'''
'''
Classifier.__init__(self)
self.name = 'VGG19 (Imagenet pre-trained) + MLP'
self._VGG19 = None
self._MLP = None
self._VGG19_features_for_kfold = None
self._VGG19_features_calculated = False
def __init__(self, D, H, W, K, iternum):
Classifier.__init__(self, D, H, W, K, iternum)
""" Parameters """
# weight matrix: [M * K]
self.A = 0.01 * np.random.randn(self.M, K)
# bias: [1 * K]
self.b = np.zeros((1, K))
""" Hyperparams """
# learning rate
self.rho = 1e-5
# momentum
self.mu = 0.9
# reg strength
self.lam = 1e1
# velocity for A: [M * K]
self.v = np.zeros((self.M, K))
return
def __init__(self, D, H, W, K, iternum):
Classifier.__init__(self, D, H, W, K, iternum)
""" Parameters """
# weight matrix: [M * K]
self.A = 0.01 * np.random.randn(self.M, K)
# bias: [1 * K]
self.b = np.zeros((1,K))
""" Hyperparams """
# learning rate
self.rho = 1e-5
# momentum
self.mu = 0.9
# reg strength
self.lam = 1e1
# velocity for A: [M * K]
self.v = np.zeros((self.M, K))
return
def __init__(self, rawfname, min_occurences=5, **kargs):
Classifier.__init__(self, rawfname, **kargs)
self.min_occurences = min_occurences
# Maintains all training examples
self.all_training_examples = []
# Each example contains only keys for features which occurred more
# than <min_occurences> times in the training set
self.shrunk_training_examples = []
# { feature -> num times <feature> was seen }
self.all_features = {}
self.model = None
self.filesubset = kargs.get('filesubset', 3000)
self.max_iter = kargs.get('max_iter', 4)
def __init__(self, rawfname, min_occurences=5, **kargs):
Classifier.__init__(self, rawfname, **kargs)
self.min_occurences = min_occurences
# Maintains all training examples
self.all_training_examples = []
# Each example contains only keys for features which occurred more
# than <min_occurences> times in the training set
self.shrunk_training_examples = []
# { feature -> num times <feature> was seen }
self.all_features = {}
self.model = None
self.filesubset = kargs.get('filesubset', 3000)
self.max_iter = kargs.get('max_iter', 4)
def __init__(self, feature):
Classifier.__init__(self, feature)
self.threshold = None
def __init__(self, microDataLoc, estimators=55, depth=7):
Classifier.__init__(self, microDataLoc)
self.estimators = estimators
self.depth = depth
def __init__(self,
microDataLoc,
clusterNum=1,
macroDataLoc="data/clusterData.txt"):
Classifier.__init__(self, microDataLoc, clusterNum, macroDataLoc)
def __init__(self, fname, *args, **kargs):
# type: (object, object, object) -> object
Classifier.__init__(self, fname, *args, **kargs)
self.thresholds = [1.0, 1.0]
def __init__(self, root_dir, input_text, config_dirs): Classifier.__init__(self, input_text) self.master_word_list = [] self.word_features = [] self.configs = utils.load_json_file(config_dirs)
def __init__(self, D, H, W, K, iternum):
Classifier.__init__(self, D, H, W, K, iternum)
"""
Layer 1 Parameters (Conv 32 x 32 x 16)
K = 16, F = 5, S = 1, P = 2
weight matrix: [K1 * D * F1 * F1]
bias: [K1 * 1]
"""
K1, F1, self.S1, self.P1 = 16, 5, 1, 2
self.A1 = 0.01 * np.random.randn(K1, D, F1, F1)
self.b1 = np.zeros((K1, 1))
H1 = (H - F1 + 2*self.P1) / self.S1 + 1
W1 = (W - F1 + 2*self.P1) / self.S1 + 1
"""
Layer 3 Parameters (Pool 16 x 16 x 16)
K = 16, F = 2, S = 2
"""
K3, self.F3, self.S3 = K1, 2, 2
H3 = (H1 - self.F3) / self.S3 + 1
W3 = (W1 - self.F3) / self.S3 + 1
"""
Layer 4 Parameters (Conv 16 x 16 x 20)
K = 20, F = 5, S = 1, P = 2
weight matrix: [K4 * K3 * F4 * F4]
bias: [K4 * 1]
"""
K4, F4, self.S4, self.P4 = 20, 5, 1, 2
self.A4 = 0.01 * np.random.randn(K4, K3, F4, F4)
self.b4 = np.zeros((K4, 1))
H4 = (H3 - F4 + 2*self.P4) / self.S4 + 1
W4 = (W3 - F4 + 2*self.P4) / self.S4 + 1
"""
Layer 6 Parameters (Pool 8 x 8 x 20)
K = 20, F = 2, S = 2
"""
K6, self.F6, self.S6 = K4, 2, 2
H6 = (H4 - self.F6) / self.S6 + 1
W6 = (W4 - self.F6) / self.S6 + 1
"""
Layer 7 Parameters (Conv 8 x 8 x 20)
K = 20, F = 5, S = 1, P = 2
weight matrix: [K7 * K6 * F7 * F7]
bias: [K7 * 1]
"""
K7, F7, self.S7, self.P7 = 20, 5, 1, 2
self.A7 = 0.01 * np.random.randn(K7, K6, F7, F7)
self.b7 = np.zeros((K7, 1))
H7 = (H6 - F7 + 2*self.P7) / self.S7 + 1
W7 = (W6 - F7 + 2*self.P7) / self.S7 + 1
"""
Layer 9 Parameters (Pool 4 x 4 x 20)
K = 20, F = 2, S = 2
"""
K9, self.F9, self.S9 = K7, 2, 2
H9 = (H7 - self.F9) / self.S9 + 1
W9 = (W7 - self.F9) / self.S9 + 1
"""
Layer 10 Parameters (FC 1 x 1 x K)
weight matrix: [(K6 * H_6 * W_6) * K]
bias: [1 * K]
"""
self.A10 = 0.01 * np.random.randn(K9 * H9 * W9, K)
self.b10 = np.zeros((1, K))
""" Hyperparams """
# learning rate
self.rho = 1e-2
# momentum
self.mu = 0.9
# reg strength
self.lam = 0.1
# velocity for A1: [K1 * D * F1 * F1]
self.v1 = np.zeros((K1, D, F1, F1))
# velocity for A4: [K4 * K3 * F4 * F4]
self.v4 = np.zeros((K4, K3, F4, F4))
# velocity for A7: [K7 * K6 * F7 * F7]
self.v7 = np.zeros((K7, K6, F7, F7))
# velocity for A10: [(K9 * H9 * W9) * K]
self.v10 = np.zeros((K9 * H9 * W9, K))
return
def __init__(self):
Classifier.__init__(self)
self.class_priors = None
self.conditional_probabilities = None
self.class_indices = {}
self.class_term_probability = {}
def __init__(self, D, H, W, K, iternum, verbose=False):
Classifier.__init__(self, D, H, W, K, iternum)
self.verbose = verbose
"""
Layer 1 Parameters (Conv 32 x 32 x 16)
K = 16, F = 5, S = 1, P = 2
weight matrix: [K1 * D * F1 * F1]
bias: [K1 * 1]
"""
K1, F1, self.S1, self.P1 = 16, 5, 1, 2
self.A1 = 0.01 * np.random.randn(K1, D, F1, F1)
self.b1 = np.zeros((K1, 1))
H1 = (H - F1 + 2 * self.P1) / self.S1 + 1
W1 = (W - F1 + 2 * self.P1) / self.S1 + 1
"""
Layer 3 Parameters (Pool 16 x 16 x 16)
K = 16, F = 2, S = 2
"""
K3, self.F3, self.S3 = K1, 2, 2
H3 = (H1 - self.F3) / self.S3 + 1
W3 = (W1 - self.F3) / self.S3 + 1
"""
Layer 4 Parameters (Conv 16 x 16 x 20)
K = 20, F = 5, S = 1, P = 2
weight matrix: [K4 * K3 * F4 * F4]
bias: [K4 * 1]
"""
K4, F4, self.S4, self.P4 = 20, 5, 1, 2
self.A4 = 0.01 * np.random.randn(K4, K3, F4, F4)
self.b4 = np.zeros((K4, 1))
H4 = (H3 - F4 + 2 * self.P4) / self.S4 + 1
W4 = (W3 - F4 + 2 * self.P4) / self.S4 + 1
"""
Layer 6 Parameters (Pool 8 x 8 x 20)
K = 20, F = 2, S = 2
"""
K6, self.F6, self.S6 = K4, 2, 2
H6 = (H4 - self.F6) / self.S6 + 1
W6 = (W4 - self.F6) / self.S6 + 1
"""
Layer 7 Parameters (Conv 8 x 8 x 20)
K = 20, F = 5, S = 1, P = 2
weight matrix: [K7 * K6 * F7 * F7]
bias: [K7 * 1]
"""
K7, F7, self.S7, self.P7 = 20, 5, 1, 2
self.A7 = 0.01 * np.random.randn(K7, K6, F7, F7)
self.b7 = np.zeros((K7, 1))
H7 = (H6 - F7 + 2 * self.P7) / self.S7 + 1
W7 = (W6 - F7 + 2 * self.P7) / self.S7 + 1
"""
Layer 9 Parameters (Pool 4 x 4 x 20)
K = 20, F = 2, S = 2
"""
K9, self.F9, self.S9 = K7, 2, 2
H9 = (H7 - self.F9) / self.S9 + 1
W9 = (W7 - self.F9) / self.S9 + 1
"""
Layer 10 Parameters (FC 1 x 1 x K)
weight matrix: [(K6 * H_6 * W_6) * K]
bias: [1 * K]
"""
self.A10 = 0.01 * np.random.randn(K9 * H9 * W9, K)
self.b10 = np.zeros((1, K))
""" Hyperparams """
# learning rate
self.rho = 1e-2
# momentum
self.mu = 0.9
# reg strength
self.lam = 0.1
# velocity for A1: [K1 * D * F1 * F1]
self.v1 = np.zeros((K1, D, F1, F1))
# velocity for A4: [K4 * K3 * F4 * F4]
self.v4 = np.zeros((K4, K3, F4, F4))
# velocity for A7: [K7 * K6 * F7 * F7]
self.v7 = np.zeros((K7, K6, F7, F7))
# velocity for A10: [(K9 * H9 * W9) * K]
self.v10 = np.zeros((K9 * H9 * W9, K))
return
def __init__(self, root_dir, input_text, config_dirs):
Classifier.__init__(self, input_text)
self.master_word_list = []
self.word_features = []
self.configs = utils.load_json_file(config_dirs)
