'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)
