'GradBoost.__getitem__: argument \'i\' must be of type int') return self.ensemble[i] ################################################################################ ################################################################################ ################################################################################ ################################################################################ ## MAIN ######################################################################## ################################################################################ if __name__ == '__main__': data, predictions = load_data_from_csv('../data/regressor-data.csv', -1, float) data, predictions = arr(data), arr(predictions) data, predictions = bootstrap_data(data, predictions, 1000) # bases = [LinearRegress, LogisticRegress, KNNRegress, TreeRegress] bases = [KNNRegress] def test(trd, trc, ted, tec): X1, Y1 = bootstrap_data(trd, trc, round(len(trd) * .5)) X2, Y2 = bootstrap_data(trd, trc, round(len(trd) * .5)) base = bases[np.random.randint(len(bases))] gd = GradBoost(base, 10, X1, Y1) print('gd', '\n') print(gd, '\n')
return y_hat ################################################################################ ################################################################################ ################################################################################ ################################################################################ ## MAIN ######################################################################## ################################################################################ if __name__ == '__main__': ## RANDOM TESTING ############################################################## data, classes = load_data_from_csv('../data/classifier-data.csv', 4, float) data, classes = arr(data), arr(classes) bd1, bc1 = filter_data(data, classes, lambda x, y: y == 2) bd1, bc1 = np.array(bd1), np.array(bc1) def test(trd, trc, ted, tec): print('tc', '\n') tc = TreeClassify(trd, trc) print(tc, '\n') # print(tc.predict(ted), '\n') # print(tc.predict_soft(ted), '\n') # print(tc.confusion(ted, tec), '\n') # print(tc.auc(ted, tec), '\n') # print(tc.roc(ted, tec), '\n') err = tc.err(ted, tec)
T = {'pi': alpha, 'mu': mu, 'sig': sig} return optional_return(to_return, twod(z).T, T, soft, ll) ################################################################################ ################################################################################ ################################################################################ ################################################################################ ## MAIN ######################################################################## ################################################################################ if __name__ == '__main__': X, Y = data.load_data_from_csv('../data/classifier-data.csv', 4, float) X, Y = arr(X), arr(Y) z, T, soft, ll = em_cluster(X, 5, to_return=[1, 1, 1, 1]) print('z') print(z) print('T') print(T) print('soft') print(soft) print('ll') print(ll) ################################################################################ ################################################################################
################################################################################ ################################################################################ ################################################################################ ################################################################################ ## MAIN ######################################################################## ################################################################################ if __name__ == '__main__': ## RANDOM TESTING ############################################################## X,Y = load_data_from_csv('../data/binary.csv', 4, float) X,Y = bootstrap_data(X, Y, 1000) # X,mu,scale = rescale(X) Xtr,Xte,Ytr,Yte = split_data(X, Y, .8) nc = NNetClassify(Xtr, Ytr, [4,2,3,2], init='random', max_steps=5000, activation='htangent') print(nc.get_weights()) print(nc) print(nc.predict(Xte)) print(nc.predict_soft(Xte)) print(nc.err(Xte, Yte)) ## DETERMINISTIC TESTING ####################################################### # data = [[float(val) for val in row[:-1]] for row in csv.reader(open('../data/classifier-data.csv'))] # trd = np.asarray(data[0:40] + data[50:90] + data[100:140])
return optional_return(to_return, twod(z).T, join) ################################################################################ ################################################################################ ################################################################################ ################################################################################ ## MAIN ######################################################################## ################################################################################ if __name__ == '__main__': np.set_printoptions(linewidth=200, precision=2) X,Y = data.load_data_from_csv('../data/classifier-data.csv', 4, float) X,Y = arr(X), arr(Y) z,join = agglom_cluster(X, 5, to_return=[1,1]) print('z') print(z) print('join') print(join) ################################################################################ ################################################################################ ################################################################################
################################################################################ ################################################################################ ################################################################################ ################################################################################ ## MAIN ######################################################################## ################################################################################ if __name__ == '__main__': ## RANDOM TESTING ############################################################## data,classes = load_data_from_csv('../data/classifier-data.csv', 4, float) data,classes = arr(data), arr(classes) bd1,bc1 = filter_data(data, classes, lambda x,y: y == 2) bd1,bc1 = np.array(bd1), np.array(bc1) def test(trd, trc, ted, tec): print('gbc', '\n') gbc = GaussBayesClassify(trd, trc) print(gbc, '\n') # print(gbc.predict(ted), '\n') # print(gbc.predict_soft(ted), '\n') # print(gbc.confusion(ted, tec), '\n') # print(gbc.auc(ted, tec), '\n') # print(gbc.roc(ted, tec), '\n') err = gbc.err(ted, tec)
################################################################################ ################################################################################ ################################################################################ ################################################################################ ## MAIN ######################################################################## ################################################################################ if __name__ == "__main__": ## RANDOM TESTING ############################################################## data, predictions = load_data_from_csv("../data/regressor-data.csv", -1, float) data, predictions = arr(data), arr(predictions) def test(trd, trc, ted, tec): print("knnr", "\n") knnr = KNNRegress(trd, trc) print(knnr, "\n") err = knnr.mae(ted, tec) print(err, "\n") return err avg_err = test_randomly(data, predictions, 0.8, test) print("avg_err") print(avg_err)
################################################################################ ################################################################################ ################################################################################ ################################################################################ ## MAIN ######################################################################## ################################################################################ if __name__ == '__main__': ## RANDOM TESTING ############################################################## X,Y = load_data_from_csv('../data/gauss.csv', 4, float) X,Y = bootstrap_data(X, Y, 100000) # X,mu,scale = rescale(X) Xtr,Xte,Ytr,Yte = split_data(X, Y, .8) nc = NNetClassify(Xtr, Ytr, [4,5,5,5,5,5,5,5,4], init='random', max_steps=5000, activation='htangent') print(nc.get_weights()) print(nc) print(nc.predict(Xte)) print(nc.predict_soft(Xte)) print(nc.err(Xte, Yte)) ## DETERMINISTIC TESTING ####################################################### # data = [[float(val) for val in row[:-1]] for row in csv.reader(open('../data/classifier-data.csv'))] # trd = np.asarray(data[0:40] + data[50:90] + data[100:140])
'AdaBoost.__getitem__: argument \'i\' must be of type int') return self.ensemble[i] ################################################################################ ################################################################################ ################################################################################ ################################################################################ ## MAIN ######################################################################## ################################################################################ if __name__ == '__main__': data, predictions = load_data_from_csv('../data/binary.csv', -1, float) data, predictions = bootstrap_data(data, predictions, 150) bases = [GaussBayesClassify, KNNClassify, TreeClassify] def test(trd, trc, ted, tec): X1, Y1 = bootstrap_data(trd, trc, round(len(trd) * .5)) X2, Y2 = bootstrap_data(trd, trc, round(len(trd) * .5)) base = bases[np.random.randint(len(bases))] ab = AdaBoost(base, 10, X1, Y1) print('ab', '\n') print(ab)