def get_commit_data(self, branch): commits = [] commit_objs = [] repo = self.clone_branch(branch) #print(branch, "++++++") path = self.repo_path + '_' + branch for commit in repo.walk(repo.head.target, GIT_SORT_TOPOLOGICAL | GIT_SORT_REVERSE): commit_id = commit.id.hex commit_message = commit.message res = re.search( r'\b{bug|fix|issue|error|patch|defect|problem|wrong|fail|resol|#}\b', utils().stemming(commit_message), re.IGNORECASE) if res is not None: commits_buggy = 1 else: commits_buggy = 0 if len(commit.parent_ids) == 0: commit_parent = None else: commit_parent = commit.parent_ids[0].hex commit_objs.append(commit) commits.append([ commit_id, commit_message, commit_parent, commits_buggy, branch, commit.commit_time ]) #print(commit_objs) self.repos.append([repo, path]) return commits, commit_objs
def get_current_commit_objects(self): commits = [] commit_objs = [] for commit in self.repo.walk(self.repo.head.target, GIT_SORT_TOPOLOGICAL | GIT_SORT_REVERSE): commit_id = commit.id.hex commit_message = commit.message res = re.search( r'\b{bug|fix|issue|error|patch|defect|problem|wrong|fail|resol|#}\b', utils().stemming(commit_message), re.IGNORECASE) if res is not None: commits_buggy = 1 else: commits_buggy = 0 if len(commit.parent_ids) == 0: commit_parent = None else: commit_parent = commit.parent_ids[0].hex commit_objs.append(commit) commits.append([ commit_id, commit_message, commit_parent, commits_buggy, self.repo.head.name, commit.commit_time ]) self.commit = commit_objs return commits
def predict(self, data, xTrain, W, me, std, subset): """ Returns the predicted labels Parameters: ---------- data: np.array (n_samples1, n_features) test data xTrain: np.array (n_samples2, n_features) train data W: np.array learnt weight matrix me: np.array (n_features,) or (n_subset,) mean of train data features std: np.array (n_features,) or (n_subset,) standard deviation of train data features subset: list subset of train data to be used Returns: ------- labels: np.array (n_samples1,) labels of the train data scores: np.array (n_samples1, numClasses) scores of each sample """ util = utils() kernel_type = self.kernel_type gamma = self.gamma n_components = self.n_components compress_type = self.compress_type N = data.shape[0] M = data.shape[1] label = np.zeros((N, )) feature_indices = np.array(range(M)) sample_indices = np.array(range(xTrain.shape[0])) if (compress_type == 'zero_one'): xTrain = util.zero_one_normalization(xTrain) data = util.zero_one_normalization(data) elif (compress_type == 'sigmoid'): xTrain = util.logsig(xTrain) data = util.logsig(data) elif (compress_type == 'saturate'): xTrain = util.saturate_fcn1(xTrain) data = util.saturate_fcn1(data) else: raise ValueError('wrong compress_type selected!') X1, X2 = util.select_(data, xTrain, kernel_type, subset, feature_indices, sample_indices) data1 = util.kernel_transform(X1=X1, X2=X2, kernel_type=kernel_type, n_components=n_components, gamma=gamma) data1 = util.normalize_(data1, me, std) data1 = util.add_bias(data1) scores = data1.dot(W) label = np.argmax(scores, axis=1) return label, scores
def validate(self, username, password, token, user_agent, ip_addr): if not utils().check_run(username): message = { "status": "ok", "code": 5, "params": [], "message": "Success operation" } return self.response(message, 200, BaseHandler.headers_json, None, True) body = {} body["token"] = token try: body["password"] = base64.b64decode(str(password)).decode("utf-8") except: return self.response( BaseHandler.config["RESPONSES_GENERIC"]["bad_request"], 400, BaseHandler.headers_json, None, True) run_numero, DV = utils().parse_run(username) body["numero"] = run_numero body["metadata"] = logs().metadata(user_agent, ip_addr, run_numero) return body, run_numero
def fit(self, xTrain, yTrain): """ fits a classifier to the data Parameters: ----------- xTrain: np.array (2D array) (n_samples,n_features) data matrix yTrain: np.array (n_samples,) label array, labels are in range [0,numClasses-1] Returns: ------- W: np.array (n_features, numClasses) weight matrix me: np.array (n_features,) mean of train features std: np.array (n_features,) standard deviation of train features subset: list list of selected subset for kernel_type = linear, sin, tanh, TL1, rbf and empty list otherwise """ util = utils() # N = xTrain.shape[0] # M = xTrain.shape[1] # numClasses=np.unique(yTrain).size gamma = self.gamma kernel_type = self.kernel_type n_components = self.n_components PV_scheme = self.PV_scheme do_pca = self.do_pca_in_selection non_linear_kernels = ['linear', 'rbf', 'sin', 'tanh', 'TL1'] if (kernel_type in non_linear_kernels): subset = util.subset_selection(xTrain, yTrain, n_components, PV_scheme, 'classification', do_pca) data1 = xTrain[subset, ] else: subset = [] data1 = None xTrain1 = util.kernel_transform(X1=xTrain, X2=data1, kernel_type=kernel_type, n_components=n_components, gamma=gamma) #standardize the dataset xTrain1, me, std = util.standardize(xTrain1, centering=True) W, f, iters, fvals = self.inner_opt(xTrain1, yTrain, data1) return W, f, iters, fvals, subset, me, std
def inner_opt(self, X, Y, data1): """ It performs optimization using the MCM classifier Parameters: X: np.array (n_samples,n_features) data matrix Y: np.array (n_samples,) label matrix data1: np.array (n_samples1, n_features) data for ['linear','rbf','sin','tanh','TL1'] forming kernels Returns: -------- W : np.array Weights learnt f: np.array best value of f iters: int total number of iterations run fvals: np.float function values for each itertion """ gamma = self.gamma kernel_type = self.kernel_type iterMax2 = self.iterMax2 iterMax1 = self.iterMax1 tol = self.tol util = utils() non_linear_kernels = ['linear', 'rbf', 'sin', 'tanh', 'TL1'] #if data1 = None implies there is no kernel computation, i.e., there is only primal solvers applicable if (data1 is not None): if (self.reg_type == 'M'): K = util.margin_kernel(X1=data1, kernel_type=kernel_type, gamma=gamma) if (kernel_type in non_linear_kernels): K_plus, K_minus = util.matrix_decomposition(K) W_prev, f, iters, fvals = self.train(X, Y, K_plus=K_plus, K_minus=None, W=None) if (kernel_type == 'linear' or kernel_type == 'rbf'): #for mercer kernels no need to train for outer loop print('Returning for mercer kernels') return W_prev, f, iters, fvals else: print('Solving for non - mercer kernels') #for non mercer kernels, train for outer loop with initial point as W_prev W_best = np.zeros(W_prev.shape) W_best[:] = W_prev[:] f_best = np.inf iter_best = 0 fvals = np.zeros((iterMax1 + 1, )) iters = 0 fvals[iters] = f rel_error = 1.0 print('iters =%d, f_outer = %0.9f' % (iters, f)) train_acc_best = 0.0 while (iters < iterMax2 and rel_error > tol): iters = iters + 1 W, f, iters1, fvals1 = self.train(X, Y, K_plus=K_plus, K_minus=K_minus, W=W_prev) rel_error = np.abs( np.linalg.norm(W - W_prev, 'fro')) / ( np.linalg.norm(W_prev, 'fro') + 1e-08) W_prev[:] = W[:] X1 = util.add_bias(X) scores = X1.dot(W) pred = np.argmax(scores, axis=1) train_acc = np.sum(pred == Y) * 100 / Y.shape[0] if (train_acc >= train_acc_best): train_acc_best = train_acc - 0.5 W_best[:] = W[:] f_best = f iter_best = iters else: break fvals[iters] = -1 return W_best, f_best, iter_best, fvals else: #if kernel_type is wrong raise ValueError( 'Please choose a kernel_type from linear, rbf, sin, tanh or TL1 for reg_type = M to work' ) else: W, f, iters, fvals = self.train(X, Y, K_plus=None, K_minus=None, W=None) else: #i.e., data1 is None -> we are using primal solvers with either l1, l2, ISTA or elastic net penalty if (self.reg_type == 'M'): raise ValueError( 'Please choose a kernel_type from linear, rbf, sin, tanh or TL1 for reg_type = M to work' ) else: W, f, iters, fvals = self.train(X, Y, K_plus=None, K_minus=None, W=None) return W, f, iters, fvals return W, f, iters, fvals
def train(self, xTrain, yTrain, K_plus=None, K_minus=None, W=None): """ Training procedure for MCM classifier Parameters: ----------- xTrain: np.array (n_samples,n_features) data matrix yTrain: np.array (n_samples,) label matrix K_plus: np.array (n_samples1,n_samples2) kernel matrix for positive definite part of matrix K_minus: np.array (n_samples1,n_samples2) kernel matrix for negative definite part of matrix W: np.array (n_features, n_classes) This is passed only if we are doing multiple outer loop iterations Returns: ------- W_best : np.array (n_features, n_classes) Best weights learnt f_best: np.array best value of f iters_best: int total number of iterations run fvals: np.float function values for each itertion """ #min D(E|w|_1 + (1-E)*0.5*|W|_2^2) + C*\sum_i\sum_(j)|f_j(i)| + \sum_i\sum_(j_\neq y_i)max(0,(1-f_y_i(i) + f_j(i))) #setting C = 0 gives us SVM # or when using margin term i.e., reg_type = 'M' #min D(E|w|_1) + (E)*0.5*\sum_j=1 to numClasses (w_j^T(K+ - K-)w_j) + C*\sum_i\sum_(j)|f_j(i)| + \sum_i\sum_(j_\neq y_i)max(0,(1-f_y_i(i) + f_j(i))) #setting C = 0 gives us SVM with margin term util = utils() if (self.do_upsample == True): xTrain, yTrain = util.upsample(xTrain, yTrain, new_imbalance_ratio=0.5, upsample_type=1) xTrain = util.add_bias(xTrain) M = xTrain.shape[1] N = xTrain.shape[0] numClasses = np.unique(yTrain).size verbose = False C = self.C1 #for loss function of MCM D = self.C2 #for L1 or L2 penalty E = self.C3 #for elastic net penalty or margin term iterMax1 = self.iterMax1 eta_zero = self.eta class_weighting = self.class_weighting reg_type = self.reg_type update_type = self.update_type tol = self.tol np.random.seed(1) if (W is None): W = 0.001 * np.random.randn(M, numClasses) W = W / np.max(np.abs(W)) else: W_orig = np.zeros(W.shape) W_orig[:] = W[:] class_weights = np.zeros((numClasses, )) sample_weights = np.zeros((N, )) #divide the data into K clusters for i in range(numClasses): idx = (yTrain == i) class_weights[i] = 1.0 / np.sum(idx) sample_weights[idx] = class_weights[i] G_clip_threshold = 1000 W_clip_threshold = 5000 eta = eta_zero scores = xTrain.dot(W) #samples X numClasses N = scores.shape[0] correct_scores = scores[range(N), np.array(yTrain, dtype='int32')] mat = (scores.transpose() - correct_scores.transpose()).transpose() mat = mat + 1.0 mat[range(N), np.array(yTrain, dtype='int32')] = 0.0 scores1 = np.zeros(scores.shape) scores1[:] = scores[:] scores1[range(N), np.array(yTrain, dtype='int32')] = -np.inf max_scores = np.max(scores1, axis=1) mat1 = 1 - correct_scores + max_scores f = 0.0 if (reg_type == 'l2'): f += D * 0.5 * np.sum(W**2) if (reg_type == 'l1'): f += D * np.sum(np.abs(W)) if (reg_type == 'en'): f += D * 0.5 * (1 - E) * np.sum(W**2) + D * E * np.sum(np.abs(W)) if (class_weighting == 'average'): f1 = C * 0.5 * np.sum(scores**2) + 0.5 * np.sum((mat1)**2) f += (1.0 / N) * f1 else: f1 = C * 0.5 * np.sum( (scores**2) * sample_weights[:, None]) + 0.5 * np.sum( (mat1**2) * sample_weights[:, None]) f += (1.0 / numClasses) * f1 if (K_minus is not None): temp_mat = np.dot(K_minus, W_orig[0:(M - 1), ]) for i in range(numClasses): #add the term (E/2*numclasses)*lambda^T*K_plus*lambda for margin if (K_plus is not None): w = W[0:(M - 1), i] f2 = np.dot(np.dot(K_plus, w), w) f += ((0.5 * E) / (numClasses)) * f2 #the second term in the objective function if (K_minus is not None): f3 = np.dot(temp_mat[:, i], w) f += -((0.5 * E) / (numClasses)) * f3 iter1 = 0 print('iter1=%d, f=%0.3f' % (iter1, f)) f_best = f fvals = np.zeros((iterMax1 + 1, )) fvals[iter1] = f_best W_best = np.zeros(W.shape) iter_best = iter1 f_prev = f_best rel_error = 1.0 # f_prev_10iter=f if (reg_type == 'l1' or reg_type == 'en' or reg_type == 'M'): # from paper: Stochastic Gradient Descent Training for L1-regularized Log-linear Models with Cumulative Penalty if (update_type == 'adam' or update_type == 'adagrad' or update_type == 'rmsprop'): u = np.zeros(W.shape) else: u = 0.0 q = np.zeros(W.shape) z = np.zeros(W.shape) all_zeros = np.zeros(W.shape) eta1 = eta_zero v = np.zeros(W.shape) v_prev = np.zeros(W.shape) vt = np.zeros(W.shape) m = np.zeros(W.shape) vt = np.zeros(W.shape) cache = np.zeros(W.shape) eps = 1e-08 decay_rate = 0.99 mu1 = 0.9 mu = mu1 beta1 = 0.9 beta2 = 0.999 iter_eval = 10 #evaluate after every 10 iterations batch_sz = self.batch_sz idx_batches, sample_weights_batch, num_batches = util.divide_into_batches_stratified( yTrain, batch_sz) lr_schedule = 'triangular2' iter2 = 0 cyclic_lr_schedule = ['triangular', 'triangular2', 'exp_range'] if (lr_schedule in cyclic_lr_schedule): base_lr = eta max_lr = 1.5 * base_lr step_size = num_batches mode = lr_schedule gamma = 1. scale_fn = None scale_mode = 'cycle' clr = CyclicLR(base_lr=base_lr, max_lr=max_lr, step_size=step_size, mode=mode, gamma=gamma, scale_fn=scale_fn, scale_mode=scale_mode) while (iter1 < iterMax1 and rel_error > tol): iter1 = iter1 + 1 for batch_num in range(0, num_batches): iter2 += 1 if (lr_schedule in cyclic_lr_schedule): eta1 = clr.clr(iter2) eta = clr.clr(iter2) elif (lr_schedule == 'constant'): eta = eta eta1 = eta1 elif (lr_schedule == 'decrease'): eta = eta_zero / np.power((iter1), 1) eta1 = eta_zero / np.power((iter1), 1) # batch_size=batch_sizes[j] test_idx = idx_batches[batch_num] data = xTrain[test_idx, ] labels = yTrain[test_idx, ] N = labels.shape[0] scores = data.dot(W) correct_scores = scores[range( N ), np.array( labels, dtype='int32' )] #label_batches[j] for this line should be in the range [0,numClasses-1] mat = (scores.transpose() - correct_scores.transpose()).transpose() mat = mat + 1.0 mat[range(N), np.array(labels, dtype='int32')] = 0.0 scores1 = np.zeros(scores.shape) scores1[:] = scores[:] scores1[range(N), np.array(labels, dtype='int32')] = -np.inf max_scores = np.max(scores1, axis=1) max_scores_idx = np.argmax(scores1, axis=1) mat1 = 1 - correct_scores + max_scores dscores1 = np.zeros(mat.shape) dscores1[range(N), np.array(max_scores_idx, dtype='int32')] = mat1 row_sum = np.sum(dscores1, axis=1) dscores1[range(N), np.array(labels, dtype='int32')] = -row_sum if (C != 0.0): dscores2 = np.zeros(scores.shape) dscores2[:] = scores[:] else: dscores2 = np.zeros(scores.shape) dscores1 = 2 * dscores1 dscores2 = 2 * dscores2 if (class_weighting == 'average'): gradW = np.dot((dscores1 + C * dscores2).transpose(), data) gradW = gradW.transpose() gradW = (0.5 / N) * gradW else: sample_weights_b = sample_weights_batch[batch_num] gradW = np.dot((dscores1 + C * dscores2).transpose(), data * sample_weights_b[:, None]) gradW = gradW.transpose() gradW = (0.5 / numClasses) * gradW if (np.sum(gradW**2) > G_clip_threshold): #gradient clipping gradW = G_clip_threshold * gradW / np.sum(gradW**2) if (update_type == 'sgd'): W = W - eta * gradW elif (update_type == 'momentum'): v = mu * v - eta * gradW # integrate velocity W += v # integrate position elif (update_type == 'nesterov'): v_prev[:] = v[:] # back this up v = mu * v - eta * gradW # velocity update stays the same W += -mu * v_prev + ( 1 + mu) * v # position update changes form elif (update_type == 'adagrad'): cache += gradW**2 W += -eta1 * gradW / (np.sqrt(cache) + eps) elif (update_type == 'rmsprop'): cache = decay_rate * cache + (1 - decay_rate) * gradW**2 W += -eta1 * gradW / (np.sqrt(cache) + eps) elif (update_type == 'adam'): m = beta1 * m + (1 - beta1) * gradW mt = m / (1 - beta1**(iter1 + 1)) v = beta2 * v + (1 - beta2) * (gradW**2) vt = v / (1 - beta2**(iter1 + 1)) W += -eta1 * mt / (np.sqrt(vt) + eps) else: W = W - eta * gradW if (reg_type == 'M'): gradW1 = np.zeros(W.shape) gradW2 = np.zeros(W.shape) for i in range(numClasses): w = W[0:(M - 1), i] if (K_plus is not None): gradW1[0:(M - 1), i] = ((E * 0.5) / (numClasses)) * 2 * np.dot(K_plus, w) if (K_minus is not None): gradW2[0:(M - 1), i] = ((E * 0.5) / (numClasses)) * temp_mat[:, i] if (update_type == 'adam'): W += -(gradW1 - gradW2) * (eta1 / (np.sqrt(vt) + eps)) elif (update_type == 'adagrad' or update_type == 'rmsprop'): W += -(gradW1 - gradW2) * (eta1 / (np.sqrt(cache) + eps)) else: W += -(gradW1 - gradW2) * (eta) if (reg_type == 'ISTA'): if (update_type == 'adam'): idx_plus = W > D * (eta1 / (np.sqrt(vt) + eps)) idx_minus = W < -D * (eta1 / (np.sqrt(vt) + eps)) idx_zero = np.abs(W) < D * (eta1 / (np.sqrt(vt) + eps)) W[idx_plus] = W[idx_plus] - D * ( eta1 / (np.sqrt(vt[idx_plus]) + eps)) W[idx_minus] = W[idx_minus] + D * ( eta1 / (np.sqrt(vt[idx_minus]) + eps)) W[idx_zero] = 0.0 elif (update_type == 'adagrad' or update_type == 'rmsprop'): idx_plus = W > D * (eta1 / (np.sqrt(cache) + eps)) idx_minus = W < -D * (eta1 / (np.sqrt(cache) + eps)) idx_zero = np.abs(W) < D * (eta1 / (np.sqrt(cache) + eps)) W[idx_plus] = W[idx_plus] - D * ( eta1 / (np.sqrt(cache[idx_plus]) + eps)) W[idx_minus] = W[idx_minus] + D * ( eta1 / (np.sqrt(cache[idx_minus]) + eps)) W[idx_zero] = 0.0 else: idx_plus = W > D * (eta) idx_minus = W < -D * (eta) idx_zero = np.abs(W) < D * (eta) W[idx_plus] = W[idx_plus] - D * (eta) W[idx_minus] = W[idx_minus] + D * (eta) W[idx_zero] = 0.0 if (reg_type == 'l2'): if (update_type == 'adam'): W += -D * W * (eta1 / (np.sqrt(vt) + eps)) elif (update_type == 'adagrad' or update_type == 'rmsprop'): W += -D * W * (eta1 / (np.sqrt(cache) + eps)) else: W += -D * W * (eta) if (reg_type == 'en'): if (update_type == 'adam'): W += -D * (1.0 - E) * W * (eta1 / (np.sqrt(vt) + eps)) elif (update_type == 'adagrad' or update_type == 'rmsprop'): W += -D * (1.0 - E) * W * (eta1 / (np.sqrt(cache) + eps)) else: W += -D * W * (eta) if (reg_type == 'l1' or reg_type == 'M'): if (update_type == 'adam'): u = u + D * (eta1 / (np.sqrt(vt) + eps)) elif (update_type == 'adagrad' or update_type == 'rmsprop'): u = u + D * (eta1 / (np.sqrt(cache) + eps)) else: u = u + D * eta z[:] = W[:] idx_plus = W > 0 idx_minus = W < 0 W_temp = np.zeros(W.shape) if (update_type == 'adam' or update_type == 'adagrad' or update_type == 'rmsprop'): W_temp[idx_plus] = np.maximum( all_zeros[idx_plus], W[idx_plus] - (u[idx_plus] + q[idx_plus])) W_temp[idx_minus] = np.minimum( all_zeros[idx_minus], W[idx_minus] + (u[idx_minus] - q[idx_minus])) else: W_temp[idx_plus] = np.maximum( all_zeros[idx_plus], W[idx_plus] - (u + q[idx_plus])) W_temp[idx_minus] = np.minimum( all_zeros[idx_minus], W[idx_minus] + (u - q[idx_minus])) W[idx_plus] = W_temp[idx_plus] W[idx_minus] = W_temp[idx_minus] q = q + (W - z) if (reg_type == 'en'): if (update_type == 'adam'): u = u + D * E * (eta1 / (np.sqrt(vt) + eps)) elif (update_type == 'adagrad' or update_type == 'rmsprop'): u = u + D * E * (eta1 / (np.sqrt(cache) + eps)) else: u = u + D * E * eta z[:] = W[:] idx_plus = W > 0 idx_minus = W < 0 W_temp = np.zeros(W.shape) if (update_type == 'adam' or update_type == 'adagrad' or update_type == 'rmsprop'): W_temp[idx_plus] = np.maximum( all_zeros[idx_plus], W[idx_plus] - (u[idx_plus] + q[idx_plus])) W_temp[idx_minus] = np.minimum( all_zeros[idx_minus], W[idx_minus] + (u[idx_minus] - q[idx_minus])) else: W_temp[idx_plus] = np.maximum( all_zeros[idx_plus], W[idx_plus] - (u + q[idx_plus])) W_temp[idx_minus] = np.minimum( all_zeros[idx_minus], W[idx_minus] + (u - q[idx_minus])) W[idx_plus] = W_temp[idx_plus] W[idx_minus] = W_temp[idx_minus] q = q + (W - z) if (np.sum(W**2) > W_clip_threshold): #gradient clipping W = W_clip_threshold * W / np.sum(W**2) if (iter1 % iter_eval == 0): #once the W are calculated for each epoch we calculate the scores scores = xTrain.dot(W) N = scores.shape[0] correct_scores = scores[range(N), np.array(yTrain, dtype='int32')] mat = (scores.transpose() - correct_scores.transpose()).transpose() mat = mat + 1.0 mat[range(N), np.array(yTrain, dtype='int32')] = 0.0 scores1 = np.zeros(scores.shape) scores1[:] = scores[:] scores1[range(N), np.array(yTrain, dtype='int32')] = -np.inf max_scores = np.max(scores1, axis=1) mat1 = 1 - correct_scores + max_scores f = 0.0 if (reg_type == 'l2'): f += D * 0.5 * np.sum(W**2) if (reg_type == 'l1'): f += D * np.sum(np.abs(W)) if (reg_type == 'en'): f += D * 0.5 * (1 - E) * np.sum(W**2) + D * E * np.sum( np.abs(W)) if (class_weighting == 'average'): f1 = C * 0.5 * np.sum(scores**2) + 0.5 * np.sum(mat1**2) f += (1.0 / N) * f1 else: f1 = C * 0.5 * np.sum( (scores**2) * sample_weights[:, None]) + 0.5 * np.sum( (mat1**2) * sample_weights[:, None]) f += (1.0 / numClasses) * f1 for i in range(numClasses): #first term in objective function for margin if (K_plus is not None): w = W[0:(M - 1), i] f2 = np.dot(np.dot(K_plus, w), w) f += ((0.5 * E) / (numClasses)) * f2 #the second term in the objective function for margin if (K_minus is not None): f3 = np.dot(temp_mat[:, i], w) f += -((0.5 * E) / (numClasses)) * f3 if (verbose == True): print('iter1=%d, f=%0.3f' % (iter1, f)) fvals[iter1] = f rel_error = np.abs(f_prev - f) / np.abs(f_prev) error_tol1 = 1e-02 maxW = np.max(np.abs(W[:-1, :]), axis=0) max_W = np.ones(W[:-1, ].shape) * maxW W[:-1, ][np.abs(W)[:-1, ] < error_tol1 * max_W] = 0.0 if (f < f_best): f_best = f W_best[:] = W[:] maxW = np.max(np.abs(W_best[:-1, :]), axis=0) max_W = np.ones(W_best[:-1, ].shape) * maxW W_best[:-1, ][np.abs(W_best)[:-1, ] < error_tol1 * max_W] = 0.0 iter_best = iter1 else: break f_prev = f eta = eta_zero / np.power((iter1 + 1), 1) max_W1 = np.max(np.abs(W_best[:-1, :]), axis=0) max_W1 = np.ones(W_best[:-1, ].shape) * max_W1 W1_best = np.zeros(W_best.shape) W2 = np.zeros(W_best.shape) W2[:] = W_best[:] train_acc_best = 0.0 for l1_ratio in [1e-02, 5e-02, 1e-01, 2e-01, 3e-01]: W2[:] = W_best[:] W2[:-1, ][np.abs(W2)[:-1, ] < l1_ratio * max_W1] = 0.0 scores = xTrain.dot(W2) pred = np.argmax(scores, axis=1) train_acc = np.sum(pred == yTrain) * 100 / yTrain.shape[0] # print('l1_ratio =%0.3f, train_acc=%0.3f'%(l1_ratio,train_acc)) if (train_acc >= train_acc_best): train_acc_best = train_acc - 0.5 W1_best[:] = W2[:] fvals[iter1] = -1 return W1_best, f_best, iter_best, fvals
def main(): utils.utils() print("hoi")
def fit(self, xTrain, yTrain): """ fits a classifier to the data Parameters: ----------- xTrain: np.array (2D array) (n_samples,n_features) data matrix yTrain: np.array (n_samples,) label array, labels are in range [0,numClasses-1] Returns: ------- W: np.array (n_features, numClasses) weight matrix me: np.array (n_features,) mean of train features std: np.array (n_features,) standard deviation of train features subset: list list of selected subset for kernel_type = linear, sin, tanh, TL1, rbf and empty list otherwise """ util = utils() gamma = self.gamma kernel_type = self.kernel_type n_components = self.n_components PV_scheme = self.PV_scheme do_pca = self.do_pca_in_selection levels = self.levels compress_type = self.compress_type non_linear_kernels = ['linear', 'rbf', 'sin', 'tanh', 'TL1'] if (kernel_type in non_linear_kernels): subset = util.subset_selection(xTrain, yTrain, n_components, PV_scheme, 'classification', do_pca) data1 = xTrain[subset, ] else: subset = [] data1 = None if (compress_type == 'zero_one'): xTrain = util.zero_one_normalization(xTrain) elif (compress_type == 'sigmoid'): xTrain = util.logsig(xTrain) elif (compress_type == 'saturate'): xTrain = util.saturate_fcn1(xTrain) else: raise ValueError('wrong compress_type selected!') xTrain = util.quantize(xTrain, levels) xTrain = util.onehot_minibatch(xTrain, levels) xTrain = util.tempcode_minibatch(xTrain, levels) if (data1 is not None): if (compress_type == 'zero_one'): data1 = util.zero_one_normalization(data1) elif (compress_type == 'sigmoid'): data1 = util.logsig(data1) elif (compress_type == 'saturate'): data1 = util.saturate_fcn1(data1) else: raise ValueError('wrong compress_type selected!') data1 = util.quantize(data1, levels) data1 = util.onehot_minibatch(data1, levels) data1 = util.tempcode_minibatch(data1, levels) xTrain1 = util.kernel_transform(X1=xTrain, X2=data1, kernel_type=kernel_type, n_components=n_components, gamma=gamma) #standardize the dataset if (kernel_type != 'linear_primal'): centering = True else: centering = False xTrain1, me, std = util.standardize(xTrain1, centering=centering) W, f, iters, fvals = self.inner_opt(xTrain1, yTrain, data1) return W, f, iters, fvals, subset, me, std