def dec_or_reg_tree(df_train, df_test, Y):
binary = utils.check_binary(df_train[Y])
if binary:
newtree = treeHW4.TreeOptimal(max_depth=1)
y = list(df_train[Y])
nondf_train = utils.pandas_to_data(df_train)
nondf_test = utils.pandas_to_data(df_test)
newtree.fit(nondf_train, y)
predict = newtree.predict(nondf_train)
error_train = mystats.get_error(predict, y, binary)
y = utils.pandas_to_data(df_test[Y])
predict = newtree.predict(nondf_test)
error_test = mystats.get_error(predict, y)
else:
node = mytree.Node(np.ones(len(df_train)))
hw1.branch_node(node, df_train, 5, Y)
model = mytree.Tree(node)
predict = model.predict_obj()
error_train = mystats.get_error(predict, df_train[Y], binary)
node.presence = np.ones(len(df_test))
hw1.test_node(node, df_test, Y)
test_tree = mytree.Tree(node)
predict = test_tree.predict_obj()
error_test = mystats.get_error(predict, df_test[Y], binary)
return [error_train, error_test]
def linear_gd(df_train, df_test, Y):
""" linear gradient descent """
binary = utils.check_binary(df_train[Y])
model = gd.gradient(df_train, df_train[Y], 0.00001, max_iterations=50)
print model
predict = gd.predict(df_train, model, binary)
print predict
error_train = mystats.get_error(predict, df_train[Y], binary)
predict = gd.predict(df_test, model, binary)
print predict
error_test = mystats.get_error(predict, df_test[Y], binary)
return [error_train, error_test]
def logistic_gd(df_train, df_test, Y):
""" logistic gradient descent """
binary = utils.check_binary(df_train[Y])
model = gd.logistic_gradient(df_train, df_train[Y], 0.1, max_iterations=5)
print model
predict = gd.predict(df_train, model, binary, True)
print predict
error_train = mystats.get_error(predict, df_train[Y], binary)
predict = gd.predict(df_test, model, binary, True)
print predict
error_test = mystats.get_error(predict, df_test[Y], binary)
return [error_train, error_test]
def q1():
"""GDA """
"""Run the Gaussian Discriminant Analysis on the spambase data. Use the k-folds from the previous problem (1 for testing, k-1 for training, for each fold)
Since you have 57 real value features, each of the 2gaussians (for + class and for - class) will have a mean vector with 57 components, and a they will have
either a common (shared) covariance matrix size 57x57. This covariance is estimated from all training data (both classes)
or two separate covariance 57x57 matrices (estimated separately for each class)
(you can use a Matlab or Python of Java built in function to estimated covariance matrices, but the estimator is easy to code up).
Looking at the training and testing performance, does it appear that the gaussian assumption (normal distributed data) holds for this particular dataset?
"""
spamData = hw3.pandas_to_data(hw3.load_and_normalize_spambase()) # returns an array of arrays - this is by row
k = 10
train_acc_sum = 0
k_folds = hw3.partition_folds(spamData, k)
gdas = []
for ki in range(k - 1):
subset = []
gda = hw3.GDA()
X, truth = hw3.separate_X_and_y(k_folds[ki])
covariance_matrix = hw3.get_covar(X)
gda.p_y = float(sum(truth)) / len(truth)
gda.train(X, covariance_matrix, truth)
predictions = gda.predict(X)
#print predictions
accuracy = mystats.get_error(predictions, truth, True)
#gdas.append(gda)
print_output(ki, accuracy)
#print gda.prob
gdas.append(gda)
def linear_gd_error(df, Y):
binary = utils.check_binary(df[Y])
model = gd.gradient(df, df[Y], 0.00001, max_iterations=50)
print model
predict = gd.predict(df, model, binary)
print predict
error = mystats.get_error(predict, df_train[Y], binary)
return error
def testLogisticGradient():
""" logistic gradient descent """
df_test, df_train = utils.split_test_and_train(utils.load_and_normalize_spam_data())
Y = 'is_spam'
binary = utils.check_binary(df_train[Y])
model = gd.logistic_gradient(df_train, df_train[Y], .1, max_iterations=5)
#print model
#raw_input()
predict = gd.predict(df_train, model, binary, True)
print predict
error_train = mystats.get_error(predict, df_train[Y], binary)
#raw_input()
predict = gd.predict(df_test, model, binary, True)
print predict
error_test = mystats.get_error(predict, df_test[Y], binary)
print 'error train {} error_test {}'.format(error_train, error_test)
return [error_train, error_test]
def debug_print(iters, nc, h, y):
diffs = 0
error = mystats.get_error(h, y, 0)
for i, pred in enumerate(y):
diffs += abs(pred - h[i])
distance = float(diffs)/len(h)
print "actual"
print y[:5]
print "predicted"
print h[:5]
print 'loop: {} num not converged: {} distance: {} MSE: {}'.format(iters, nc, distance, error)
def k_folds_linear_gd(df_test, df_train, Y):
k = 10
df_test = gd.pandas_to_data(df_test)
k_folds = partition_folds(df_test, k)
model = Model_w()
theta = None
for ki in range(k - 1):
print "k fold is {}".format(k)
data, truth = get_data_and_truth(k_folds[ki])
binary = True
model.update(gd.gradient(data, np.array(truth), 0.00001, max_iterations=5, binary=binary))
print model.w
if theta is None:
theta, max_acc = get_best_theta(data, truth, model.w, binary, False)
predict = gd.predict_data(data, model.w, binary, False, theta)
error = mystats.get_error(predict, truth, binary)
print "Error for fold {} is {} with theta = {}".format(k, error, theta)
test, truth = get_data_and_truth(k_folds[k - 1])
predict = gd.predict_data(test, model.w, binary, False, theta)
test_error = mystats.get_error(predict, truth, binary)
return [error, test_error]
def get_best_theta(data, truth, model, binary, logistic):
best_theta = None
max_acc = 0
modmin = min(model)
modmax = max(model)
for theta_i in range(100):
theta = modmin + float(theta_i) / (modmax - modmin)
predict = gd.predict_data(data, model, binary, False, theta)
acc = mystats.get_error(predict, truth, binary)
if best_theta is None:
best_theta = theta
max_acc = acc
elif acc > max_acc:
best_theta = theta
max_acc = acc
return best_theta, max_acc
def linear_reg(df, Y, binary=False, ridge=False, sigmoid=False):
means = []
columns = [col for col in df.columns if (col != "is_spam" and col != "MEDV" and col != "y")]
if ridge:
w = mystats.get_linridge_w(df[columns], df[Y], binary)
else:
for col in df.columns:
mean = df[col].mean()
means.append(mean)
df[col] -= mean
w = mystats.get_linreg_w(df[columns], df[Y])
print ("w:")
print (w)
predict = mystats.predict(df[columns], w, binary, means=means)
error = mystats.get_error(predict, df[Y], binary)
return error
