def test_adaboost(self): train_X,train_y,test_X,test_y = loadHorseColic() adaboost = AdaBoostClassifier() adaboost.fit(train_X,train_y) preds = adaboost.predict(test_X) print(accuracy_score(preds,test_y)) assert accuracy_score(preds,test_y)>0.7
def train(X_train, y_train): clf = AdaBoostClassifier(DecisionTreeClassifier(max_depth=1), n_weakers_limit=20) print("Training a AdaBoost Classifier.") clf.fit(X_train, y_train) # If model directories don't exist, create them if not os.path.isdir(os.path.split(adb_model_path)[0]): os.makedirs(os.path.split(adb_model_path)[0]) clf.save(clf, adb_model_path)
def process_boost(): x_train, y_train, x_valid, y_valid = load_and_split() n_weakers_limit = 20 adaBoost = AdaBoostClassifier(DecisionTreeClassifier, n_weakers_limit) adaBoost.fit(x_train, y_train) # 测试集预测 predict_list = adaBoost.predict(x_valid) target_names = ['face', 'non_face'] report = classification_report(y_valid, predict_list, target_names=target_names) with open("D:/testing/python/classifier_report.txt", "w") as f: f.write(report)
def test_breast_cancer(): clf = AdaBoostClassifier(n_weakers_limit=50) X, y = load_breast_cancer(True) X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.33, random_state=42) clf.fit(X_train, y_train) y_pred = clf.predict(X_test) print(classification_report(y_test, y_pred)) skclf = SkAdaBoostClassifier() skclf.fit(X_train, y_train) print(classification_report(y_test, skclf.predict(X_test)))
def train(train_X, train_y): weak_classifier = DecisionTreeClassifier(max_depth=3) ada = AdaBoostClassifier(weak_classifier, 5) ada.fit(train_X, train_y) result = ada.predict(train_X) diff = np.abs(result - train_y) diff[diff > ep] = 1 t = np.sum(diff) print("错误预测的个数为: ", t) target_names = ['人脸', '非人脸'] report = (classification_report(train_y, result, target_names=target_names)) re_path = "/home/sun/ComputerScience/MachineLearning/Experiments/Experiment_three/ML2017-lab-03/report.txt" write_report(re_path, report) return ada
def fit(self, X, y): # clear the adaboost container self.adaboosts.clear() # data preprocess y_face_nonface = Hierarchy_Adaboost.seperate_face_nonface(y) X_male_female, y_male_female = Hierarchy_Adaboost.extract_male_female( X, y) X_animal_object, y_animal_object = Hierarchy_Adaboost.extract_animal_object( X, y) # initialize a decision tree classifier dt = DecisionTreeClassifier(max_depth=4) # train an adaboost for each different situation # adaboost for classifying face images and nonface images print("train adaboost_face_nonface") adaboost_face_nonface = AdaBoostClassifier(dt, self.maximum_weakers) adaboost_face_nonface.fit(X, y_face_nonface) self.adaboosts.append(adaboost_face_nonface) # adaboost for classifying male images and female images print("train adaboost_male_female") adaboost_male_female = AdaBoostClassifier(dt, self.maximum_weakers) adaboost_male_female.fit(X_male_female, y_male_female) self.adaboosts.append(adaboost_male_female) # adaboost for classifying animal images and object images print("train adaboost_animal_object") adaboost_animal_object = AdaBoostClassifier(dt, self.maximum_weakers) adaboost_animal_object.fit(X_animal_object, y_animal_object) self.adaboosts.append(adaboost_animal_object)
def test_image(): path = 'datasets/original/' face = io.imread_collection(path + 'face/*.jpg') nonface = io.imread_collection(path + 'nonface/*.jpg') labels = ['face', 'nonface'] X = [] y = [] # face_list = [get_features(i) for i in face] # nonface_list = [get_features(i) for i in nonface] # face_list = Parallel(n_jobs=4)(delayed(get_features)(i) for i in face) # nonface_list = Parallel(n_jobs=4)( # delayed(get_features)(i) for i in nonface) # X += face_list # y += list(np.zeros(len(face_list), dtype=int)) # X += nonface_list # y += list(np.ones(len(nonface_list), dtype=int)) # AdaBoostClassifier.save(X, 'X.pkl') # AdaBoostClassifier.save(y, 'y.pkl') X = AdaBoostClassifier.load('X.pkl') y = AdaBoostClassifier.load('y.pkl') X_train, X_test, y_train, y_test = train_test_split( np.array(X), np.array(y), test_size=0.33, random_state=42) print('start training') clf = AdaBoostClassifier(n_weakers_limit=50) clf.fit(X_train, y_train) y_pred = clf.predict(X_test) with open('report.txt', 'w') as f: print(classification_report(y_test, y_pred, target_names=labels), file=f)
def test_xor(): X_train = np.array([ [1, 1], [1, 0], [0, 1], [0, 0] ]) y_train = np.array([ 0, 1, 1, 0 ]) clf = AdaBoostClassifier(n_weakers_limit=1000) clf.fit(X_train, y_train) y_pred = clf.predict(X_train) print(classification_report(y_train, y_pred)) skclf = SkAdaBoostClassifier() skclf.fit(X_train, y_train) print(classification_report(y_train, skclf.predict(X_train)))
str(i).rjust(3, '0') + ".jpg") img = cv2.resize(img, dsize=(24, 24)) img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) # 转换了灰度化 npd = NPDFeature(img) x.append(npd.extract()) y.append(1) for i in tqdm(range(500)): img = cv2.imread("./datasets/original/nonface/nonface_" + str(i).rjust(3, '0') + ".jpg") img = cv2.resize(img, dsize=(24, 24)) img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) # 转换了灰度化 npd = NPDFeature(img) x.append(npd.extract()) y.append(-1) x_train, x_val, y_train, y_val = train_test_split(x, y, test_size=0.2) print('begin train data') ada = AdaBoostClassifier() ada.fit(x_train, y_train) y_predict = ada.predict(x_val, threshold=0) print( classification_report(y_val, y_predict, target_names=["nonface", "face"], digits=4)) with open("report.txt", "w") as f: f.write( classification_report(y_val, y_predict, target_names=["nonface", "face"], digits=4))
def split_dataset(dataset, train_ratio=0.8): """ :return: X_train, y_train, X_valid, y_valid """ pivot = int(2 * SAMPLES_N * train_ratio) train_set = dataset[0][:pivot], dataset[1][:pivot] valid_set = dataset[0][pivot:], dataset[1][pivot:] return train_set + valid_set if __name__ == "__main__": X_train, y_train, X_valid, y_valid = split_dataset(load_dataset()) adaBoost = AdaBoostClassifier(DecisionTreeClassifier, WEAKERS_LIMIT) accs = adaBoost.fit(X_train, y_train, X_valid, y_valid) plt.figure(figsize=[8, 5]) plt.title('Accuracy') plt.xlabel('Num of weak classifiers') plt.ylabel('Accuracy') plt.plot(accs[0], '--', c='b', linewidth=3, label='train') plt.plot(accs[1], c='r', linewidth=3, label='valid') plt.legend() plt.grid() plt.savefig('AdaBoost-accuracy.png') plt.show() AdaBoostClassifier.save(adaBoost, 'AdaBoost-Model.pkl')
X.append(NPDFeature(np.array(img)).extract()) y.append(-1) print(i) X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=42) ada = AdaBoostClassifier(DecisionTreeClassifier, 20) X_train = np.array(X_train) X_test = np.array(X_test) y_train = np.array(y_train) y_test = np.array(y_test) y_train = y_train.reshape((y_train.shape[0], 1)) y_test = y_test.reshape((y_test.shape[0], 1)) ada.fit(X_train, y_train) h = ada.predict(X_test) yes = 0 no = 0 for i in range(0, len(h)): if (h[i] == y_test[i]): yes += 1 if (h[i] != y_test[i]): no += 1 print(yes, " ", no) report = classification_report(y_test, h, target_names=["nonface", "face"]) file = open('report.txt', 'w') file.write(report) file.close()
Data = AdaBoostClassifier.load('feature.data') else : Data = pre_process() #将X_data与y_data分开 X_data,y_data = Data[:,:-1],Data[:,-1] #切分训练集与验证集 X_train,X_test,y_train,y_test = train_test_split(X_data,y_data,test_size=0.3,random_state=10) print(len(y_train),len(y_test)) #进行AdaBoost训练 mode = tree.DecisionTreeClassifier(max_depth=1) adaboost=AdaBoostClassifier(mode,20) adaboost.fit(X_train,y_train) #得到预测结果 y_predict=adaboost.predict(X_test) #输出正确率 count=0 for i in range(len(y_test)): if y_test[i]==y_predict[i]: count=count+1 target_names = ['1', '-1'] print(count/len(y_test)) #调用classification_report获得预测结果 report=classification_report(y_test, y_predict, target_names=target_names)
face_im=face_im.convert('L')#灰度化 face_im=face_im.resize((24,24)) #缩小尺寸 nonface_im=nonface_im.convert('L') nonface_im=nonface_im.resize((24,24)) face.append(np.array(face_im))#转为ndarray nonface.append(np.array(nonface_im)) feature_face=[] feature_nonface=[] for i in range(500) : feature_face.append(NPDFeature(face[i]).extract()) feature_nonface.append(NPDFeature(nonface[i]).extract()) # #缓存特征 # AdaBoostClassifier.save(feature_face,'feature_face') # AdaBoostClassifier.save(feature_nonface,'feature_nonface') # #读取缓存的特征 # feature_face=np.array(AdaBoostClassifier.load('feature_face')) # feature_nonface=np.array(AdaBoostClassifier.load('feature_nonface')) data=np.row_stack((feature_face,feature_nonface)) label=np.concatenate((np.ones(500),-np.ones(500))) X_train,X_validation,y_train,y_validation=train_test_split(data,label,test_size=0.3,random_state=1000) #Adaboost 20个分类器,每个决策树只有一个节点 model=AdaBoostClassifier(DecisionTreeClassifier,20) model.fit(X_train,y_train)#训练模型 y_pre=model.predict(X_validation)#预测 with open('report.txt',mode='w') as f: f.write(classification_report(y_pre,y_validation)) #单个分类器 model=DecisionTreeClassifier(max_depth=1).fit(X_train,y_train) y_pre=model.predict(X_validation) print(classification_report(y_pre,y_validation))
if os.path.exists("./feature.txt") is False: get_data() X_trainsize = 800 # 训练集大小 (<1000) max_depth = 3 num_of_weakers = 20 Accuracytrainlist = [] Accuracytestlist = [] dataset = load_data(X_trainsize=X_trainsize) X_train, y_train, X_test, y_test = dataset[0], dataset[1], dataset[ 2], dataset[3] clf = DecisionTreeClassifier(max_depth=max_depth, min_samples_leaf=1) adaboost = AdaBoostClassifier(clf, n_weakers_limit=num_of_weakers) Accuracytrainlist, Accuracytestlist = adaboost.fit(X_train, y_train, X_test, y_test) print(Accuracy(adaboost.predict(X_test), y_test)) print( classification_report(y_train, adaboost.predict(X_train), target_names=['non-face', 'face'])) #training_result print( classification_report(y_test, adaboost.predict(X_test), target_names=['non-face', 'face'])) #test_result plt.plot(Accuracytrainlist, 'black', label='Adaboost_train') plt.plot(Accuracytestlist, 'blue', label='Adaboost_test') plt.title('training Accuracy and test Accuracy') #plt.yscale('log')
np.random.shuffle(features_dataset) np.save("./datasets/extract_features", features_dataset) if __name__ == "__main__": get_original_features("face") get_original_features("nonface") face_features = np.load("./datasets/face_features.npy") nonface_features = np.load("./datasets/nonface_features.npy") get_features_dataset(face_features, nonface_features) features_dataset = np.load("./datasets/extract_features.npy") print(features_dataset.shape, face_features.shape, nonface_features.shape) num_face_feature = features_dataset.shape[1] - 1 training_size = 800 X_train = features_dataset[:training_size, :num_face_feature] X_validation = features_dataset[training_size:, :num_face_feature] y_train = features_dataset[:training_size, -1] y_validation = features_dataset[training_size:, -1] # print(X_train.shape,y_train.shape,X_validation.shape,y_validation.shape) adaboost_classifier = AdaBoostClassifier( DecisionTreeClassifier(max_depth=4), 5) pred_y = adaboost_classifier.fit(X_train, y_train).predict(X_validation) with open("report.txt", "wb") as f: report = classification_report(y_validation, pred_y, target_names=["nonface", "face"]) f.write(report.encode())
test_size=0.2, random_state=24) output = open(datafile, 'wb') pickle.dump(X_train, output) pickle.dump(X_vali, output) pickle.dump(y_train, output) pickle.dump(y_vali, output) output.close() #create adaboost/weak classifier dtc = DecisionTreeClassifier(random_state=0, max_depth=3, max_features="sqrt") classifier = AdaBoostClassifier(dtc, 15) #train classifiers classifier.fit(X_train, y_train) dtc.fit(X_train, y_train) #do prediction result = classifier.predict(X_vali) weakresult = dtc.predict(X_vali) #calculate predicting accuracy for both adacount = 0 weakcount = 0 for i in range(0, result.shape[0]): if (np.abs(result[i] - 1) < np.abs(result[i] + 1)): result[i] = 1 else: result[i] = -1 if result[i] == y_vali[i]: adacount = adacount + 1
from sklearn.model_selection import train_test_split from sklearn.tree import DecisionTreeClassifier from ensemble import AdaBoostClassifier #这里是直接读取灰度图,灰度图在original文件夹里面 path1=[os.path.join('G:\\Users\\qqqqqq1997520\\Desktop\\original\\face\\face',f) for f in os.listdir('G:\\Users\\qqqqqq1997520\\Desktop\\original\\face\\face')] path2 = [os.path.join('G:\\Users\\qqqqqq1997520\\Desktop\\original\\face\\nonface',f) for f in os.listdir('G:\\Users\\qqqqqq1997520\\Desktop\\original\\face\\nonface')] ABC=AdaBoostClassifier(DecisionTreeClassifier(), 1) im=[0 for i in range(1000)] for i in range(500): im[i]=plt.imread(path1[i]) for i in arange(500,1000): im[i]=plt.imread(path2[(i%500)]) _feature=[0 for i in range(1000)] for i in range(1000): feature=NPDFeature(im[i]) _feature[i]=feature.extract() feature_data=array(_feature) y=[1 for i in range(1000)] for i in range(500,1000): y[i]=-1; y=array(y) X_train, X_vali, y_train, y_vali = train_test_split(feature_data, y, test_size=0.3, random_state=37) ABC=AdaBoostClassifier(DecisionTreeClassifier(),20) ABC.fit(X_train,y_train) predict=ABC.predict(X_vali,0) classification_name=["Y","N"] with open('report.txt', 'w') as f: f.write(classification_report(y_vali, predict, target_names=classification_name))
y_test = y_test.reshape(75, 1) return y_train, y_test def acc(y_test, y_preds): for n, y in enumerate(y_preds): if y > 0: y_preds[n] = 1 if y <= 0: y_preds[n] = -1 num = 0 for z in zip(y_preds, y_test): if int(z[0]) == int(z[1][0]): num = num + 1 print('arr:', num / len(y_test)) if __name__ == "__main__": X = trainX() X_test = testX() y_train, y_test = dataY() clf = tree.DecisionTreeClassifier(max_depth=50, min_samples_leaf=50, random_state=30, criterion='gini') gbdt = AdaBoostClassifier(clf, 10) gbdt.fit(X, y_train) y_preds = gbdt.predict(X_test) # y_preds acc(y_test, y_preds)
else: path_face = './datasets/original/face/' path_non_face = './datasets/original/nonface/' for i in os.listdir(path_face): features = processImage(Image.open(path_face + i)) X.append(features) y.append(1) for i in os.listdir(path_non_face): features = processImage(Image.open(path_non_face + i)) X.append(features) y.append(0) with open("data_x", "wb") as f: pickle.dump(X, f) with open("data_y", "wb") as f: pickle.dump(y, f) return X, y if __name__ == "__main__": X, y = getData() X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, shuffle=True) clf = AdaBoostClassifier(DecisionTreeClassifier, 10) clf.fit(X_train, y_train) predict = clf.predict(X_val) print(classification_report(y_val, predict))
features_face_array = np.array(features_face)[0:n_limit] n_pos_sample = features_face_array.shape[0] n_feature = features_face_array.shape[1] features_nonface = load('features_nonface') features_nonface_array = np.array(features_nonface)[0:n_limit] n_neg_sample = features_nonface_array.shape[0] X = np.concatenate((features_face_array, features_nonface_array), axis=0) y = np.array([1] * n_pos_sample + [-1] * n_neg_sample) X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2) # model = dt() # model.fit(X_train,y_train) # s = model.score(X_test,y_test) # print(s) Ada = AdaBoostClassifier(dt, 10) Ada.fit(X_train, y_train) pred = Ada.predict(X_test) acc = accuracy_score(pred, y_test) print('acc:', acc) f = open('report.txt', 'w') content = classification_report(pred, y_test) f.write(content) f.close()
trainLabel.extend(nonfaceLabel) trainLabel.extend(faceLabel) X_train, X_test, Y_train, Y_test = train_test_split(trainImage, trainLabel, test_size = 0.33) return np.array(X_train), np.array(X_test), np.array(Y_train), np.array(Y_test) if __name__ == "__main__": # write your code here #dataProcess() trainData, testData, trainLabel, testLabel = divideData('./dataFeature/face', './dataFeature/nonface') clf = DecisionTreeClassifier(max_depth=2) row, col = trainData.shape weightArray = [(1 / row)] * row clf.fit(trainData, trainLabel, weightArray) predictY = clf.predict(testData) rate = calculateAcc(predictY, testLabel) print(rate) target_name = ['class-1', 'class1'] with open("./report.txt", 'w') as fp: fp.write(classification_report(testLabel, predictY, target_names=target_name)) print(classification_report(testLabel, predictY, target_names=target_name)) clf2 = AdaBoostClassifier(DecisionTreeClassifier, 20) clf2.fit(trainData, trainLabel) predictY2 = clf2.predict(testData) rate = calculateAcc(predictY2, testLabel) print(rate) target_name = ['class-1', 'class1'] with open("./report1.txt", 'w') as fp: fp.write(classification_report(testLabel, predictY2, target_names=target_name)) print(classification_report(testLabel, predictY2, target_names=target_name))
file1_size = len(file1) file2 = load('nonface.txt').tolist() file2_size = len(file2) X = file1 + file2 #构造结果值Y y_face = np.ones(file1_size).tolist() y_nonface = (-1 * np.ones(file2_size)).tolist() y = y_face + y_nonface #划分训练集和验证集 x_train, x_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=1) classifier = tree.DecisionTreeClassifier adaBoostClassifier = AdaBoostClassifier(classifier, 20) adaBoostClassifier.fit(x_train, y_train) y_true = y_test y_pred = adaBoostClassifier.predict(x_test, y_test) target_names = ['nonface', 'face'] print(classification_report(y_true, y_pred, target_names=target_names)) ''' weight = np.ones(len(x_train)).tolist() #test = em.AdaBoostClassifier(classifier, 2) classifier.fit(x_train,y_train,sample_weight =weight ) s = classifier.score(x_test,y_test) print(s) '''
dataset = np.array(samples) with open('tmp.pkl', 'wb') as output: pickle.dump(dataset, output, True) with open('tmp.pkl', 'rb') as input: dataset = pickle.load(input) print(dataset.shape) # 将数据集切分为训练集和验证集 X_train = dataset[:dataset.shape[0] * 3 // 4, :dataset.shape[1] - 1] y_train = dataset[:dataset.shape[0] * 3 // 4, dataset.shape[1] - 1] X_validation = dataset[dataset.shape[0] * 3 // 4:, :dataset.shape[1] - 1] y_validation = dataset[dataset.shape[0] * 3 // 4:, dataset.shape[1] - 1] return X_train, X_validation, y_train, y_validation if __name__ == "__main__": X_train, X_validation, y_train, y_validation = loadDataSet() abc = AdaBoostClassifier(DecisionTreeClassifier, 20) abc.fit(X_train, y_train) final_pre_y = abc.predict(X_validation) error = 0 for i in range(final_pre_y.shape[0]): if final_pre_y[i] != y_validation[i]: error = error + 1 accuracy = 1 - error / y_validation.shape[0] print('accuracy: %f' % accuracy) target_names = ['face', 'nonface'] report = classification_report(y_validation, final_pre_y, target_names=target_names) print(report) with open('report.txt', 'w') as f: f.write(report)
img = Image.open(nonfaces_path[i]) img = img.convert('L').resize((24, 24)) nf = NPDFeature(np.array(img)) train[i * 2 + 1] = nf.extract() AdaBoostClassifier.save(train, 'train.txt') try: X = AdaBoostClassifier.load("train.txt") except IOError: Feature_extract() X = AdaBoostClassifier.load("train.txt") Y = np.zeros((1000, 1)) for i in range(1000): Y[i] = (i + 1) % 2 Y = np.where(Y > 0, 1, -1) X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2) booster = AdaBoostClassifier(DecisionTreeClassifier, 15) booster.fit(X_train, Y_train) predict = booster.predict(X_test) wrong_count = 0 for j in range(predict.shape[0]): if predict[j] != Y_test[j]: wrong_count += 1 AdaBoostClassifier.save(classification_report(Y_test, predict), "classifier_report.txt") pass
def preprocess(): x, y = to_gray_resize('datasets/original/face/') x, y = to_gray_resize('datasets/original/nonface/', x, y) #write binary with open('datasets/features/feature', 'wb') as file: pickle.dump(x, file) with open('datasets/features/label', 'wb') as file: pickle.dump(y, file) print(x.shape, y.shape) if __name__ == "__main__": print('loading data...') # preprocess() with open('datasets/features/feature', 'rb') as file: x = pickle.load(file) with open('datasets/features/label', 'rb') as file: y = pickle.load(file) X_train, X_test, y_train, y_test = train_test_split(x, y, test_size=0.25, random_state=42) print(X_train.shape, X_test.shape, y_train.shape, y_test.shape) print('start training...') ada_clf = AdaBoostClassifier(DecisionTreeClassifier(max_depth=3), 10) ada_clf.fit(X_train, y_train, X_test, y_test) ada_clf.plotting()
label.append(-1) if __name__ == "__main__": # write your code here readimg() train_feature,validation_feature,train_label,validation_label=train_test_split(feature,label,test_size=0.3) #adaboost adaboostClassifier=AdaBoostClassifier(DecisionTreeClassifier(max_depth = 1, random_state = 1),20) adaboostClassifier.save(train_feature,'train_feature') adaboostClassifier.save(train_label,'train_label') adaboostClassifier.save(validation_feature,'validation_feature') adaboostClassifier.save(validation_label,'validation_label') adaboostClassifier.fit(train_feature,train_label) adaboostClassifier.drawPic() ''' #debug adaboostClassifier=AdaBoostClassifier(DecisionTreeClassifier(max_depth = 1, random_state = 1),20) train_feature=adaboostClassifier.load("train_feature") train_label=adaboostClassifier.load("train_label") adaboostClassifier.fit(train_feature,train_label) adaboostClassifier.drawPic() '''
shuffle=True) print('X_train.shape', X_train.shape) print('X_val.shape', X_val.shape) print('y_train.shape', y_train.shape) print('y_val.shape', y_val.shape) # 尝试使用不同深度的决策树,不同数量的决策树来进行建模和预测 result = [] max_depth = 4 max_num_tree = 10 for depth in range(1, max_depth + 1): result_item = [] for num_tree in range(1, max_num_tree + 1): adaboostclassifier = AdaBoostClassifier( DecisionTreeClassifier(max_depth=depth), num_tree) adaboostclassifier.fit(X_train, y_train) pre_label = adaboostclassifier.predict(X_val) correct = [1 if a == b else 0 for (a, b) in zip(pre_label, y_val)] accurary = sum(correct) / len(correct) result_item.append(accurary * 100) report = classification_report(y_val, pre_label, labels=[-1, 1], target_names=["face", "nonface"]) model_num = (depth - 1) * 10 + num_tree with open('report.txt', 'a') as f: f.write('\nmodel ' + str(model_num) + ':\n') f.write('number of decision tree:' + str(num_tree) + '\n') f.write('max_depth of decision tree:' + str(depth) + '\n') f.write(report)
# train_y.append(-1) clf = AdaBoostClassifier(tree.DecisionTreeClassifier, 10) #cal NPD for i in range(num_face + num_nonface): NPD.append(NPDFeature(imgs[i]).extract()) #save NPD # clf.save(NPD,'output') #load NPD # NPD=np.array(clf.load('output')) train_x = np.row_stack((NPD[0:100], NPD[500:600])) train_y = np.append(np.ones((1, 100)), np.linspace(-1, -1, 100)) test_x = np.row_stack((NPD[200:300], NPD[700:800])) test_y = np.append(np.ones((1, 100)), np.linspace(-1, -1, 100)) clf.fit(train_x, train_y) y = clf.predict(test_x) hit = 0 for i in range(test_x.shape[0]): if (y[i] == test_y[i]): hit += 1 print("hit rate:", hit / test_x.shape[0]) with open('report.txt', 'w') as f: f.write(classification_report(test_y, y))
# 数据集加标签,并划分训练集,验证集 Data = loadData("data") label = np.ones(1000) label[500:] = -1 train_x, train_y, validation_x, validation_y = split(Data, label, 0.4) saveData("train", train_x) saveData("label", train_y) saveData("validation", validation_x) saveData("target", validation_y) train = loadData("train") train_x = np.array(train) label = loadData("label") train_y = np.array(label) validation = loadData("validation") test_x = np.array(validation) target = loadData("target") test_y = np.array(target) weakClassifier = DecisionTreeClassifier(max_depth=3) cls = AdaBoostClassifier(weakClassifier, num_classifier) cls = cls.fit(train_x, train_y) result_adaboost = cls.predict(test_x, 0) print('adaboost result: ', result_adaboost) print('accuracy: ', validate_result(result_adaboost, test_y)) target_names = {'nonface', 'face'} output = open('report.txt', 'w') output.write( classification_report(test_y, result_adaboost, target_names=target_names))
plt.xlabel('Iteration') plt.ylabel('Accuracy') plt.plot(range(len(validation_score_list)), validation_score_list) #plt.grid() plt.show() if __name__ == "__main__": # pre_image() with open('features', "rb") as f: x = pickle.load(f) with open('labels', "rb") as f: y = pickle.load(f) X_train, X_test, y_train, y_test = train_test_split(x, y, test_size=0.33, random_state=0) maxIteration = 10 s = AdaBoostClassifier(DecisionTreeClassifier(max_depth=3), maxIteration) s.fit(X_train, y_train) predict_y = s.predict(X_test) # acc_plot(validation_score_list) with open('report.txt', "wb") as f: report = classification_report(y_test, predict_y, target_names=["face", "nonface"]) f.write(report.encode())