def main():
ps_path = '/home/tim/repos/py_solvers/applications/deconvolution_challenge/test.ini'
ps_params = ParameterStruct(ps_path)
dict_in = {}
sec_input = sf.create_section(ps_params, 'Input1')
sec_input.read(dict_in)
#'x' now has the reconstruction, so move it to 'x_n'
dict_in['x_n'] = dict_in['x']
dict_in['x_n_f'] = fftn(dict_in['x_n'])
sec_input2 = sf.create_section(ps_params, 'Input3')
sec_input2.read(dict_in)
sec_observe = sf.create_section(ps_params, 'Observe1')
sec_observe.observe(dict_in)
#now remove the extra padding from x
results = sf.create_section(ps_params, 'Results1')
results.update(dict_in)
def __init__(self, ps_parameters, str_section):
"""Class constructor for Operator.
"""
super(Solver, self).__init__(ps_parameters, str_section)
self.int_iterations = self.get_val('nitn', True)
self.results = sf.create_section(ps_parameters,
self.get_val('results', False))
def __init__(self, ps_parameters, str_section):
"""
Class constructor for ISNR.
"""
super(RER, self).__init__(ps_parameters, str_section)
self.x_f = None #ground truth dft
self.fmetrics = sf.create_section(ps_parameters,
self.get_val('fmetrics', False))
def __init__(self, ps_params, str_section):
"""
Class constructor for Scattering
"""
super(Scattering, self).__init__(ps_params, str_section)
self.depth = self.get_val('depth', True)
self.transform_sec = self.get_val('transform', False)
self.W = sf.create_section(ps_params, self.transform_sec)
self.max_transform_levels = self.W.nlevels
if self.depth > self.max_transform_levels:
raise ValueError(
'cannot have more scattering transform layers than wavelet transform scales'
)
#create the versions of W we'll need in a list, increasing the number of scales at each index
self.W = []
for J in xrange(1, self.max_transform_levels + 1):
ps_params.set_key_val_pairs(self.transform_sec, ['nlevels'], [J])
self.W.append(sf.create_section(ps_params, self.transform_sec))
def __init__(self,ps_parameters,str_section):
"""Class constructor for SampledFT.
"""
super(SampledFT,self).__init__(ps_parameters,str_section)
self.output_fourier = 1
#setup the mask
mask_sec_in = self.get_val('masksectioninput',False)
self.mask = None
if mask_sec_in:
sec_mask = sf.create_section(self.get_params(), mask_sec_in)
self.mask = sec_mask.read({}, True)
def load_csr_avg(self):
sec_input=sf.create_section(self.get_params(),self.sparse_matrix_input)
sec_input.filepath+=self.file_string
self.file_path=sec_input.filepath
if os.path.isfile(self.file_path):
self.csr_avg_save=sec_input.read({},True)
if self.csr_avg_save!=None:
self.csr_avg=csr_matrix((1.0/self.csr_avg_save.data,
self.csr_avg_save.indices,
self.csr_avg_save.indptr),
shape=self.csr_avg_save.shape)
return True
return False
def main():
#configuration specification, absolute path
seed_flag = -1
if len(sys.argv)>1:
ps_path=sys.argv[1]
if len(sys.argv)>2:
seed_flag = sys.argv[2]
else:
ps_path='/home/tim/repos/py_solvers/applications/deconvolution/config/downsampled_cameraman_vbmm.ini'
ps_params = ParameterStruct(ps_path)
seed_flag = int(seed_flag)
if seed_flag!=-1 and seed_flag>0:
#sweep the seed and run this a bunch of times
seeds = np.arange(0,seed_flag)
else:
seeds = [None]
for seed in seeds:
if len(seeds)>1:
ps_params.set_key_val_pairs('Observe1', ['seed'], [seed])
dict_in = {}
sec_input = sf.create_section(ps_params,'Input1')
sec_preprocess = sf.create_section(ps_params,'Preprocess1')
sec_observe = sf.create_section(ps_params,'Observe1')
so_solver = sf.create_section(ps_params,'Solver1')
#read, observe, solve, report
sec_input.read(dict_in)
sec_preprocess.preprocess(dict_in)
sec_observe.observe(dict_in)
t0 = time.time()
so_solver.solve(dict_in)
t1 = time.time()
so_solver.results.display()
so_solver.results.save()
print "Solver finished in " + str(t1-t0) + " seconds"
if 'profiling' in dict_in:
pretty2(dict_in['profiling'])
def setup():
this_dir = os.path.dirname(__file__)
global qbgn
qbgn = np.load(pjoin(this_dir, 'qbgn.npz'))['qbgn']
global verif
verif = np.load(pjoin(this_dir, 'verification.npz'))
global ps_params
ps_params = ParameterStruct(pjoin(this_dir, 'testparameters.ini'))
global cell_image
cell_image = sf.create_section(ps_params, 'Input1').read({}, True)
def __init__(self, ps_params, str_section):
"""
Class constructor for ISNR.
"""
super(ISNR, self).__init__(ps_params, str_section)
self.y = None #observation
self.x = None #ground truth
self.y_key = self.get_val('comparisony', False)
if self.y_key == '':
self.y_key = 'y'
self.transform_name = self.get_val('transform', False)
if self.transform_name != '':
self.transform = sf.create_section(ps_params, self.transform_name)
else:
self.transform = None
def __init__(self, ps_params, str_section):
"""
Class constructor for Operator.
"""
super(OperatorComp, self).__init__(ps_params, str_section)
self.ls_op_names = self.get_val('operators', False)
if self.ls_op_names.__class__.__name__ == 'str':
self.ls_op_names = [self.ls_op_names]
#build the operator objects
self.ls_ops = [
sf.create_section(ps_params, self.ls_op_names[i])
for i in arange(len(self.ls_op_names))
]
self.str_eval = self.get_mult_eval(False)
self.str_eval_adjoint = self.get_mult_eval(True)
self.str_eval_f = self.get_mult_eval(False, '.get_spectrum()')
self.str_eval_adjoint_f = self.get_mult_eval(True, '.get_spectrum()')
self.str_eval_psd = self.get_mult_eval(False, '.get_spectrum_sq()')
def main():
strmainpath='/home/tim/GoogleDrive/[email protected]/PhD/Projects/Classification/Data/GalaxyClassification' #workstation
strmodelpath=strmainpath+'/images_training_rev1_formatted/training_model_small' #workstation
ps_path='/home/tim/repos/py_solvers/applications/classification/galaxy_classification.ini'
ps_params = ParameterStruct(ps_path)
exp_list=['exp_1','exp_2','exp_3','exp_4','exp_5','exp_6','exp_7','exp_8','exp_9','exp_10','exp_11']
class_dict={}
class_dict[exp_list[0]]=['Class1.1','Class1.2','Class1.3']
class_dict[exp_list[1]]=['Class2.1','Class2.2']
class_dict[exp_list[2]]=['Class3.1','Class3.2']
class_dict[exp_list[3]]=['Class4.1','Class4.2']
class_dict[exp_list[4]]=['Class5.1','Class5.2','Class5.3','Class5.4']
class_dict[exp_list[5]]=['Class6.1','Class6.2']
class_dict[exp_list[6]]=['Class7.1','Class7.2','Class7.3']
class_dict[exp_list[7]]=['Class8.1','Class8.2','Class8.3','Class8.4','Class8.5','Class8.6','Class8.7']
class_dict[exp_list[8]]=['Class9.1','Class9.2','Class9.3']
class_dict[exp_list[9]]=['Class10.1','Class10.2','Class10.3']
class_dict[exp_list[10]]=['Class11.1','Class11.2','Class11.3','Class11.4','Class11.5','Class11.6']
class_dict = OrderedDict(sorted(class_dict.items(), key=lambda t: t[0]))
#do classification on testing set with unknown labels
sec_input = sf.create_section(ps_params,'Input2')
dict_in={}
dict_in['x_feature']=sec_input.read(dict_in,return_val=True)
for exp in exp_list:
with open(strmainpath + '/' + exp + '_predict.csv', 'wb') as csvfile:
galaxywriter = csv.writer(csvfile)
Xtest=np.zeros([len(dict_in['x_feature'].keys()),241])
for idx,galaxy_id in enumerate(dict_in['x_feature'].keys()):
#aggregate the test matrix
Xtest[idx,:]=dict_in['x_feature'][galaxy_id]
#load the model for this experiment
scaler = preprocessing.StandardScaler().fit(Xtest)
Xtest=scaler.fit_transform(Xtest)
filehandler = open(strmodelpath + '/' + exp + '_x_model_params.pkl', 'r')
model = cPickle.load(filehandler)
filehandler.close()
#make prediction
ypreds=model.predict_proba(Xtest)
#write to the currently open csv file
galaxywriter.writerow(['GalaxyID']+class_dict[exp]) #header
for idx,galaxy_id in enumerate(dict_in['x_feature'].keys()):
galaxywriter.writerow([galaxy_id]+list(ypreds[idx,:]))
def create_kernel(self):
"""Creates or reads from file the kernel weights and stores
in the class kernel attribute.
"""
if self.str_type != 'file':
self.ary_sz = self.get_val('size', True)
ary_kernel = np.zeros(self.ary_sz)
if self.str_type == 'uniform':
ary_kernel[:] = 1.0 / np.prod(self.ary_sz)
elif self.str_type == 'separable':
pyr_side = np.asfarray([1, 4, 6, 4, 1]) #hard-coded size
ary_kernel = np.outer(pyr_side, pyr_side)
self.ary_sz = np.asarray(ary_kernel.shape)
ary_kernel /= np.sum(ary_kernel)
elif self.str_type == 'rational':
length = 7 #hard-coded size
ary_kernel = np.zeros([2 * length + 1, 2 * length + 1])
for x1 in np.arange(-7, 7 + 1):
for x2 in np.arange(-7, 7 + 1):
ary_kernel[x1 + 7, x2 + 7] = 1.0 / (x1**2 + x2**2 + 1)
self.ary_sz = np.asarray(ary_kernel.shape)
ary_kernel /= np.sum(ary_kernel)
elif self.str_type == 'gaussian':
ary_kernel = gaussian(self.ary_sz, self.gaussian_sigma)
elif self.str_type == 'hamming':
ary_kernel = np.hamming(self.ary_sz)
ary_kernel /= np.sum(ary_kernel)
elif self.str_type == 'file':
sec_input = sf.create_section(self.ps_parameters,
self.get_val('filesection', False))
ary_kernel = sec_input.read({}, True)
self.ary_sz = array(ary_kernel.shape)
else:
raise ValueError("no such kernel " + self.str_type + " supported")
if self.ary_sz.__class__.__name__ == 'int':
self.ary_sz = np.array([self.ary_sz])
self.kernel = ary_kernel
def preprocess(self, dict_in):
"""Loads observation model parameters into a dictionary,
performs the forward model and provides an initial solution.
Args:
dict_in (dict): Dictionary which must include the following members:
'x' (ndarray): The 'ground truth' input signal to be modified.
"""
#build the preprocessing parameters
if (self.str_type == 'brainwebmri'):
#need to pad/crop the input data for wavelet processing
swap_axes = self.get_val('swapaxes', True)
if swap_axes.__class__.__name__ == 'ndarray':
dict_in['x'] = dict_in['x'].swapaxes(swap_axes[0],
swap_axes[1])
input_shape = dict_in['x'].shape
#cropping
new_shape = self.get_val('newshape', True)
if new_shape.__class__.__name__ == 'ndarray':
new_shape = tuple(new_shape)
#figure out what to crop, if anything
if np.any(new_shape < input_shape):
crop_shape = np.min(np.vstack((new_shape, input_shape)),
axis=0)
dict_in['x'] = crop_center(dict_in['x'], crop_shape)
else:
crop_shape = input_shape
#padding
if np.any(new_shape > crop_shape):
pad_shape = np.max(np.vstack((new_shape, crop_shape)), axis=0)
dict_in['x'] = pad_center(dict_in['x'], pad_shape)
# elif (self.str_type == 'superresolution'):
# #need to crop edge of image to make results compatible with the literature
elif (self.str_type == 'phasevelocity'):
mask_sec_in = self.get_val('masksectioninput', False)
bmask_sec_in = self.get_val('boundarymasksectioninput', False)
ls_local_lim_sec_in = self.get_val('vcorrects', False)
if ls_local_lim_sec_in.__class__.__name__ == 'str' and ls_local_lim_sec_in:
ls_local_lim_sec_in = [ls_local_lim_sec_in]
ls_local_lim_secs = []
if ls_local_lim_sec_in:
ls_local_lim_secs = [
sf.create_section(self.get_params(), local_lim_sec_in)
for local_lim_sec_in in ls_local_lim_sec_in
]
ls_local_lim_secs = [{
'phaselowerlimit':
local_lim.get_val('phaselowerlimit', True),
'phaseupperlimit':
local_lim.get_val('phaseupperlimit', True),
'regionupperleft':
local_lim.get_val('regionupperleft', True),
'regionlowerright':
local_lim.get_val('regionlowerright', True)
} for local_lim in ls_local_lim_secs]
#load the mask
if mask_sec_in != '':
sec_mask_in = sf.create_section(self.get_params(), mask_sec_in)
dict_in['mask'] = np.asarray(sec_mask_in.read(dict_in, True),
dtype='bool')
else:
dict_in['mask'] = True
if bmask_sec_in != '':
sec_bmask_in = sf.create_section(self.get_params(),
bmask_sec_in)
dict_in['boundarymask'] = np.asarray(sec_bmask_in.read(
dict_in, True),
dtype='bool')
else:
dict_in['boundarymask'] = np.asarray(np.zeros(
dict_in['x'][:, :, 0].shape),
dtype='bool')
if self.get_val('nmracquisition',
True): #compute phase from lab measurement
#The frame ordering determines in which direction to compute the
#phase differences to obtain positive velocities
frame_order = [0, 1]
if self.get_val('reverseframeorder'):
frame_order = [1, 0]
#Fully sampled fourier transform in order to extract phase data
for frame in xrange(2):
dict_in['x'][:, :, frame] = fftn(
fftshift(dict_in['x'][:, :, frame]))
if self.get_val('extrafftshift', True):
for frame in xrange(2):
dict_in['x'][:, :,
frame] = fftshift(dict_in['x'][:, :,
frame])
#Compute phase differences between the two frames
diff_method = self.get_val('phasedifferencemethod')
if diff_method == 'conjugateproduct':
new_x = (dict_in['x'][:, :, frame_order[1]] *
conj(dict_in['x'][:, :, frame_order[0]]))
theta = angle(new_x)
theta += np.max(np.abs(theta))
# theta /= np.max(np.abs(theta))
# theata *= np.pi*2
magnitude = sqrt(abs(new_x))
elif diff_method == 'subtraction':
theta = (angle(dict_in['x'][:, :, frame_order[1]]) -
angle(dict_in['x'][:, :, frame_order[0]]))
magnitude = 0.5 * (
np.abs(dict_in['x'][:, :, frame_order[0]]) +
np.abs(dict_in['x'][:, :, frame_order[1]]))
# if self.get_val('reverseframeorder'):
# theta = -theta
# theta+=np.abs(np.min(theta))
new_x = magnitude * exp(1j * theta)
else: #synthetic data
theta = angle(dict_in['x'])
magnitude = nabs(dict_in['x'])
#Do phase unwrapping. This works almost everywhere, except
#in certain areas where the range of phases exceeds 2*pi.
#These areas must also be unwrapped with special limits
#which are determined from the data.
dict_global_lims = {}
dict_global_lims['lowerlimit'] = self.get_val(
'phaselowerlimit', True)
dict_global_lims['upperlimit'] = self.get_val(
'phaseupperlimit', True)
dict_global_lims['boundary_mask'] = dict_in['boundarymask']
dict_global_lims['boundary_upperlimit'] = self.get_val(
'boundaryphaseupperlimit', True)
dict_global_lims['boundaryoverlapvcorrects'] = self.get_val(
'boundaryoverlapvcorrects', True)
theta = phase_unwrap(theta, dict_global_lims, ls_local_lim_secs)
magnitude /= np.max(nabs(magnitude))
dict_in['x'] = magnitude * exp(1j * theta)
dict_in['theta'] = dict_in['mask'] * theta
dict_in['magnitude'] = magnitude
dict_in['dict_global_lims'] = dict_global_lims
dict_in['ls_local_lim_secs'] = ls_local_lim_secs
def __init__(self, ps_parameters, str_section):
"""Class constructor for Results.
"""
super(Results,self).__init__(ps_parameters,str_section)
self.ls_metric_names = self.get_val('metrics',False)
if self.ls_metric_names.__class__.__name__ == 'str':
self.ls_metric_names = [self.ls_metric_names]
self.ls_metrics = [sf.create_section(ps_parameters, self.ls_metric_names[i]) \
for i in arange(len(self.ls_metric_names))]
self.ls_metrics_csv = [self.ls_metrics[i]
for i in arange(len(self.ls_metrics))
if self.ls_metrics[i].has_csv]
self.ls_metrics_no_csv = [self.ls_metrics[i]
for i in arange(len(self.ls_metrics))
if not self.ls_metrics[i].has_csv]
self.grid_size = aa([self.get_val('figuregridwidth',True), \
self.get_val('figuregridheight',True)], dtype = np.int)
self.desktop = self.get_val('desktop',True)
self.row_offset = self.get_val('rowoffset',True)
self.int_overlap = max(5,self.get_val('overlap',True))
self.save_interval = self.get_val('saveinterval',True)
self.output_directory = self.get_val('outputdirectory',False)
#default to the configuration file's filename as a prefix
self.output_filename = self.get_val('outputfilename',False,
default_value=self.get_params_fname(False))
self.overwrite_results = self.get_val('overwriteresults',True)
self.zeros = self.get_val('zeros', True, DEFAULT_ZEROS)
self.display_enabled = not self.get_val('disablefigures',True)
self.monitor_count=0
self.resolutions=tuple()
#get screen info
if self.display_enabled:
#try to find a display
screen = os.popen("xrandr -q -d :0").readlines()
if len(screen)>0:
ls_res=re.findall(' connected [0-9]*x[0-9]*', ''.join(screen))
ls_res=re.findall('[0-9]*x[0-9]*', ''.join(ls_res))
#the ordering of these assumes the screens are in the same order
#if this is not the case, simply rearrange your screens ;-)
self.resolutions=tuple([np.array(res.split('x'),'uint16') for res in ls_res])
self.monitor_count = len(self.resolutions)
self.desktop=np.mod(self.desktop,self.monitor_count)
self.arrange_metric_windows() #figure out the coordinates
else: #turn display off
self.monitor_count=0
self.display_enabled = False
#multiple viewport/desktop support not enabled, so wrapping the desktop to the range
#of available monitors
#create a folder in the output directory with the current minute's time stamp
if self.output_directory=='':
print ('Not writing results to file no output dir specified')
return None
st = '/' + self.output_filename
self.output_directory += st + '/'
if not os.path.exists(self.output_directory):
os.makedirs(self.output_directory)
if not self.overwrite_results:
#old timestamping method, keep in case this is deemed better in the future
# st += '/' + datetime.datetime.fromtimestamp(time.time()).strftime('%Y-%m-%d_%H-%M-%S')
#get the count of the current numbered directories
files_enumerated = enumerate(os.walk(self.output_directory))
files,dir_info=files_enumerated.next()
results_count_string=str(len(dir_info[1])).zfill(self.zeros)
self.output_directory += '/' + results_count_string + '/'
if not os.path.exists(self.output_directory):
os.makedirs(self.output_directory)
#save the parameters to this folder as ini, and write as csv
self.ps_parameters.write(self.output_directory + self.output_filename + '_config.ini')
self.ps_parameters.write_csv(self.output_directory + self.output_filename + '_config.' + DEFAULT_CSV_EXT)
def main():
# strpath='/home/tim/GoogleDrive/[email protected]/PhD/Projects/Classification/Data/GalaxyClassification/' #workstation
# strpath='/home/zelda/tr331/Projects/GalaxyChallenge/' #yoshi
# training_dir='images_training_rev1/'
# save_dir='images_training_rev1_formatted/'
strpath = '/home/tim/GoogleDrive/[email protected]/PhD/Projects/Classification/Data/GalaxyClassification/' #workstation
# strpath='/home/zelda/tr331/Projects/GalaxyChallenge' #yoshi
training_dir = 'images_training_rev1/'
save_dir = 'images_training_rev1_formatted/'
# training_dir='images_test_rev1/'
# save_dir='images_test_rev1_formatted/'
exp_list = [
'exp1', 'exp2', 'exp3', 'exp4', 'exp5', 'exp6', 'exp7', 'exp8', 'exp9',
'exp10', 'exp11'
]
for index, exp in enumerate(exp_list):
exp_list[index] = 'class_csv_' + exp
class_dict = {}
class_cols = {}
class_dict[exp_list[0]] = ['Class1.1', 'Class1.2', 'Class1.3']
class_dict[exp_list[1]] = ['Class2.1', 'Class2.2']
class_dict[exp_list[2]] = ['Class3.1', 'Class3.2']
class_dict[exp_list[3]] = ['Class4.1', 'Class4.2']
class_dict[exp_list[4]] = ['Class5.1', 'Class5.2', 'Class5.3', 'Class5.4']
class_dict[exp_list[5]] = ['Class6.1', 'Class6.2']
class_dict[exp_list[6]] = ['Class7.1', 'Class7.2', 'Class7.3']
class_dict[exp_list[7]] = [
'Class8.1', 'Class8.2', 'Class8.3', 'Class8.4', 'Class8.5', 'Class8.6',
'Class8.7'
]
class_dict[exp_list[8]] = ['Class9.1', 'Class9.2', 'Class9.3']
class_dict[exp_list[9]] = ['Class10.1', 'Class10.2', 'Class10.3']
class_dict[exp_list[10]] = [
'Class11.1', 'Class11.2', 'Class11.3', 'Class11.4', 'Class11.5',
'Class11.6'
]
tgt_size = [128, 128]
feature_reduce = Scat().reduce #function handle
gen_csv = 1
gen_bw_cropped_images = 0
gen_feature_vector_files = 0
if gen_feature_vector_files:
feature_vector = {} #dict, keys are galaxyids'
ps_path = strpath + 'galaxy_params.ini'
ps_params = ParameterStruct(ps_path)
S = sf.create_section(ps_params, 'Transform2')
#BEGINCOMMENTED SECTION(only for generating training data)
with open(strpath + 'training_solutions_rev1.csv', 'rb') as csvfile:
galaxyreader = csv.reader(csvfile)
count = 0 #to skip the first row
for row in galaxyreader:
#ENDCOMMENTED SECTION(only for generating training data)
#BEGINCOMMENTED SECTION(only for generating training data)
if count == 0: #skip
header = row
#get the column numbers (as lists) corresponding to each experiment
for exp in exp_list:
class_cols[exp] = [
header.index(_class) for _class in class_dict[exp]
]
else:
print 'processing galaxy ' + row[0]
#decode the row data and separate into classes
if gen_csv:
for exp in exp_list:
with open(strpath + exp + '.csv', 'ab') as csvfile2:
expwriter = csv.writer(csvfile2)
#pull out the probabilities corresponding to each class
class_probs = np.array([
np.float(row[column])
for column in class_cols[exp]
])
#find the maximal class
_class = class_dict[exp][np.argmax(class_probs)]
#output the maximal class
expwriter.writerow([row[0]] + [_class])
galaxyid = row[0]
#now open the file, and do some adjustments
traingalaxyfile = strpath + training_dir + galaxyid + '.jpg'
savegalaxyfile = strpath + save_dir + galaxyid + '.png'
#open the galaxies and resave them if specified
if gen_bw_cropped_images:
galaxydata = mpimg.imread(traingalaxyfile)
newgalaxy = np.zeros(tgt_size)
#get the cropping region
st0 = (galaxydata.shape[0] - tgt_size[0]) / 2
st1 = (galaxydata.shape[1] - tgt_size[1]) / 2
SL0 = slice(st0, st0 + tgt_size[0], None)
SL1 = slice(st1, st1 + tgt_size[1], None)
#convert color-> rgb
galaxydata = rgb2gray(galaxydata)
newgalaxy = galaxydata[SL0, SL1]
f = open(savegalaxyfile, 'wb')
w = png.Writer(*(newgalaxy.shape[1], newgalaxy.shape[0]),
greyscale=True)
newgalaxy = newgalaxy / np.max(newgalaxy) * 255
w.write(f, newgalaxy)
f.close()
if gen_feature_vector_files:
x_data = misc.imread(savegalaxyfile)
feature_vector[galaxyid] = (feature_reduce(
(S * x_data).flatten(), method='average'))
count += 1
#now generate the features vector files for each experiment
if gen_feature_vector_files:
feature_file = strpath + save_dir + 'allfeatures.pkl'
filehandler = open(feature_file, 'wb')
cPickle.dump(feature_vector, filehandler)
filehandler.close()
#reopen
filehandler = open(feature_file, 'r')
feature_vector = cPickle.load(filehandler)
filehandler.close()
for exp in [exp_list[0]]:
print 'creating feature vector file for ' + exp
feature_vector_exp = {}
for _class in class_dict[exp]: #initialize with empty feature list
feature_vector_exp[_class] = []
feature_file_exp = exp + '_features.pkl'
exp_csv_file = exp + '_small.csv'
with open(strpath + save_dir + exp_csv_file, 'rb') as csvfile:
csvreader = csv.reader(csvfile)
for row in csvreader:
feature_vector_exp[row[1]].append(feature_vector[row[0]])
filehandlerexp = open(strpath + save_dir + feature_file_exp, 'wb')
cPickle.dump(feature_vector_exp, filehandlerexp)
filehandlerexp.close()
def solve(self, dict_in):
super(MSIST, self).solve()
##################################
### Transforms and Modalities ####
##################################
H = self.H #mapping from solution domain to observation domain
dict_in['H'] = H
W = self.W #sparsifying transform
dict_in['W'] = W
# precision = 'float32'
# if W.output_dtype!='':
# precision = W.output_dtype
if self.alpha.__class__.__name__ != 'ndarray':
self.alpha = su.spectral_radius(
self.W, self.H, dict_in['x_0'].shape,
self.get_val('alphamethod', False, 'spectrum'))
# self.alpha = su.spectral_radius(self.W, self.H, (64,64,64),
# self.get_val('alphamethod', False, 'spectrum'))
alpha = self.alpha #Lambda_alpha main diagonal (B-sized vector of subband gains)
dict_in['alpha'] = alpha
############
#Input Data#
############
if H.output_fourier:
y_hat = dict_in['y']
else:
#do an extra FFT to do deconvolution in fourier domain
y_hat = fftn(dict_in['y'])
x_n = dict_in['x_0'].copy() #seed current solution
# The famous Joan Lasenby "residuals"
dict_in['x_n'] = x_n
x = dict_in['x'].copy()
dict_in['resid_n'] = x - x_n
x_max = np.max(x)
x_min = np.min(x)
# dict_in['resid_range'] = np.array([x_min - x_max, x_max + x_max])
dict_in['resid_range'] = np.array([-255.0 / 2, 255.0 / 2])
#######################
#Common Initialization#
#######################
#determine whether/not we need double the wavelet transforms on
#each iteration for a complex-valued input signal
self.input_complex = np.iscomplexobj(x_n)
#initialize current solution in sparse domain
#g_i is the element group size (2 for CWT, 4 for CWT and input_complex)
if self.input_complex:
if self.input_phase_encoded:
theta_n = su.phase_unwrap(angle(x_n),
dict_in['dict_global_lims'],
dict_in['ls_local_lim_secs'])
else:
theta_n = angle(x_n)
dict_in['theta_n'] = theta_n
dict_in['magnitude_n'] = nabs(x_n)
w_n = [W * x_n.real, W * x_n.imag]
g_i = 2 * (w_n[0].is_wavelet_complex() + 1)
else:
w_n = [W * x_n]
g_i = (w_n[0].is_wavelet_complex() + 1)
w_n_len = len(w_n)
w_n_it = xrange(w_n_len) #iterator for w_n
dict_in['w_n'] = w_n
#initialize the precision matrix with zeros
S_n = w_n[0] * 0
dict_in['S_n'] = S_n
#initialize continuation parameters
epsilon, nu = self.get_epsilon_nu()
if self.ordepsilon:
# self.ordepsilonpercstart = 8.0/9.0*(.55**2)
epsilon = np.zeros(self.int_iterations + 1, )
self.percentiles = np.arange(30, self.ordepsilonpercstop,
-1.0 / self.int_iterations)
epsilon[0] = self.get_ord_epsilon(w_n[0], np.inf,
self.percentiles[0])
dict_in['epsilon_sq'] = epsilon[0]**2
else:
dict_in['epsilon_sq'] = epsilon**2
if self.convexnu:
nu = np.zeros(self.int_iterations + 1, )
nu[0] = self.get_convex_nu(w_n[0], epsilon[0]**2, np.min(alpha))
dict_in['nu_sq'] = nu[0]**2
else:
dict_in['nu_sq'] = nu**2
#wavelet domain variance used for poisson deblurring
ary_p_var = 0
########################################
#Sparse penalty-specific initialization#
########################################
if self.str_sparse_pen == 'l0rl2_bivar':
w_tilde = w_n[0] * 0
sqrt3 = sqrt(3.0)
sigsq_n = self.get_val('nustop', True)**2
sig_n = sqrt(sigsq_n)
if self.str_sparse_pen == 'l0rl2_group':
tau = self.get_val('tau', True)
tau_rate = self.get_val('taurate', True)
tau_start = self.get_val('taustart', True)
if np.all(tau_start != 0) and tau_rate != 0:
tau_end = tau
tau = tau_start
A = sf.create_section(self.ps_parameters,
self.get_val('clusteraverage',
False)) #cluster
G = sf.create_section(self.ps_parameters,
self.get_val('groupaverage', False)) #group
#initialize A and G with parameters of the master vector
A.init_csr_avg(w_n[0])
G.init_csr_avg(w_n[0])
dup_it = xrange(
A.duplicates) # iterator for duplicate variable space
#initialize non-overlapping space (list of ws objects ls_w_hat_n)
ls_w_hat_n = [[w_n[ix_] * 1 for j in dup_it] for ix_ in w_n_it]
#initialize non-overlapping space precision
ls_S_hat_n = [
((sum([w_n[ix].energy()
for ix in w_n_it]) / g_i) + epsilon[0]**2).invert()
for int_dup in dup_it
]
w_bar_n = [w_n[ix_] * 1 for ix_ in w_n_it]
#using the structure of A, initialize the support of Shat, what
A_row_ix = np.nonzero(A.csr_avg)[0]
A_col_ix = np.nonzero(A.csr_avg)[1]
D = csr_matrix((np.ones(A_col_ix.size, ), (A_row_ix, A_col_ix)),
shape=A.csr_avg.shape)
#compute the support of Shat
ls_S_hat_sup = unflat_list(
D.transpose() * ((w_n[0] * 0 + 1).flatten()), A.duplicates)
#load this vector into each new wavelet subband object
ls_S_hat_sup = [(w_n[0] * 0).unflatten(S_sup)
for S_sup in ls_S_hat_sup]
ls_S_hat_sup = [
S_hat_n_sup.nonzero() for S_hat_n_sup in ls_S_hat_sup
]
del S_sup
del S_hat_n_sup
#precompute AtA (doesn't change from one iteration to the next)
AtA = (A.csr_avg.transpose() * A.csr_avg).tocsr()
#convert tau**2 to csr format to allow for subband-adaptive constraint
if tau.__class__.__name__ != 'ndarray':
tau_sq = np.ones(w_n[0].int_subbands) * tau**2
else:
tau_sq = tau**2
tau_sq_dia = [((w_n[0] * 0 + 1).cast(A.dtype)) * tau_sq
for j in dup_it]
# tau_sq_dia = [((w_n[0]*0+1))*tau_sq for j in dup_it]
tau_sq_dia = su.flatten_list(tau_sq_dia)
offsets = np.array([0])
tau_sz = tau_sq_dia.size
tau_sq_dia = dia_matrix((tau_sq_dia, offsets),
shape=(tau_sz, tau_sz))
#initialize S_hat_bar parameters for efficient matrix inverses
Shatbar_p_filename = A.file_path.split('.pkl')[0] + 'Shatbar.pkl'
if not os.path.isfile(Shatbar_p_filename):
dict_in['col_offset'] = A.int_size
S_hat_n_csr = su.flatten_list_to_csr(ls_S_hat_sup)
su.inv_block_diag((tau_sq_dia) * AtA + S_hat_n_csr, dict_in)
filehandler = open(Shatbar_p_filename, 'wb')
cPickle.dump(dict_in['dict_bdiag'], filehandler, -1)
del S_hat_n_csr
else:
filehandler = open(Shatbar_p_filename, 'rb')
dict_in['dict_bdiag'] = cPickle.load(filehandler)
filehandler.close()
#store all of the l0rl2_group specific variables in the solver dict_in
dict_in['ls_S_hat_n'] = ls_S_hat_n
dict_in['ls_w_hat_n'] = ls_w_hat_n
dict_in['w_bar_n'] = w_bar_n
dict_in['G'] = G
dict_in['A'] = A
dict_in['W'] = W
dict_in['AtA'] = AtA
dict_in['ls_S_hat_sup'] = ls_S_hat_sup
dict_in['w_n_it'] = w_n_it
dict_in['dup_it'] = dup_it
dict_in['ws_dummy'] = w_n[0] * 0
dict_in['g_i'] = g_i
# self.update_duplicates(dict_in,nu[0],epsilon[0],tau_sq, tau_sq_dia)
w_bar_n = dict_in['w_bar_n']
ls_w_hat_n = dict_in['ls_w_hat_n']
ls_S_hat_n = dict_in['ls_S_hat_n']
del D #iterations need A and G only, not D
if (self.str_sparse_pen == 'vbmm' or #vbmm
self.str_sparse_pen == 'vbmm_hmt'):
p_a = self.get_val('p_a', True)
p_b_0 = self.get_val('p_b_0', True)
p_k = self.get_val('p_k', True)
p_theta = self.get_val('p_theta', True)
p_c = self.get_val('p_c', True)
p_d = self.get_val('p_d', True)
b_n = w_n[0] * 0
sigma_n = 0
if self.str_sparse_pen == 'vbmm_hmt':
ary_a = self.get_gamma_shapes(W * dict_in['x_0'])
b_n = w_n[0] * p_b_0
#poisson + gaussiang noise,
#using the scaling coefficients in the regularization (MSIST-P)
if self.input_poisson_corrupted:
#need a 0-padded y to get the right size for the scaling coefficients
b = dict_in['b']
if not H.output_fourier:
y_hat = fftn(dict_in['y'] - b)
else:
y_hat = fftn(ifftn(dict_in['y']) - b)
w_y = (W * dict_in['y_padded'])
dict_in['x_n'] = su.crop_center(x_n, dict_in['y'].shape)
w_y_scaling_coeffs = w_y.downsample_scaling()
self.results.update(dict_in)
print 'Finished itn: n=' + str(0)
#begin iterations here for the MSIST(-X) algorithm, add some profiling info here
if self.profile:
dict_profile = {}
dict_profile['twoft_time'] = []
dict_profile['wht_time'] = []
dict_profile['other_time'] = []
dict_profile['reproj_time_inv'] = []
dict_profile['reproj_time_for'] = []
dict_in['profiling'] = dict_profile
t0 = time.time()
####################
##Begin Iterations##
####################
for n in np.arange(self.int_iterations):
####################
###Landweber Step###
####################
twoft_0 = time.time()
H.set_output_fourier(True) #force Fourier output to reduce ffts
if self.input_complex:
f_resid = y_hat - H * x_n #Landweber difference
else:
f_resid = ifftn(y_hat - H * x_n)
H.set_output_fourier(False)
twoft_1 = time.time()
if self.input_complex:
HtHf = (~H) * f_resid
w_resid = [W * (HtHf).real, W * (HtHf).imag]
else:
w_resid = [W * ((~H) * f_resid)]
wht = time.time()
if self.profile:
dict_profile['twoft_time'].append(twoft_1 - twoft_0)
dict_profile['wht_time'].append(wht - twoft_1)
########################
######Convex Nu#########
#####Ord/HMT Epsilon####
########################
if self.ordepsilon:
if n == 0:
prevepsilon = epsilon[0]
else:
prevepsilon = epsilon[n - 1]
epsilon[n] = self.get_ord_epsilon(w_n[0], prevepsilon,
self.percentiles[n])
dict_in['epsilon_sq'] = epsilon[n]**2
if self.convexnu:
nu[n] = self.get_convex_nu(w_n[0], epsilon[n]**2,
np.min(self.alpha))
dict_in['nu_sq'] = nu[n]**2
###############################################
###Sparse Penalty-Specific Thresholding Step###
###############################################
if self.str_sparse_pen == 'l0rl2_group':
#S_hat_n, w_hat_n, and wb_bar (eqs 11, 19, and 13)
self.update_duplicates(dict_in, nu[n], epsilon[n], tau_sq,
tau_sq_dia)
w_bar_n = dict_in['w_bar_n']
ls_w_hat_n = dict_in['ls_w_hat_n']
#####################################################
#Subband-adaptive subband update of precision matrix#
#####################################################
if (self.str_sparse_pen[0:5] == 'l0rl2'
and self.str_sparse_pen[-5:] != 'bivar'):
if self.str_sparse_pen == 'l0rl2_group':
S0_n = nsum(
[nabs(w_n[ix].ary_lowpass)**2 for ix in w_n_it],
axis=0) / g_i + epsilon[n]**2
S0_n = 1.0 / S0_n
else:
if self.hmt:
S_n_prev = S_n * 1.0
S_n.set_subband(
0, (1.0 /
((1.0 / g_i) * nabs(w_n[0].get_subband(0))**2 +
(epsilon[n]**2))))
for s in xrange(w_n[0].int_subbands - 1, 0, -1):
sigma_sq_parent_us = nabs(
w_n[0].get_upsampled_parent(s))**2
s_parent_sq = 1.0 / (
(2.0**(-2.25)) *
(1.0 / g_i * sigma_sq_parent_us))
S_n.set_subband(s, s_parent_sq)
else:
S_n = (sum([w_n[ix_].energy()
for ix_ in w_n_it]) / g_i +
epsilon[n]**2).invert()
elif (self.str_sparse_pen[0:5] == 'vbmm'
and self.str_sparse_pen[-5:] != 'hmt'):
cplx_norm = 1.0 + self.input_complex
S_n = ((g_i + 2.0 * p_a) *
(sum([w_n[ix_].energy()
for ix_ in w_n_it]) / cplx_norm + sigma_n +
2.0 * b_n).invert())
b_n = (p_k + p_a) * (S_n.get_subband(s) + p_theta).invert()
sigma_n = (1.0 / nu[n]**2 * alpha[s] + S_n).invert()
else:
#iterating through subbands is necessary, coarse to fine
for s in xrange(w_n[0].int_subbands - 1, -1, -1):
#Sendur Selesnick BSWLVE paper
if self.str_sparse_pen == 'l0rl2_bivar':
if s > 0:
s_parent_us = nabs(
w_n[0].get_upsampled_parent(s))**2
s_child = nabs(w_n[0].get_subband(s))**2
yi, yi_mask = su.get_neighborhoods(s_child,
1) #eq 8
s_child_norm = sqrt(s_parent_us + s_child)
sigsq_y = np.sum(yi, axis=yi.ndim - 1) / np.sum(
yi_mask, axis=yi.ndim - 1) #still eq 8...
sig = sqrt(np.maximum(sigsq_y - sigsq_n, 0))
w_tilde.set_subband(s, sqrt3 * sigsq_n /
sig) #the thresholding fn
thresh = np.maximum(
s_child_norm - w_tilde.get_subband(s),
0) / s_child_norm #eq 5
if np.mod(
n, 2
) == 0: #update with the bivariate thresholded coefficients on every other iteration
S_n.set_subband(
s,
(1.0 /
((1.0 / g_i) *
nabs(thresh * w_n[0].get_subband(s))**2 +
(epsilon[n]**2))))
else:
S_n.set_subband(
s, (1.0 / ((1.0 / g_i) *
nabs(w_n[0].get_subband(s))**2 +
(epsilon[n]**2))))
else:
S_n.set_subband(s, (1.0 / (
(1.0 / g_i) * nabs(w_n[0].get_subband(s))**2 +
epsilon[n]**2)))
elif self.str_sparse_pen == 'vbmm_hmt': #vbmm
if n == 0:
sigma_n = 0
else:
sigma_n = (1.0 / nu[n]**2 * alpha[s] +
S_n.get_subband(s))**(-1)
if s > 0:
w_parent_us = w_n[0].get_upsampled_parent(s)
alpha_dec = 2.25
if s > S_n.int_orientations:
s_child = S_n.subband_group_sum(
s - S_n.int_orientations, 'children')
b_child = b_n.subband_group_sum(
s - S_n.int_orientations, 'children')
else:
s_child = 0
b_child = 0
if s < S_n.int_subbands - S_n.int_orientations:
ap = ary_a[s + S_n.int_orientations]
else:
ap = .5
w_en_avg = w_n[0].subband_group_sum(
s, 'parent_children')
S_n.set_subband(
s, (g_i + 2.0 * ary_a[s]) /
(nabs(w_n[0].get_subband(s))**2 + sigma_n +
2.0 * b_n.get_subband(s)))
b_n.set_subband(s, ary_a[s] * w_en_avg)
else: #no parents, so generate fixed-param gammas
S_n.set_subband(
s, (g_i + 2.0 * ary_a[s]) /
(nabs(w_n[0].get_subband(s))**2 + sigma_n +
2.0 * b_n.get_subband(s)))
b_n.set_subband(s, (p_k + ary_a[s]) /
(S_n.get_subband(s) + p_theta))
else:
raise ValueError('no such solver variant')
#########################
#Update current solution#
#########################
for s in xrange(w_n[0].int_subbands - 1, -1, -1):
if self.input_poisson_corrupted:
if s == 0:
ary_p_var = w_y.ary_lowpass
else:
int_lev, int_ori = w_n[0].lev_ori_from_subband(s)
ary_p_var = w_y_scaling_coeffs[int_lev]
ary_p_var[ary_p_var <= 0] = 0
if (self.str_sparse_pen == 'l0rl2_group'):
if s > 0:
for ix_ in w_n_it:
w_n[ix_].set_subband(
s,
(alpha[s] * w_n[ix_].get_subband(s) +
w_resid[ix_].get_subband(s) +
(tau_sq[s]) * w_bar_n[ix_].get_subband(s)) /
(alpha[s] + tau_sq[s]))
else: #a standard msist update for the lowpass coeffs
for ix_ in w_n_it:
w_n[ix_].set_subband(s, \
(alpha[s] * w_n[ix_].get_subband(s) + w_resid[ix_].get_subband(s)) /
(alpha[s] + (nu[n]**2) * S0_n))
else:
for ix_ in w_n_it:
w_n[ix_].set_subband(
s, (alpha[s] * w_n[ix_].get_subband(s) +
w_resid[ix_].get_subband(s)) /
(alpha[s] +
(nu[n]**2 + self.sc_factor * ary_p_var) *
S_n.get_subband(s)))
#end updating subbands
#############################################
##Solution Domain Projection and Operations##
#############################################
tother = time.time()
if self.input_complex:
x_n = np.asfarray(~W * w_n[0], 'complex128')
x_n += 1j * np.asfarray(~W * w_n[1], 'complex128')
m_n = nabs(x_n)
theta_n = angle(x_n)
if self.input_phase_encoded: #need to apply boundary conditions for phase encoded velocity
#the following isn't part of the documented algorithm
#it only needs to be executed at the end to fix
#phase wrapping in very high dynamic-phase regions
theta_n = su.phase_unwrap(angle(x_n),
dict_in['dict_global_lims'],
dict_in['ls_local_lim_secs'])
if self.get_val(
'iterationmask', True
): #apply boundary conditions for phase encoded velocity
theta_n *= dict_in['mask']
if self.get_val('magnitudemask', True, 1):
m_n *= dict_in[
'mask'] #uncomment this for 'total' masking
x_n = m_n * exp(1j * theta_n)
dict_in['theta_n'] = theta_n
dict_in['magnitude_n'] = m_n
else:
x_n = ~W * w_n[0]
tinvdwt = time.time()
#implicit convolution operator is used, so crop and repad
if H.str_object_name == 'Blur' and H.lgc_even_fft:
x_n = su.crop_center(x_n, dict_in['y'].shape)
if self.input_poisson_corrupted and self.spatial_threshold:
x_n[x_n < self.spatial_threshold_val] = 0.0
#finished spatial domain operations on this iteration, store
dict_in['x_n'] = x_n
# store "residuals"
dict_in['resid_n'] = x - x_n
# dict_in['resid_range'] = np.array([np.min(dict_in['resid_n']), np.max(dict_in['resid_n'])])
print "resid min " + str(np.round(np.min(dict_in['resid_n']), 2))
print "resid max " + str(np.round(np.max(dict_in['resid_n']), 2))
if H.str_object_name == 'Blur' and H.lgc_even_fft:
x_n = su.pad_center(x_n, dict_in['x_0'].shape)
#############################
#Wavelet Domain Reprojection#
#############################
if self.profile:
dict_profile['other_time'].append(tother - wht)
if self.input_complex:
w_n = [W * x_n.real, W * x_n.imag]
else:
w_n = [W * x_n]
tforwardwt = time.time()
if self.profile:
dict_profile['reproj_time_inv'].append(tinvdwt - tother)
dict_profile['reproj_time_for'].append(tforwardwt - tinvdwt)
if self.str_sparse_pen[:11] == 'l0rl2_group':
ls_w_hat_n = [[
ls_w_hat_n[ix_][j] * ls_S_hat_sup[j] + w_bar_n[ix_] *
((ls_S_hat_sup[j] + (-1)) * (-1)) for j in dup_it
] for ix_ in w_n_it] #fill in the gaps with w_bar_n
w_bar_n = [W * ((~W) * w_bar_n[ix_]) for ix_ in w_n_it]
ls_w_hat_n = [[
W * ((~W) * w_hat_n) for w_hat_n in ls_w_hat_n[ix_]
] for ix_ in w_n_it]
dict_in['w_bar_n'] = w_bar_n
dict_in['ls_w_hat_n'] = ls_w_hat_n
if tau_rate != 0 and not np.any(tau > tau_end):
tau_sq_dia = tau_rate * tau_sq_dia
tau = np.sqrt(tau_rate) * tau
dict_in['w_n'] = w_n
dict_in['S_n'] = S_n
################
#Update Results#
################
self.results.update(dict_in)
print 'Finished itn: n=' + str(n + 1)
# if self.str_sparse_pen[:11] == 'l0rl2_group' and n==150: #an interesting experiment for cs..
# self.str_sparse_pen = 'l0rl2'
return dict_in
def solve(self,dict_in):
super(Classify,self).solve()
S = self.S
feature_reduce = Scat().reduce #function handle to static method
classes = sorted(dict_in['x'].keys())
dict_in['class_labels']=classes
if self.feature_sec_in != '': #load the feature vectors from disk
sec_input = sf.create_section(self.get_params(), self.feature_sec_in)
dict_in['x_feature'] = sec_input.read(dict_in, return_val = True)
if self.class_sec_in != '':
#The class specification (csv), should already have
#been read in sec_input.
#Now organize dict_in['x_feature'] into classes
#using dict_in['x'] as a reference
#dict_in['x_feature'][exemplarid]->
#dict_in['x_feature'][exemplarclass]
#where dict_in['x_feature']['exemplarclass'] is a list
print 'organizing classes for this experiment...'
for _class in classes:
dict_in['x_feature'][_class]=[]
for _exemplar in dict_in['x'][_class]:
exemplar_feature=dict_in['x_feature'].pop(_exemplar[0])
dict_in['x_feature'][_class].append(exemplar_feature)
else: #no feature vector file specified, so compute
met_output_obj = sf.create_section(self.get_params(),
self.feature_sec_out)
#generate the features if not previously stored from a prior run
#takes a while...
for _class_index,_class in enumerate(classes):
print 'generating scattering features for class ' + _class
n_samples = len(dict_in['x'][_class])
dict_in['x_feature'][_class]= (
[feature_reduce((S*dict_in['x'][_class][sample][1]).flatten(),
method = self.feature_reduction)
for sample in xrange(n_samples)])
#assumes each feature vector is the same size for all exemplars...
dict_in['feature_vec_sz'] = dict_in['x_feature'][classes[0]][-1].size
Xtrain = np.zeros([dict_in['n_training_samples'],
dict_in['feature_vec_sz']],dtype='double')
Xtest = np.zeros([dict_in['n_testing_samples'],
dict_in['feature_vec_sz']],dtype='double')
#vector to hold the training labels
ytrain = np.zeros(dict_in['n_training_samples'],dtype='int16')
ytest = np.zeros(dict_in['n_testing_samples'],dtype='int16')
sample_index = 0
print 'generating training/test data using pre-computed partitions...'
#generate the training and test data matrix (X) and label vectors (y)
for _class_index,_class in enumerate(classes):
for train_ix in dict_in['x_train'][_class]:
Xtrain[sample_index,:] = (dict_in['x_feature'][_class][train_ix])
ytrain[sample_index] = dict_in['y_label'][_class]
sample_index+=1
sample_index = 0
ls_testing_index = []
ls_exemplar_id = []
for _class_index,_class in enumerate(classes):
for test_ix in dict_in['x_test'][_class]:
Xtest[sample_index,:] = (dict_in['x_feature'][_class][test_ix])
ytest[sample_index] = dict_in['y_label'][_class]
ls_testing_index.append(test_ix)
ls_exemplar_id.append(dict_in['x'][_class][test_ix][0])
sample_index+=1
dict_in['y_truth']=ytest
dict_in['y_truth_sample_index']=np.array(ls_testing_index,dtype='int16')
dict_in['exemplar_id']=ls_exemplar_id
#rescaling X and y, since SVM is not scale invariant
# Xtrain /= np.max(Xtrain)
# Xtest /= np.max(Xtest)
scaler = preprocessing.StandardScaler().fit(Xtrain)
Xtrain=scaler.fit_transform(Xtrain)
Xtest=scaler.transform(Xtest)
dict_in['x_scaler_params']=scaler
#train the model
print 'fitting the model...'
if self.classifier_method=='affinepca':
dict_in['pca_train']={}
#we must fit a model separately for each of the class subspaces
for _cls_index,_cls in enumerate(classes):
#xcls_feat is n_samples (C) X n_features (\barSx_c)
xcls_feat=Xtrain[ytrain==dict_in['y_label'][_cls],:]
xcls_feat_mean=np.mean(xcls_feat,axis=0)
#subtract the mean from each sample scattering vector
#(rows in xcls_feat) and do pca
self.clf.fit(xcls_feat-xcls_feat_mean)
#store the components as a list in the pca_train dict
#the first element being the mean (scattering class centroid),
#the second: the n_features x n_components array of PCs
dict_in['pca_train'][_cls]=[xcls_feat_mean,self.clf.components_]
#now fit the models by minimizing the error in the orthogonal linear
#space projection of classes
#error matrix is (D+1) X ()
#where D is the number of components in the pca decomposition
pcaD=self.clf.components_.shape[0]+1
err_mtx=np.zeros([pcaD,dict_in['n_testing_samples'],len(classes)])
for _cls_index,_cls in enumerate(classes):
sx_minus_esxc=Xtest-dict_in['pca_train'][_cls][0]
vc=dict_in['pca_train'][_cls][1]
#calculate the orthoganal projection at each d in D
#for the first row, sum energy along feature axis
err_temp_1 = np.sum(np.abs(sx_minus_esxc)**2,axis=1)
err_temp_rest = -(np.abs(vc.dot(sx_minus_esxc.T))**2)
# pdb.set_trace()
err_temp = np.cumsum(np.vstack([err_temp_1,err_temp_rest]),
axis=0)**(.5)
err_mtx[:,:,_cls_index]=err_temp
#error matrix is now num_samplesXnum_classes
err_mtx=err_mtx[-1,:,:]
#minimum D+1 error along class dimension
error_mins=np.amin(err_mtx,axis=1)
#now find the indices corresponding to these mins
print 'making prediction...'
dict_in['y_pred']=np.array([int(
np.where(error_mins[j]==err_mtx[j,:])[0])
for j in xrange(error_mins.shape[0])])
dict_in['x_model_params']=dict_in['pca_train']
else:#svm or some other method
self.clf.fit(Xtrain,ytrain)
#perform classification/prediction on the test set
print 'making prediction...'
if self.output=='probabilities':
dict_in['y_pred']=self.clf.predict_proba(Xtest)
for index,_class in enumerate(classes):
dict_in[_class]=dict_in['y_pred'][:,index]
else:#non-probabilistic
dict_in['y_pred']=self.clf.predict(Xtest)
dict_in['x_model_params']=self.clf
self.results.update(dict_in)
