def train(self, num_classifiers): # Use this scores array to train a weak classifier using VJ_Classifier # in the for loop below. scores = np.zeros((len(self.integralImages), len(self.haarFeatures))) print " -- compute all scores --" for i, im in enumerate(self.integralImages): scores[i, :] = [hf.evaluate(im) for hf in self.haarFeatures] weights_pos = np.ones(len(self.posImages), dtype='float') * 1.0 / ( 2*len(self.posImages)) weights_neg = np.ones(len(self.negImages), dtype='float') * 1.0 / ( 2*len(self.negImages)) weights = np.hstack((weights_pos, weights_neg)) print " -- select classifiers --" excluded_feats = [] for i in range(num_classifiers): # print 'Current excluded feat ids' # print excluded_feats weights = np.array([wt/np.sum(weights) for wt in weights]) h = VJ_Classifier(scores, self.labels, weights=weights, excl_feat=excluded_feats) h.train() excluded_feats.append(h.feature) eps = h.error beta = eps/(1. - eps) alpha = np.log(1/beta) h_j = h.predict(scores.transpose()) errors = np.array([h_j[i] != self.labels[i] for i in range(0, len(h_j))]) # err = [int(x) for x in errors] self.classifiers.append(h) self.alphas.append(alpha) weights[errors] = weights[errors]*beta**(1 - (-1))
def train(self, num_classifiers): # Use this scores array to train a weak classifier using VJ_Classifier # in the for loop below. scores = np.zeros((len(self.integralImages), len(self.haarFeatures))) print " -- compute all scores --" for i, im in enumerate(self.integralImages): scores[i, :] = [hf.evaluate(im) for hf in self.haarFeatures] weights_pos = np.ones(len(self.posImages), dtype='float') * 1.0 / (2 * len(self.posImages)) weights_neg = np.ones(len(self.negImages), dtype='float') * 1.0 / (2 * len(self.negImages)) weights = np.hstack((weights_pos, weights_neg)) print " -- select classifiers --" for i in range(num_classifiers): weights_pos /= weights_pos.sum() weights_neg /= weights_neg.sum() hj = VJ_Classifier(scores, self.labels, weights) hj.train() self.classifiers.append(hj) beta = hj.error / (1 - hj.error) alpha = np.log(1 / beta) for i in range(0, len(weights)): ei = 1 if (hj.predict(scores[i]) == self.labels[i]): ei = -1 weights[i] = weights[i] * (beta**(1 - ei)) self.alphas.append(alpha)
def train(self, num_classifiers): # Use this scores array to train a weak classifier using VJ_Classifier # in the for loop below. scores = np.zeros((len(self.integralImages), len(self.haarFeatures))) print(" -- compute all scores --") for i, im in enumerate(self.integralImages): scores[i, :] = [hf.evaluate(im) for hf in self.haarFeatures] weights_pos = np.ones(len(self.posImages), dtype='float') * 1.0 / (2 * len(self.posImages)) weights_neg = np.ones(len(self.negImages), dtype='float') * 1.0 / (2 * len(self.negImages)) weights = np.hstack((weights_pos, weights_neg)) print(" -- select classifiers --") for i in range(num_classifiers): # Step 1: Normalize the weights weights_total = np.sum(weights) weights = weights / weights_total # Step 2: Training the VJ_Classifier vjc = VJ_Classifier(scores, self.labels, weights, thresh=0, feat=0, polarity=1) vjc.train() error = vjc.error # Step 3: Append coefficients to classifier self.classifiers.append(vjc) # Step 4: Update the weights beta = float(error) / (1. - error) for i in range(len(self.integralImages)): if self.labels[i] == vjc.predict(scores[i]): weights[i] = weights[i] * beta else: weights[i] = weights[i] # Step 5: Calculate alphas self.alphas.append(np.log(1. / beta))
def train(self, num_classifiers): # Use this scores array to train a weak classifier using VJ_Classifier # in the for loop below. scores = np.zeros((len(self.integralImages), len(self.haarFeatures))) print(" -- compute all scores --") for i, im in enumerate(self.integralImages): scores[i, :] = [hf.evaluate(im) for hf in self.haarFeatures] weights_pos = np.ones(len(self.posImages), dtype='float') * 1.0 / (2 * len(self.posImages)) weights_neg = np.ones(len(self.negImages), dtype='float') * 1.0 / (2 * len(self.negImages)) weights = np.hstack((weights_pos, weights_neg)) print(" -- select classifiers --") for i in range(num_classifiers): # TODO: Complete the Viola Jones algorithm sum_temp = np.sum(weights) weights = weights / sum_temp vjc = VJ_Classifier(scores, self.labels, weights, thresh=0, feat=0, polarity=1) vjc.train() error = vjc.error self.classifiers.append(vjc) beta = float(error) / (1. - error) for j in range(len(self.integralImages)): if self.labels[j] == vjc.predict(scores[j]): weights[j] = weights[j] * beta else: weights[j] = weights[j] weights = np.asarray(weights) self.alphas.append(math.log((1.) / beta))
def train(self, num_classifiers): # Use this scores array to train a weak classifier using VJ_Classifier # in the for loop below. scores = np.zeros((len(self.integralImages), len(self.haarFeatures))) print(" -- compute all scores --") for i, im in enumerate(self.integralImages): scores[i, :] = [hf.evaluate(im) for hf in self.haarFeatures] np.save("scores.npy", scores, allow_pickle=True) # scores = np.load("scores.npy") weights_pos = np.ones(len(self.posImages), dtype='float') * 1.0 / (2 * len(self.posImages)) weights_neg = np.ones(len(self.negImages), dtype='float') * 1.0 / (2 * len(self.negImages)) weights = np.hstack((weights_pos, weights_neg)) print(" -- select classifiers --") for i in range(num_classifiers): # normalize weights = weights / np.sum(weights) h_of_x = VJ_Classifier(scores, self.labels, weights) h_of_x.train() e_t = h_of_x.error B_t = e_t / (1 - e_t) a_t = np.log(1 / B_t) self.classifiers.append(h_of_x) self.alphas.append(a_t) # update weights predictions = [h_of_x.predict(x) for x in scores] incorrect_indices = np.where(self.labels != predictions) b_array = np.zeros_like(self.labels, dtype=np.float) b_array[incorrect_indices] = 1.0 b_array[b_array == 0] = B_t temp_weights = np.multiply(weights, b_array) weights = temp_weights print("Training: ", str(i))
def train(self, num_classifiers): # Use this scores array to train a weak classifier using VJ_Classifier # in the for loop below. scores = np.zeros((len(self.integralImages), len(self.haarFeatures))) print " -- compute all scores --" for i, im in enumerate(self.integralImages): scores[i, :] = [hf.evaluate(im) for hf in self.haarFeatures] weights_pos = np.ones(len(self.posImages), dtype='float') * 1.0 / ( 2*len(self.posImages)) weights_neg = np.ones(len(self.negImages), dtype='float') * 1.0 / ( 2*len(self.negImages)) weights = np.hstack((weights_pos, weights_neg)) print " -- select classifiers --" for i in range(num_classifiers): # normalize weights. weights = weights / np.sum(weights) # instantiate each classifier classifier = VJ_Classifier(scores, self.labels, weights) classifier.train() error = classifier.error # append self.classifiers.append(classifier) # update weights. B = error / (1.0 - error) a = np.log(1.0 / B) # get predictions preds = classifier.predict(np.transpose(scores)) # e = -1 if same, 1 if not. e = [-1 if preds[i] == self.labels[i] else 1 for i in range(len(preds))] for wti in range(len(weights)): weights[wti] = weights[wti] * np.power(B, 1-e[wti]) # append the alpha. self.alphas.append(a)
def train(self, num_classifiers): # Use this scores array to train a weak classifier using VJ_Classifier # in the for loop below. scores = np.zeros((len(self.integralImages), len(self.haarFeatures))) print(" -- compute all scores --") for i, im in enumerate(self.integralImages): scores[i, :] = [hf.evaluate(im) for hf in self.haarFeatures] weights_pos = np.ones(len(self.posImages), dtype='float') * 1.0 / (2 * len(self.posImages)) weights_neg = np.ones(len(self.negImages), dtype='float') * 1.0 / (2 * len(self.negImages)) weights = np.hstack((weights_pos, weights_neg)) print(" -- select classifiers --") for i in range(num_classifiers): # TODO: Complete the Viola Jones algorithm weights = weights / sum(weights) scores = [ hf.evaluate(ii) for ii in self.integralImages for hf in self.haarFeatures ] n_feats = len(self.haarFeatures) n_iis = len(self.integralImages) X_ = np.reshape(scores, (n_iis, n_feats)) y_ = self.labels vj = VJ_Classifier(X_, y_, weights) vj.train() preds = vj.predict(X_.T) eps = 1 * (preds != self.labels) beta = vj.error / (1 - vj.error) print(vj.error) weights = weights * (beta**(1 - eps)) alpha = np.log(1 / beta) self.classifiers.append(vj) self.alphas.append(alpha)
def train(self, num_classifiers): # Use this scores array to train a weak classifier using VJ_Classifier # in the for loop below. scores = np.zeros((len(self.integralImages), len(self.haarFeatures))) print " -- compute all scores --" for i, im in enumerate(self.integralImages): scores[i, :] = [hf.evaluate(im) for hf in self.haarFeatures] weights_pos = np.ones(len(self.posImages), dtype='float') * 1.0 / (2 * len(self.posImages)) weights_neg = np.ones(len(self.negImages), dtype='float') * 1.0 / (2 * len(self.negImages)) weights = np.hstack((weights_pos, weights_neg)) print " -- select classifiers --" for i in range(num_classifiers): weights = weights / np.sum(weights) VJ = VJ_Classifier(scores, self.labels, weights) VJ.train() self.classifiers.append(VJ) B = VJ.error / (1.0 - VJ.error) alpha = np.log(1.0 / B) et = [ 0 if VJ.predict(st) == lt else 1 for i, (st, lt) in enumerate(zip(scores, self.labels)) ] weights = [w * np.power(B, 1 - e) for (w, e) in zip(weights, et)] self.alphas.append(alpha) print " -- select classifiers done --"
def train(self, num_classifiers): # Use this scores array to train a weak classifier using VJ_Classifier # in the for loop below. scores = np.zeros((len(self.integralImages), len(self.haarFeatures))) print " -- compute all scores --" for i, im in enumerate(self.integralImages): scores[i, :] = [hf.evaluate(im) for hf in self.haarFeatures] weights_pos = np.ones(len(self.posImages), dtype='float') * 1.0 / ( 2*len(self.posImages)) weights_neg = np.ones(len(self.negImages), dtype='float') * 1.0 / ( 2*len(self.negImages)) weights = np.hstack((weights_pos, weights_neg)) print " -- select classifiers --" for i in range(num_classifiers): # TODO: Complete the Viola Jones algorithm # 1. Normalize the weights weights = weights / np.sum(weights) # 2. Instantiate a and train a classifier h_j h_j = VJ_Classifier(scores, self.labels, weights) h_j.train() # 3. Append h_j to the self.classifiers attribute self.classifiers.append(h_j) # 4. Update the weights h_x = np.array([h_j.predict(scores[x, :]) for x in range(scores.shape[0])], np.float32) eps_j = h_j.error beta_j = eps_j / (1 - eps_j) e_i = np.float32(np.not_equal(h_x, self.labels)) * 2.0 - 1.0 weights = np.multiply(weights, np.power(beta_j, 1.0 - e_i)) # 5. Calculate alpha_j alpha_j = - np.log(beta_j) # Append it to the self.alphas self.alphas.append(alpha_j)