def estimate_gradients(x, y, I): range = x.max(0) - x.min(0) #x = (x - x.min(0)) / range x = x[I, :] y = y[I] data = data_lib.Data(x, y) data.set_train() data.is_regression = True nw = method.NadarayaWatsonMethod() nw.cv_params = {} nw.sigma = 1000 nw.train_and_test(data) num_x0 = 40 num_x1 = int(num_x0 * range[1] / range[0]) v = np.zeros((num_x0, num_x1)) x0_vals = np.linspace(x[:, 0].min(), x[:, 0].max(), num_x0) x1_vals = np.linspace(x[:, 1].min(), x[:, 1].max(), num_x1) x1_vals = x1_vals[::-1] v = np.zeros((x1_vals.size, x0_vals.size)) for idx0, x0 in enumerate(x0_vals): for idx1, x1 in enumerate(x1_vals): xi = np.asarray([x0, x1]) d = data_lib.Data(xi[np.newaxis, :], np.asarray([np.nan])) v[idx1, idx0] = nw.predict(d).y print '' gradients = np.gradient(v) g = gradients[0]**2 + gradients[1]**2 g = np.sqrt(g) return g, v
def viz(pc, fig=None, show_histogram=False, show=True): import create_data_set from methods import method source_learner = method.NadarayaWatsonMethod() target_learner = method.NadarayaWatsonMethod() #pc = configs_lib.ProjectConfigs() data = helper_functions.load_object('../' + pc.data_file).data data.set_train() source_data = data.get_transfer_subset(pc.source_labels) source_data.set_target() target_data= data.get_transfer_subset(pc.target_labels) target_data.set_target() source_learner.train_and_test(source_data) target_learner.train_and_test(target_data) source_learner.sigma = 10 target_learner.sigma = 10 x = array_functions.vec_to_2d(np.linspace(data.x.min(), data.x.max(), 100)) test_data = data_lib.Data() test_data.x = x test_data.is_regression = True y_s = source_learner.predict(test_data).fu y_t = target_learner.predict(test_data).fu #array_functions.plot_line(x,y_t-y_s,pc.data_set,y_axes=np.asarray([-5,5])) y = y_t-y_s #y = y - y.mean() array_functions.plot_line(x,y, title=None ,fig=fig,show=show) if show_histogram: array_functions.plot_histogram(data.x,20) x=1
def create_synthetic_linear_classification(n=500, p=50, sigma=1, w=None, x=None): data = data_class.Data() if x is None: x = np.random.uniform(0, 1, (n, p)) data.x = x if w is None: w = np.random.normal(0, sigma, p) data.y = data.x.dot(w) data.y -= data.y.mean() data.y += np.random.normal(0, sigma, n) y = data.y #data.y = np.sign(data.y) #w_eff = inv(x.T.dot(x)).dot(x.T).dot(y) #data.is_regression = False data.is_regression = True w_eff = w data.set_true_y() data.set_train() return data, w_eff
def create_synthetic_regression_transfer(target_fun_or_list, source_fun_or_list, n_target=100, n_source=100, sigma=.5): try: source_funcs = list(source_fun_or_list) except: source_funcs = [source_fun_or_list] try: target_funcs = list(target_fun_or_list) except: target_funcs = [target_fun_or_list] num_target_funcs = len(target_funcs) num_source_funcs = len(source_funcs) n = n_target * num_target_funcs + n_source * num_source_funcs data = data_class.Data() data.x = np.random.uniform(0, 1, (n, 1)) assert n_target == n_source data.data_set_ids = create_ids(n_target, num_source_funcs + num_target_funcs) data.y = np.zeros(n) all_funcs = target_funcs + source_funcs for id, f in enumerate(all_funcs): I = data.data_set_ids == id data.y[I] = f(data.x[I]) data.y += np.random.normal(0, sigma, n) data.set_true_y() data.set_train() data.is_regression = True return data
def create_synthetic_piecewise_transfer(file_dir='', dim=1): n_target = 150 n_source = 150 n = n_target + n_source sigma = .2 data = data_class.Data() data.x = np.random.uniform(0, 1, (n, dim)) data.data_set_ids = np.zeros(n) data.data_set_ids[n_target:] = 1 data.y = np.zeros(n) data.y[(data.data_set_ids == 0) & (data.x[:, 0] <= 1)] = 1 data.y[(data.data_set_ids == 0) & (data.x[:, 0] <= .66)] = 0 data.y[(data.data_set_ids == 0) & (data.x[:, 0] <= .33)] = 2 data.y[(data.data_set_ids == 1) & (data.x[:, 0] <= 1)] = 0 data.y[(data.data_set_ids == 1) & (data.x[:, 0] <= .66)] = 2 data.y[(data.data_set_ids == 1) & (data.x[:, 0] <= .33)] = 1 data.y += np.random.normal(0, sigma, n) data.set_train() data.set_true_y() data.is_regression = True if dim == 1: array_functions.plot_2d(data.x, data.y, data.data_set_ids) s = synthetic_piecewise_file if dim > 1: s = synthetic_piecewise_file % dim if file_dir != '': s = file_dir + '/' + s helper_functions.save_object(s, data)
def create_kc_housing(): file = 'kc_housing/processed_data.pkl' x, y = helper_functions.load_object(file) data = data_class.Data(x, y) data.is_regression = True s = kc_housing_file helper_functions.save_object(s, data)
def combine_data(x1, y1, x2, y2): x = np.vstack((x1, x2)) y = np.concatenate((y1, y2)) data_set_ids = np.concatenate((np.zeros(y1.size), np.ones(y2.size))) data = data_lib.Data(x, y) data.data_set_ids = data_set_ids data.is_regression return data
def create_ds2_data(target_skill_idx=0): ds2_data = pickle.load(open('DS2-processed/DS2-dict.pkl')) x = ds2_data['skill_estimates'] y = ds2_data['skill_estimates'][:, target_skill_idx] x = np.delete(x, target_skill_idx, 1) data = data_class.Data(x, y) s = 'DS2-processed/raw_data.pkl' helper_functions.save_object(s, data)
def create_covtype(): covtype_data = datasets.fetch_covtype() print covtype_data.__dict__ data = data_class.Data() data.x = covtype_data.data data.y = covtype_data.target helper_functions.save_object('data_sets/covtype/raw_data.pkl') pass
def train_on_data(x, y, domain_ids, learner): domain_ids = np.squeeze(domain_ids) data = data_class.Data() data.is_regression = True data.x = array_functions.vec_to_2d(x) data.y = y data.set_train() data.set_true_y() data.set_target() x_plot = np.zeros((0, 1)) y_plot = np.zeros(0) ids_plot = np.zeros(0) density_plot = np.zeros(0) x_test = scipy.linspace(x.min(), x.max(), 100) x_test = array_functions.vec_to_2d(x_test) data_test = data_class.Data() data_test.is_regression = True data_test.x = x_test data_test.y = np.zeros(x_test.shape[0]) data_test.y[:] = np.nan from methods import density kde = density.KDE() max_n = 200.0 for i in np.unique(domain_ids): I = domain_ids == i data_i = data.get_subset(I) if data_i.n > max_n: data_i = data_i.rand_sample(max_n / data_i.n) learner.train_and_test(data_i) o = learner.predict(data_test) x_plot = np.vstack((x_plot, x_test)) y_plot = np.hstack((y_plot, o.y)) ids_plot = np.hstack((ids_plot, np.ones(100) * i)) ''' kde.train_and_test(data_i) dens = kde.predict(data_test) dens.y = dens.y / dens.y.max() den_y = dens.y ''' dens_y = np.ones(data_test.n) density_plot = np.hstack((density_plot, dens_y)) return x_plot, y_plot, ids_plot, density_plot
def create_and_save_data(x, y, domain_ids, file): data = data_class.Data() data.x = array_functions.vec_to_2d(x) data.y = y data.set_train() data.set_target() data.set_true_y() data.is_regression = True data.data_set_ids = domain_ids helper_functions.save_object(file, data)
def __init__(self): self.my_name = 'model' self.username = '' self.password = '' self.hostname = 'apclara1.dl.ac.uk' self.port = 22 self.pathscript = '/opt/ControlRoomApps/OnlineModel/' self.path_exists = False self.data = data.Data() self.client = SSHClient() self.generator_params = ['number_of_particles', 'dist_x', 'dist_y', 'dist_z', 'sig_x', 'sig_y', 'sig_z'] self.scan_progress = -1
def create_spatial_data(dir='climate-month'): file = dir + '/processed_data.pkl' locs, y, ids = helper_functions.load_object(file) y = y.T is_missing_loc = (~np.isfinite(locs)).any(1) locs = locs[~is_missing_loc, :] y = y[~is_missing_loc, :] ids = ids[~is_missing_loc] data = data_class.Data(locs, y) data.multilabel_to_multisource() s = dir + '/raw_data.pkl' helper_functions.save_object(s, data)
def create_transfer_data(locations, pricing_data, I, apply_log=False): x_all = np.vstack((locations[I, :], locations[I, :])) y_all = np.concatenate((pricing_data[I, 0], pricing_data[I, 1])) if apply_log: y_all = np.log(y_all) else: print 'not taking log of labels!' #y_all /= y_all[np.isfinite(y_all)].max() data_set_ids = np.concatenate((np.zeros(I.sum()), np.ones(I.sum()))) data = data_lib.Data(x_all, y_all) data.data_set_ids = data_set_ids data.is_regression = True return data
def create_concrete(transfer=False): file = 'concrete/Concrete_Data.csv' used_field_names, concrete_data = load_csv(file) data = data_class.Data() t = '' if transfer: feat_ind = 0 domain_ind = (used_field_names == 'age').nonzero()[0][0] ages = concrete_data[:, domain_ind] domain_ids = np.zeros(ages.shape) domain_ids[ages < 10] = 1 domain_ids[(ages >= 10) & (ages <= 28)] = 2 domain_ids[ages > 75] = 3 data.x = concrete_data[:, 0:(concrete_data.shape[1] - 2)] #0,3,5 #data.x = preprocessing.scale(data.x) if concrete_num_feats == 1: data.x = array_functions.vec_to_2d(data.x[:, feat_ind]) t = '-feat=' + str(feat_ind) elif concrete_num_feats >= data.x.shape[1]: t = '-' + str(min(data.x.shape[1], concrete_num_feats)) else: assert False data.data_set_ids = domain_ids else: data.x = concrete_data[:, 0:-1] data.y = concrete_data[:, -1] data.set_train() data.set_target() data.set_true_y() data.is_regression = True viz = False if viz: to_use = domain_ids > 0 domain_ids = domain_ids[to_use] concrete_data = concrete_data[to_use, :] np.delete(concrete_data, domain_ind, 1) viz_features(concrete_data, concrete_data[:, -1], domain_ids, used_field_names) return data.x = array_functions.standardize(data.x) #viz_features(data.x,data.y,data.data_set_ids) s = concrete_file % t helper_functions.save_object(s, data)
def combine_predictions(self, x, y_source, y_target): data = data_lib.Data() data.x = x data.is_regression = True g = self.g_nw.predict(data).fu a_t = 1 / (1 + g) b_s = g / (1 + g) if y_source.ndim > 1: a_t = array_functions.vec_to_2d(a_t) b_s = array_functions.vec_to_2d(b_s) fu = a_t * y_target + b_s * (y_source + self.bias) else: fu = np.multiply(a_t, y_target) + np.multiply( b_s, y_source + self.bias) return fu
def create_drosophila(): data = helper_functions.load_object('drosophilia/processed_data.pkl') x, y = data y = np.reshape(y, y.shape[0]) I = np.random.choice(x.shape[0], size=500, replace=False) x = x[I, :] y = y[I] data = data_class.Data() data.x = x data.y = y data.set_train() data.set_target() data.set_true_y() data.is_regression = True helper_functions.save_object(drosophila_file, data)
def make_linear_data(n, p): #X = np.random.uniform(0, 1, (n,p)) X = np.random.normal(0, scale=.1, size=(n,p)) idx = int(n/2) X[:idx, :] += 1 X[idx:, :] -= 1 if p == 1: X = np.sort(X, 0) w = np.random.randn(p) w = np.abs(w) w[:] = 1 noise = np.random.normal(0, scale=1, size=n) noise[:] = 0 Y = X.dot(w) data = data_lib.Data(X, Y + noise) return data, w
def train(self, data): I = data.is_train & data.is_labeled x = data.x[I, :] n_L = x.shape[0] y_L = np.expand_dims(data.y[I], 1) x_L = x x_U = data.x if x_U.shape[0] > self.max_n_L: to_keep = I.nonzero()[0] to_sample = (~I).nonzero()[0] num_to_sample = self.max_n_L - to_keep.size sampled = np.random.choice(to_sample, num_to_sample, replace=False) to_use = np.hstack((to_keep, sampled)) x_U = x_U[to_use, :] x_U_not_transformed = x_U x_L_not_transformed = x_L x_U = self.graph_transform.fit_transform(x_U) n_U = x_U.shape[0] L_UU = self.create_laplacian(x_U, x_U) L_inv = np.linalg.inv(L_UU + self.C * np.eye(n_U)) D_L_inv = np.diag(1 / L_inv.sum(1)) S_SSL = D_L_inv.dot(L_inv) S_SSL_UL = S_SSL[:, :n_L] S_SSL_UL = self.fix_matrix_rows(S_SSL_UL, 1.0 / n_L) ''' x_L = self.graph_transform.transform(x_L) W_UL = self.create_similarity_matrix(x_U, x_L) D_W = np.diag(1 / W_UL.sum(1)) S_NW = (1-self.C)*D_W.dot(W_UL) S_NW = self.fix_matrix_rows(S_NW, 1.0/n_L) f = (S_SSL_UL + S_NW).dot(y_L) ''' f = np.squeeze(S_SSL_UL.dot(y_L)) nw_data = data_lib.Data(x_U_not_transformed, f) nw_data.is_regression = True tune_loo = False if tune_loo: I = nw_data.is_labeled self.nw_method.x = nw_data.x self.nw_method.y = nw_data.y self.nw_method.tune_loo(nw_data) else: self.nw_method.train_and_test(nw_data)
def combine_predictions(self, x, y_source, y_target, data_set_ids): data = data_lib.Data() data.x = x data.is_regression = True if self.constant_b: g = self.g elif self.linear_b: x = self.transform.transform(data.x) g = x.dot(self.g) if self.clip_b: g = array_functions.clip(g, self.g_min, self.g_max) g = g + self.b else: g = self.g_nw.predict(data).fu fu = self.C3 * y_target + (1 - self.C3) * (y_source + g) #fu = y_source + g return fu
def combine_predictions(self, x, y_source, y_target, data_set_ids): assert x.shape[0] == data_set_ids.shape[0] data = data_lib.Data() data.x = x data.is_regression = True if self.linear_b: unique_ids = np.unique(data_set_ids) x = self.transform.transform(data.x) g = np.zeros(x.shape[0]) for i, id in enumerate(unique_ids): I = data_set_ids == id g[I] = x[I].dot(self.g[i]) g[I] = g[I] + self.b[i] if self.clip_b: g = array_functions.clip(g, self.g_min, self.g_max) fu = self.C3 * y_target + (1 - self.C3) * (y_source + g) #fu = y_source + g return fu
def create_synthetic_classification(file_dir='', local=True): dim = 1 n_target = 200 n_source = 200 n = n_target + n_source data = data_class.Data() data.x = np.random.uniform(0, 1, (n, dim)) data.data_set_ids = np.zeros(n) data.data_set_ids[n_target:] = 1 data.y = np.zeros(n) x, ids = data.x, data.data_set_ids I = array_functions.in_range(x, 0, .25) I2 = array_functions.in_range(x, .25, .5) I3 = array_functions.in_range(x, .5, .75) I4 = array_functions.in_range(x, .75, 1) id0 = ids == 0 id1 = ids == 1 data.y[I & id0] = 1 data.y[I2 & id0] = 2 data.y[I3 & id0] = 1 data.y[I4 & id0] = 2 data.y[I & id1] = 3 data.y[I2 & id1] = 4 data.y[I3 & id1] = 3 data.y[I4 & id1] = 4 if local: data.y[I3 & id1] = 4 data.y[I4 & id1] = 3 data.set_true_y() data.set_train() data.is_regression = False noise_rate = 0 #data.add_noise(noise_rate) data.add_noise(noise_rate, id0, np.asarray([1, 2])) data.add_noise(noise_rate, id1, np.asarray([3, 4])) s = synthetic_classification_file if local: s = synthetic_classification_local_file i = id1 array_functions.plot_2d(data.x[i, :], data.y[i]) if file_dir != '': s = file_dir + '/' + s helper_functions.save_object(s, data)
def create_synthetic_linear_regression(n=500, p=50, sigma=1, num_non_zero=None): data = data_class.Data() data.x = np.random.uniform(0, sigma, (n, p)) w = np.random.normal(0, 1, p) #w = np.ones(p) if num_non_zero is not None: w[num_non_zero:] = 0 data.y = data.x.dot(w) data.y += np.random.normal(0, sigma, n) data.is_regression = True data.set_true_y() data.set_train() suffix = str(n) + '-' + str(p) + '-' + str(sigma) data.metadata = dict() data.metadata['true_w'] = w.T if num_non_zero is not None: suffix += '-nnz=' + str(num_non_zero) s = synthetic_linear_reg_file % suffix helper_functions.save_object(s, data)
def create_synthetic_step_linear_transfer(file_dir=''): n_target = 100 n_source = 100 n = n_target + n_source sigma = .5 data = data_class.Data() data.x = np.random.uniform(0, 1, (n, 1)) data.data_set_ids = np.zeros(n) data.data_set_ids[n_target:] = 1 data.y = np.reshape(data.x * 5, data.x.shape[0]) data.y[(data.data_set_ids == 1) & (data.x[:, 0] >= .5)] += 4 data.y += np.random.normal(0, sigma, n) data.set_defaults() data.is_regression = True array_functions.plot_2d(data.x, data.y, data.data_set_ids, title='Linear Step Data Set') s = synthetic_step_linear_transfer_file if file_dir != '': s = file_dir + '/' + s helper_functions.save_object(s, data)
def start(self): # setup logger gv.logger = logger.Logger() gv.sm = self.ids['screen_manager'] self.menu_utama = self.add_screen(menu_utama.MenuUtama(), False) self.info_ngabandungan = self.add_screen(info_bdg.InfoNgabandungan()) self.peta = self.add_screen(peta.Peta()) self.data = self.add_screen(data.Data()) self.info_perkembangan_rumah = self.add_screen(info_perkembangan_rumah.InfoPerkembanganRumah()) self.info_tematik = self.add_screen(info_tematik.InfoTematik()) gv.sm.current = "Menu Utama" # gv.sm.current = "Info Tematik" # auto standby # return to main menu after a period of inactivity Clock.schedule_interval(self.standby_count_down, 10) self.bind(on_touch_down = self.reset_standby) self.bind(on_touch_up = self.log_touch_up)
def create_bike_sharing(): file = 'bike_sharing/day.csv' columns = [0] + range(2, 16) all_field_names = pd.read_csv(file, nrows=1, dtype='string') all_field_names = np.asarray(all_field_names.keys()) used_field_names = all_field_names[columns] bike_data = np.loadtxt(file, skiprows=1, delimiter=',', usecols=columns) domain_ind = used_field_names == 'yr' domain_ids = np.squeeze(bike_data[:, domain_ind]) #inds_to_keep = (used_field_names == 'temp') | (used_field_names == 'atemp') #bike_data = bike_data[:,inds_to_keep] #used_field_names = used_field_names[inds_to_keep] viz = True to_use = np.asarray([8, 9, 10, 11]) x = bike_data[:, to_use] used_field_names = used_field_names[to_use] y = bike_data[:, -1] if viz: #learner = make_learner() learner = None viz_features(x, y, domain_ids, used_field_names, learner=learner) field_to_use = 1 x = x[:, field_to_use] data = data_class.Data() data.is_regression = True data.x = array_functions.vec_to_2d(x) data.x = array_functions.standardize(data.x) data.y = y data.y = array_functions.normalize(data.y) data.set_defaults() data.data_set_ids = domain_ids s = bike_file % ('-feat=' + str(field_to_use)) helper_functions.save_object(s, data) pass
import numpy as np import scipy from data_sets import create_data_set from data import data as data_lib from utility import helper_functions file = 'SAheart.data.txt' all_field_names, data = create_data_set.load_csv(file, has_field_names=True,dtype='string',delim=str(',')) data[data == 'Present'] = '1' data[data == 'Absent'] = '0' data = data[:, 1:] data = data.astype(np.float) data = data_lib.Data(data[:, :-1], data[:, -1]) data.set_train() data.set_target() helper_functions.save_object('raw_data.pkl', data) print ''
def predict_g(self, x, data_set_ids=None): data = data_lib.Data() data.x = x data.is_regression = True g = self.g_nw.predict(data).fu return g
sizes=dot_size, alpha=1, subtract_min=False, fig=fig2) pl.title('Values 2') array_functions.move_fig(fig1, 500, 500, 2000, 100) array_functions.move_fig(fig2, 500, 500, 2600, 100) pl.show(block=True) data = (x, y) x = np.vstack((x[I1, :], x[I2, :])) data_set_ids = np.hstack((np.zeros(I1.sum()), np.ones(I2.sum()))) y = np.hstack((y[I1], y[I2])) data = data_lib.Data(x, y) data.x[:, 0] = array_functions.normalize(data.x[:, 0]) data.x[:, 1] = array_functions.normalize(data.x[:, 1]) data.data_set_ids = data_set_ids print 'n-all: ' + str(data.y.size) if save_data: s = '../kc-housing-spatial' if suffix != '': s += '-' + suffix helper_functions.save_object(s + '/raw_data.pkl', data) else: feats_to_clear = ['id', 'date', 'yr_renovated', 'zipcode', 'lat', 'long'] clear_idx = array_functions.find_set(feat_names, feats_to_clear + [y_name]) x = data[:, ~clear_idx] x = array_functions.remove_quotes(x)
def train(self, data): ''' self.C = 1 self.C2 = 10 self.k = 1 ''' #self.C = 100 #self.configs.use_fused_lasso = False g_max = 2 g0_oracle = np.zeros(data.n) g0_oracle[data.x[:, 0] < .5] = g_max f = self.create_eval(data, self.C) g = self.create_gradient(data, self.C) bounds = list((0, g_max) for i in range(data.n)) #bounds = list((i, i) for i in range(data.n)) #bounds = list((0, 0) for i in range(data.n)) #bounds[0] = (0,None) #self.include_bias = False if self.include_bias: bounds = [(None, None)] + bounds #bounds = [(10, 10)] + bounds else: bounds = [(0, 0)] + bounds n = data.n + 1 g0 = np.zeros(n) g0[1:] = g0_oracle #g0[:] = 1 x = data.x y_s = np.squeeze(data.y_s[:, 0]) y_t = np.squeeze(data.y_t[:, 0]) y = data.y W = -array_functions.make_laplacian_kNN(data.x, self.k, self.configs.metric) #W = array_functions.make_graph_radius(data.x, self.radius, self.configs.metric) #W = array_functions.make_graph_adjacent(data.x, self.configs.metric) W = array_functions.try_toarray(W) if not data.is_regression: y = array_functions.make_label_matrix( data.y)[:, data.classes].toarray() y = y[:, 0] reg = self.create_reg(data.x) reg2 = self.create_reg2(data.x) if self.configs.use_fused_lasso: method = 'SLSQP' max_iter = 10000 maxfun = 10000 fused_lasso = ScipyOptNonparametricHypothesisTransfer.fused_lasso lasso = lambda x: self.C - fused_lasso(x, W) constraints = [{'type': 'ineq', 'fun': lasso}] if self.configs.no_reg: constraints = () args = (x, y, y_s, y_t, 0, reg, self.C2, reg2) else: method = 'L-BFGS-B' max_iter = np.inf maxfun = np.inf constraints = () args = (x, y, y_s, y_t, self.C, reg, self.C2, reg2) if self.g_supervised: x = np.squeeze(data.x) assert x.ndim == 1 min_i = x.argmin() max_i = x.argmax() bounds[min_i] = (1, None) bounds[max_i] = (0, 0) options = { 'disp': False, 'maxiter': max_iter, 'maxfun': maxfun, #'pgtol': 1e-8 } results = optimize.minimize( f, g0, method=method, bounds=bounds, jac=g, options=options, constraints=constraints, args=args, ) compare_results = False if compare_results or not results.success: options['disp'] = False options['approx_grad'] = True results2 = optimize.minimize(f, g0, method=method, bounds=bounds, options=options, constraints=constraints, args=args) if compare_results: err = results.x - results2.x if norm(results2.x[1:]) == 0: print 'All zeros - using absolute error' print 'Abs Error - g: ' + str(norm(err[1:])) else: print 'Rel Error - g: ' + str( norm(err[1:]) / norm(results2.x[1:])) if not self.include_bias: if norm(results2.x[0]) == 0: print 'Abs Error - b: ' + str(norm(err[0])) else: print 'Rel Error - b: ' + str( norm(err[0]) / norm(results2.x[0])) rel_error = norm(results.fun - results2.fun) / norm(results2.fun) print 'Rel Error - f(g*): ' + str(rel_error) if rel_error > .001 and norm(results2.x) > 0: print 'Big error: C=' + str(self.C) + ' C2=' + str(self.C2) if not results.success: results = results2 self.g = results.x[1:] self.bias = results.x[0] if not results.success: self.g[:] = 0 self.bias = 0 #print 'Failed: ' + results.message ''' I = data.arg_sort() x = (data.x[I,:]) g = array_functions.vec_to_2d(results.x[I]) v = np.hstack((x,g)) print v print '' ''' s = 'C=' + str(self.C) + ',C2=' + str(self.C2) + ',k=' + str( self.k) + '-' if not results.success: s += 'Opt failed - ' has_nonneg = (self.g[1:] < -1e-6).any() if has_nonneg: s += 'Negative g - min value: ' + str(self.g.min()) if not results.success or has_nonneg: print s + ': ' + results.message self.g[:] = 0 else: pass g_data = data_lib.Data() g_data.x = data.x g_data.y = results.x[1:] g_data.is_regression = True g_data.set_train() g_data.set_target() g_data.set_true_y() self.g_nw.train_and_test(g_data) if results.success: pass