def train(input): x = input['x'] y = input['y'] a = input['learning_rate'] iters = input['iters'] results = log_reg_sgd(x,y,a,max_iter=iters,debug=False) print 'Done, ', results return results
def train(input): x = input['x'] y = input['y'] a = input['learning_rate'] iters = input['iters'] results = log_reg_sgd(x,y,a,max_iter=iters,debug=False) print 'Done, ', results return results
def first_test(): from ml_metrics import auc import random from sklearn import datasets b = BasicLogisticRegression(4) iris = datasets.load_iris() train_data = iris.data[:75] train_y = iris.target[:75] test_x = iris.data[75:100] tmp = iris.target[:100] random.shuffle(tmp) test_y = tmp[:50] def to_dict(x): return {i: k for i, k in enumerate(x, start=1)} for z in xrange(50): for x, y in random.shuffle(zip(train_data, train_y)): # print x, y b.sgd_fit_one(to_dict(x), y) print "fit done" rst_y = map(b.predict_raw, map(to_dict, test_x)) print b.weights print test_y print rst_y print auc(test_y, rst_y) # print len(iris.data) # # another implementation from sgd import log_reg_sgd, h theta, err = log_reg_sgd(train_data, train_y, 0.001, max_iter=100) pred = [h(i, theta) for i in test_x] print "theta,", theta print auc(test_y, pred)
def test_sgd(): #number of examples EX = 500 #learning rate a = 0.001 #create a synthetic data set x,y = datasets.make_classification(EX) #append a 1 column at index 0 in x x = np.hstack((np.ones((x.shape[0],1)),x)) #train on half the data theta,err = log_reg_sgd(x[:EX/2],y[:EX/2],a,max_iter=100) #plot the error plt.plot(err, linewidth=2) plt.xlabel('Training example', fontsize=20) plt.ylabel('Error', fontsize=20) plt.show() #predict the test set pred = [h(x[i],theta) for i in xrange(EX/2,EX)] #plot the error as a function of training examples fpr, tpr, thresholds = metrics.roc_curve(y[EX/2:], pred) #plot the ROC curve plt.plot(fpr,tpr, linewidth=2) plt.xlabel('False positive rate', fontsize=20) plt.ylabel('True positive rate', fontsize=20) plt.show() #measure the performance using ROC and AUC auc = metrics.auc(fpr, tpr) print 'AUC of classifier: ', auc
def test_sgd(): #number of examples EX = 500 #learning rate a = 0.001 #create a synthetic data set x,y = datasets.make_classification(EX) #append a 1 column at index 0 in x x = np.hstack((np.ones((x.shape[0],1)),x)) #train on half the data theta,err = log_reg_sgd(x[:EX/2],y[:EX/2],a,max_iter=100) #plot the error plt.plot(err, linewidth=2) plt.xlabel('Training example', fontsize=20) plt.ylabel('Error', fontsize=20) plt.show() #predict the test set pred = [h(x[i],theta) for i in xrange(EX/2,EX)] #plot the error as a function of training examples fpr, tpr, thresholds = metrics.roc_curve(y[EX/2:], pred) #plot the ROC curve plt.plot(fpr,tpr, linewidth=2) plt.xlabel('False positive rate', fontsize=20) plt.ylabel('True positive rate', fontsize=20) plt.show() #measure the performance using ROC and AUC auc = metrics.auc(fpr, tpr) print 'AUC of classifier: ', auc
EX = 500 # learning rate a = 0.001 max_iter = 10 # create a synthetic data set x, y = datasets.make_classification(EX) print "sample", x[251] print "feature num ", x.shape[1] # append a 1 column at index 0 in x x = np.hstack((np.ones((x.shape[0], 1)), x)) print x[251] from sgd import log_reg_sgd, h theta = log_reg_sgd(x[:EX / 2], y[:EX / 2], a, max_iter=max_iter) pred = [h(x[i], theta) for i in xrange(EX / 2, EX)] print "weights ",theta # print "err ",err print auc(y[EX / 2:], pred) def to_dict(x): # print x return {i: k for i, k in enumerate(x[1:], start=1)} b = BasicLogisticRegression(x.shape[1]-1, a) for z in xrange(max_iter ): for i in xrange(EX / 2): b.sgd_fit_one(to_dict(x[i]), y[i])
def test_parallel_sgd(): #learning rate a = 0.001 #create a synthetic data set, default features, 1500 examples, 2 classes x,y = datasets.make_classification(1500) #append a 1 column at index 0 in x x = np.hstack((np.ones((x.shape[0],1)),x)) ### PARALLEL VERSION ### #worker pool pool = Pool(4) input = [{'x':x[:250],'y':y[:250],'learning_rate':a,'iters':500}, {'x':x[250:500],'y':y[250:500],'learning_rate':a,'iters':500}, {'x':x[500:750],'y':y[500:750],'learning_rate':a,'iters':500}, {'x':x[750:1000],'y':y[750:1000],'learning_rate':a,'iters':500}] thetas = pool.map(train, input) #compute the average theta = np.mean(thetas,axis=0) #we take the average prediction b_pred = [h(x[i],theta) for i in xrange(1000,1500)] #plot the error as a function of training examples b_fpr, b_tpr, thresholds = metrics.roc_curve(y[1000:], b_pred) #plot the ROC curve plt.plot(b_fpr,b_tpr, 'r-', label='Bagged', linewidth=2) #measure the performance using ROC and AUC b_auc = metrics.auc(b_fpr, b_tpr) print 'AUC of parallel classifier: ', b_auc ### ### SEQUENTIAL VERSION ### #train on half the data theta = log_reg_sgd(x[:1000],y[:1000],a,max_iter=500,debug=False) #predict the test set pred = [h(x[i],theta) for i in xrange(1000,1500)] #plot the error as a function of training examples fpr, tpr, thresholds = metrics.roc_curve(y[1000:], pred) #plot the ROC curve plt.plot(fpr,tpr, 'b-', label='Non-bagged', linewidth=2) plt.xlabel('False positive rate', fontsize=20) plt.ylabel('True positive rate', fontsize=20) plt.legend(loc=0) plt.show() #measure the performance using ROC and AUC auc = metrics.auc(fpr, tpr) print 'AUC of sequential classifier: ', auc #write results to file for later with open('bag_results.tsv','w') as out: for i,j in zip(b_fpr,b_tpr): out.write("\t".join((str(i),str(j)))+"\n") #write results to file for later with open('results.tsv','w') as out: for i,j in zip(fpr,tpr): out.write("\t".join((str(i),str(j)))+"\n")
def test_parallel_sgd(): #learning rate a = 0.001 #create a synthetic data set, default features, 1500 examples, 2 classes x,y = datasets.make_classification(1500) #append a 1 column at index 0 in x x = np.hstack((np.ones((x.shape[0],1)),x)) ### PARALLEL VERSION ### #worker pool pool = Pool(4) input = [{'x':x[:250],'y':y[:250],'learning_rate':a,'iters':500}, {'x':x[250:500],'y':y[250:500],'learning_rate':a,'iters':500}, {'x':x[500:750],'y':y[500:750],'learning_rate':a,'iters':500}, {'x':x[750:1000],'y':y[750:1000],'learning_rate':a,'iters':500}] thetas = pool.map(train, input) #compute the average theta = np.mean(thetas,axis=0) #we take the average prediction b_pred = [h(x[i],theta) for i in xrange(1000,1500)] #plot the error as a function of training examples b_fpr, b_tpr, thresholds = metrics.roc_curve(y[1000:], b_pred) #plot the ROC curve plt.plot(b_fpr,b_tpr, 'r-', label='Bagged', linewidth=2) #measure the performance using ROC and AUC b_auc = metrics.auc(b_fpr, b_tpr) print 'AUC of parallel classifier: ', b_auc ### ### SEQUENTIAL VERSION ### #train on half the data theta = log_reg_sgd(x[:1000],y[:1000],a,max_iter=500,debug=False) #predict the test set pred = [h(x[i],theta) for i in xrange(1000,1500)] #plot the error as a function of training examples fpr, tpr, thresholds = metrics.roc_curve(y[1000:], pred) #plot the ROC curve plt.plot(fpr,tpr, 'b-', label='Non-bagged', linewidth=2) plt.xlabel('False positive rate', fontsize=20) plt.ylabel('True positive rate', fontsize=20) plt.legend(loc=0) plt.show() #measure the performance using ROC and AUC auc = metrics.auc(fpr, tpr) print 'AUC of sequential classifier: ', auc #write results to file for later with open('bag_results.tsv','w') as out: for i,j in zip(b_fpr,b_tpr): out.write("\t".join((str(i),str(j)))+"\n") #write results to file for later with open('results.tsv','w') as out: for i,j in zip(fpr,tpr): out.write("\t".join((str(i),str(j)))+"\n")