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_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 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 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 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 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)))
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)
if min == max: return 1 length = max - min num_repeat = (weight - min) * (range_right - 1) / length + 1 return num_repeat trainset = torchvision.datasets.MNIST('./data', train=True, download=True, transform=transforms.ToTensor()) trainloader = torch.utils.data.DataLoader(dataset=trainset, shuffle=False) CLASSIFIER_NUM = 9 classifier = AdaBoostClassifier(mlpClassifier) classifier.train(trainloader, classifier_num=CLASSIFIER_NUM) test_dataset = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transforms.ToTensor()) test_dataloader = torch.utils.data.DataLoader(test_dataset, shuffle=False) # Test the AdaBoostClassifier correct = 0 for batch_index, (data, target) in enumerate(test_dataloader): # Copy data to GPU if needed data = data.to(device) target = target.to(device)
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')
num_repeat = (weight - min) * (range_right - range_left) / length + range_left return num_repeat transform_train = transforms.Compose([ transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform_train) train_dataloader = torch.utils.data.DataLoader(trainset, batch_size=BATCH_SIZE, shuffle=False) validation_dataloader = torch.utils.data.DataLoader(trainset, batch_size=1, shuffle=False) # Define and train the AdaBoostClassifier classifier = AdaBoostClassifier(BResNetVClassifier, BASE_CLASSIFIER_NAME) classifier.train(train_dataloader, validation_dataloader, classifier_num=NUM_CLASSIFIER) transform_test = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) test_dataset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform_test) test_dataloader = torch.utils.data.DataLoader(test_dataset, batch_size=1, shuffle=False) # Test the base classifier print('Testing all the base classifiers...') for i in range(NUM_CLASSIFIER): correct = 0 for batch_index, (data, target) in enumerate(test_dataloader): # Copy data to GPU if needed
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))
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)
test_size=0.4, random_state=2019, 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')
import numpy as np import pickle from numpy import * import matplotlib.image as mpimg from skimage import io import os from feature import * from PIL import Image from sklearn.metrics import classification_report 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)
image = np.array(image) feature = NPDFeature(image).extract() if 'nonface' in image_path: y[i] = -1 else: y[i] = 1 X[i, :] = feature np.savez(features_save_path, X, y) # load features npzfile = np.load(features_save_path) X = npzfile['arr_0'] y = npzfile['arr_1'] # Split the dataset into training set and validation set X_train, X_validation, y_train, y_validation = train_test_split( X, y, test_size=0.44, random_state=42, shuffle=True) adaboost_classifier = AdaBoostClassifier(max_number_classifier=1) # Train the model adaboost_classifier.fit(X_train, y_train) y_predict = adaboost_classifier.predict(X_validation) target_names = ['non_face', 'face'] accuracy = np.mean(y_predict == y_validation) print(accuracy) results = classification_report(y_validation, y_predict, target_names=target_names) with open(results_path, 'w+') as f: f.write(results) print(results)
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)
#初始化 num_weak_classifier = 5 num_list = [] pred_score_list = [] max_score = 0 report = '' #弱分类器数目从5到50进行实验 while (num_weak_classifier <= 50): print('弱分类器数量:', num_weak_classifier) num_list.append(num_weak_classifier) #定义弱分类器 b = DecisionTreeClassifier(splitter='random', max_depth=4) #定义adaboost分类器 a = AdaBoostClassifier(b, num_weak_classifier) #使用训练集进行训练 a.fit(X_train, y_train) #对测试集进行分类 y_pred = a.predict(X_val) #计算准确率 correct = 0 for i in range(y_pred.shape[0]): if (y_pred[i] == y_val[i]): correct += 1 score = correct / y_val.shape[0] print('准确率:', score) pred_score_list.append(score) #生成准确率最高时的报告 if (score > max_score):
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
print(index, path) image = image.convert('L') image = image.resize((24, 24)) imageData = np.array(image) npd = feature.NPDFeature(imageData) features.append(npd.extract()) AdaBoostClassifier.save(features, 'features.dump') features = np.array(features) print(features.shape) X_train, X_val, y_train, y_val = train_test_split(features, y, test_size=0.25) classifier = AdaBoostClassifier(DecisionTreeClassifier, 5) classifier.fit(X_train, y_train) score = classifier.predict_scores(X_val, y_val) predict = classifier.predict(X_val) y_val = np.array(list(map(lambda x: int(x), y_val.reshape(1, -1)[0]))) predict = np.array(list(map(lambda x: int(x), predict.reshape(1, -1)[0]))) print(predict) print(y_val) reportContent = 'score = ' + str(score) + '\n' reportContent += classification_report(y_val, predict) with open('classifier_report.txt', 'w') as report:
X_train, X_vali, y_train, y_vali = train_test_split(X, y, 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
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())
if os.path.exists('feature.data'): #如果预处理过,直接用load()读取数据 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)
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()
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()
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, validation_score_list = AdaBoostClassifier( DecisionTreeClassifier(max_depth=3), maxIteration).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())
transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform_train) train_dataloader = torch.utils.data.DataLoader(trainset, batch_size=BATCH_SIZE, shuffle=False) validation_dataloader = torch.utils.data.DataLoader(trainset, batch_size=1, shuffle=False) # Define and train the AdaBoostClassifier classifier = AdaBoostClassifier(ResNetBibdGcClassifier) classifier.train(train_dataloader, validation_dataloader, classifier_num=CLASSIFIER_NUM) transform_test = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) test_dataset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform_test) test_dataloader = torch.utils.data.DataLoader(test_dataset, batch_size=1, shuffle=False)
# 数据集加标签,并划分训练集,验证集 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))
for i in range(0,500): img_nonface=mpimg.imread(currentpath2+"{:0>3d}".format(i)+".jpg") img_nonface_=rgb2gray(img_nonface) f=NPDFeature(img_nonface_) feature_=f.extract() feature.append(feature_) 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")