def score_pca(k, p = 0.5, seed = 1):
Xtrain, ytrain, Xtest, ytest = ps6.split_dataset(X, y, p, seed)
mu = ps6.get_mean_face(Xtrain)
eig_vecs, eig_vals = ps6.pca(Xtrain, k)
Xtrain_proj = np.dot(Xtrain - mu, eig_vecs)
# testing
mu = ps6.get_mean_face(Xtest)
Xtest_proj = np.dot(Xtest - mu, eig_vecs)
good = 0
bad = 0
for i, obs in enumerate(Xtest_proj):
dist = [np.linalg.norm(obs - x) for x in Xtrain_proj]
idx = np.argmin(dist)
y_pred = ytrain[idx]
if y_pred == ytest[i]:
good += 1
else:
bad += 1
return good, bad
def part_1c():
p = 0.5 # Select a split percentage value
k = 5 # Select a value for k
size = [32, 32]
X, y = ps6.load_images(YALE_FACES_DIR, size)
Xtrain, ytrain, Xtest, ytest = ps6.split_dataset(X, y, p)
# training
mu = ps6.get_mean_face(Xtrain)
eig_vecs, eig_vals = ps6.pca(Xtrain, k)
Xtrain_proj = np.dot(Xtrain - mu, eig_vecs)
# testing
mu = ps6.get_mean_face(Xtest)
Xtest_proj = np.dot(Xtest - mu, eig_vecs)
good = 0
bad = 0
for i, obs in enumerate(Xtest_proj):
dist = [np.linalg.norm(obs - x) for x in Xtrain_proj]
idx = np.argmin(dist)
y_pred = ytrain[idx]
if y_pred == ytest[i]:
good += 1
else:
bad += 1
print 'Good predictions = ', good, 'Bad predictions = ', bad
print '{0:.2f}% accuracy'.format(100 * float(good) / (good + bad))
def part_1c():
p = 0.5 # Select a split percentage value
k = 5 # Select a value for k
# testing values of k or comment this back in to see result set in a loop.
# p_range = np.arange(0.1, 1.0, 0.1)
# for j in p_range:
size = [32, 32]
X, y = ps6.load_images(YALE_FACES_DIR, size)
Xtrain, ytrain, Xtest, ytest = ps6.split_dataset(X, y, p)
# training
mu = ps6.get_mean_face(Xtrain)
eig_vecs, eig_vals = ps6.pca(Xtrain, k)
Xtrain_proj = np.dot(Xtrain - mu, eig_vecs)
# testing
mu = ps6.get_mean_face(Xtest)
Xtest_proj = np.dot(Xtest - mu, eig_vecs)
good = 0
bad = 0
for i, obs in enumerate(Xtest_proj):
dist = [np.linalg.norm(obs - x) for x in Xtrain_proj]
idx = np.argmin(dist)
y_pred = ytrain[idx]
if y_pred == ytest[i]:
good += 1
else:
bad += 1
# Enable result comparsion to a random value selector.
random_guess = np.random.randint(low=1, high=16, size=len(ytest))
# random accuracy check.
rand_good = 0
rand_bad = 0
for i in range(len(random_guess)):
if random_guess[i] == ytest[i]:
rand_good += 1
else:
rand_bad += 1
print 'Results where P is {}'.format(p)
print '-------------------------------'
print 'Random Selection Results'
print 'Good predictions = ', rand_good, 'Bad predictions = ', rand_bad
print '(Random) Testing accuracy: {0:.2f}%'.format(100 * float(rand_good) / (rand_good + rand_bad))
print 'Normal Dist Results'
print 'Good predictions = ', good, 'Bad predictions = ', bad
print '{0:.2f}% accuracy'.format(100 * float(good) / (good + bad))
print '--------------------------------'
print ''
def part_1c():
p = 0.8 # Select a split percentage value
k = 5 # Select a value for k
size = [32, 32]
X, y = ps6.load_images(YALE_FACES_DIR, size)
Xtrain, ytrain, Xtest, ytest = ps6.split_dataset(X, y, p)
# training
mu = ps6.get_mean_face(Xtrain)
eig_vecs, eig_vals = ps6.pca(Xtrain, k)
Xtrain_proj = np.dot(Xtrain - mu, eig_vecs)
# testing
mu = ps6.get_mean_face(Xtest)
Xtest_proj = np.dot(Xtest - mu, eig_vecs)
good = 0
bad = 0
for i, obs in enumerate(Xtest_proj):
dist = [np.linalg.norm(obs - x) for x in Xtrain_proj]
idx = np.argmin(dist)
y_pred = ytrain[idx]
if y_pred == ytest[i]:
good += 1
else:
bad += 1
print('Good predictions = ', good, 'Bad predictions = ', bad)
print('{0:.2f}% accuracy'.format(100 * float(good) / (good + bad)))
rand_y = np.random.choice([1, 16], (len(ytrain)))
temp_y = np.zeros_like(rand_y)
temp_y[rand_y == ytrain] = 1
rand_accuracy = 100 * float(np.sum(temp_y)) / (len(ytrain)) #None
# raise NotImplementedError
print('(Random) Training accuracy: {0:.2f}%'.format(rand_accuracy))
def part_2a():
y0 = 1
y1 = 2
X, y = ps6.load_images(FACES94_DIR)
# Select only the y0 and y1 classes
idx = y == y0
idx |= y == y1
X = X[idx,:]
y = y[idx]
# Label them 1 and -1
y0_ids = y == y0
y1_ids = y == y1
y[y0_ids] = 1
y[y1_ids] = -1
p = 0.8
Xtrain, ytrain, Xtest, ytest = ps6.split_dataset(X, y, p)
# Picking random numbers
rand_y = np.random.choice([-1, 1], (len(ytrain)))
# TODO: find which of these labels match ytrain and report its accuracy
#rand_accuracy = None
rand_accuracy = 100. * helper_func(rand_y, ytrain) / len(ytrain)
#raise NotImplementedError
print '(Random) Training accuracy: {0:.2f}%'.format(rand_accuracy)
# Using Weak Classifier
uniform_weights = np.ones((Xtrain.shape[0],)) / Xtrain.shape[0]
wk_clf = ps6.WeakClassifier(Xtrain, ytrain, uniform_weights)
wk_clf.train()
wk_results = [wk_clf.predict(x) for x in Xtrain]
# TODO: find which of these labels match ytrain and report its accuracy
wk_accuracy = None
#raise NotImplementedError
wk_accuracy = 100. * helper_func(wk_results, ytrain) / len(ytrain)
print '(Weak) Training accuracy {0:.2f}%'.format(wk_accuracy)
num_iter = 5
boost = ps6.Boosting(Xtrain, ytrain, num_iter)
boost.train()
good, bad = boost.evaluate()
boost_accuracy = 100 * float(good) / (good + bad)
print '(Boosting) Training accuracy {0:.2f}%'.format(boost_accuracy)
# Picking random numbers
rand_y = np.random.choice([-1, 1], (len(ytest)))
# TODO: find which of these labels match ytest and report its accuracy
rand_accuracy = None
#raise NotImplementedError
rand_accuracy = 100. * helper_func(rand_y, ytest) / len(ytest)
print '(Random) Testing accuracy: {0:.2f}%'.format(rand_accuracy)
# Using Weak Classifier
wk_results = [wk_clf.predict(x) for x in Xtest]
# TODO: find which of these labels match ytest and report its accuracy
wk_accuracy = None
#raise NotImplementedError
wk_accuracy = 100.* helper_func(wk_results, ytest) / len(ytest)
print '(Weak) Testing accuracy {0:.2f}%'.format(wk_accuracy)
y_pred = boost.predict(Xtest)
# TODO: find which of these labels match ytest and report its accuracy
boost_accuracy = None
#raise NotImplementedError
boost_accuracy = 100. * helper_func(y_pred, ytest) / len(ytest)
print '(Boosting) Testing accuracy {0:.2f}%'.format(boost_accuracy)
def part_2a():
y0 = 1
y1 = 2
X, y = ps6.load_images(FACES94_DIR)
# Select only the y0 and y1 classes
idx = y == y0
idx |= y == y1
X = X[idx,:]
y = y[idx]
# Label them 1 and -1
y0_ids = y == y0
y1_ids = y == y1
y[y0_ids] = 1
y[y1_ids] = -1
p = 0.9
Xtrain, ytrain, Xtest, ytest = ps6.split_dataset(X, y, p)
# Picking random numbers
rand_y = np.random.choice([-1, 1], (len(ytrain)))
# TODO: find which of these labels match ytrain and report its accuracy
good = 0
bad = 0
for i in range(0, len(ytrain)):
if(ytrain[i] == rand_y[i]):
good += 1
else:
bad += 1
rand_accuracy = 100 * float(good) / (good + bad)
print '(Random) Training accuracy: {0:.2f}%'.format(rand_accuracy)
# Using Weak Classifier
uniform_weights = np.ones((Xtrain.shape[0],)) / Xtrain.shape[0]
wk_clf = ps6.WeakClassifier(Xtrain, ytrain, uniform_weights)
wk_clf.train()
wk_results = [wk_clf.predict(x) for x in Xtrain]
# TODO: find which of these labels match ytrain and report its accuracy
wk_accuracy = None
good = 0
bad = 0
for i in range(0, len(ytrain)):
if(ytrain[i] == wk_results[i]):
good += 1
else:
bad += 1
wk_accuracy = 100* float(good) / (good + bad)
print '(Weak) Training accuracy {0:.2f}%'.format(wk_accuracy)
num_iter = 2
boost = ps6.Boosting(Xtrain, ytrain, num_iter)
boost.train()
good, bad = boost.evaluate()
boost_accuracy = 100 * float(good) / (good + bad)
print '(Boosting) Training accuracy {0:.2f}%'.format(boost_accuracy)
# Picking random numbers
rand_y = np.random.choice([-1, 1], (len(ytest)))
# TODO: find which of these labels match ytest and report its accuracy
rand_accuracy = None
good = 0
bad = 0
for i in range(0, len(ytest)):
if(ytest[i] == rand_y[i]):
good += 1
else:
bad += 1
rand_accuracy = 100 * float(good) / (good + bad)
print '(Random) Testing accuracy: {0:.2f}%'.format(rand_accuracy)
# Using Weak Classifier
wk_results = [wk_clf.predict(x) for x in Xtest]
# TODO: find which of these labels match ytest and report its accuracy
wk_accuracy = None
good = 0
bad = 0
for i in range(0, len(ytest)):
if(ytest[i] == wk_results[i]):
good += 1
else:
bad += 1
wk_accuracy = 100* float(good) / (good + bad)
print '(Weak) Testing accuracy {0:.2f}%'.format(wk_accuracy)
y_pred = boost.predict(Xtest)
# TODO: find which of these labels match ytest and report its accuracy
boost_accuracy = None
good = 0
bad = 0
for i in range(0, len(ytest)):
if(ytest[i] == y_pred[i]):
good += 1
else:
bad += 1
boost_accuracy = 100* float(good) / (good + bad)
print '(Boosting) Testing accuracy {0:.2f}%'.format(boost_accuracy)
def evaluate_faces_94(p):
y0 = 1
y1 = 2
X, y = ps6.load_images(FACES94_DIR)
# Select only the y0 and y1 classes
idx = y == y0
idx |= y == y1
X = X[idx, :]
y = y[idx]
# Label them 1 and -1
y0_ids = y == y0
y1_ids = y == y1
y[y0_ids] = 1
y[y1_ids] = -1
Xtrain, ytrain, Xtest, ytest = ps6.split_dataset(X, y, p)
results = []
# Picking random numbers
rand_y = np.random.choice([-1, 1], (len(ytrain)))
matching_indices = np.where(rand_y == ytrain)[0]
rand_train_accuracy = matching_indices.shape[0] / ytrain.shape[0]
# print('(Random) Training accuracy: {0:.2f}%'.format(rand_train_accuracy))
# Using Weak Classifier
uniform_weights = np.ones((Xtrain.shape[0], )) / Xtrain.shape[0]
wk_clf = ps6.WeakClassifier(Xtrain, ytrain, uniform_weights)
wk_clf.train()
wk_results = [wk_clf.predict(x) for x in Xtrain]
matching_indices = np.where(wk_results == ytrain)[0]
wk__train_accuracy = matching_indices.shape[0] / ytrain.shape[0]
results.append(wk__train_accuracy)
# print('(Weak) Training accuracy {0:.2f}%'.format(wk__train_accuracy))
num_iter = 4
boost = ps6.Boosting(Xtrain, ytrain, num_iter)
boost.train()
good, bad = boost.evaluate()
boost_train_accuracy = float(good) / (good + bad)
results.append(boost_train_accuracy)
# print('(Boosting) Training accuracy {0:.2f}%'.format(boost_train_accuracy))
num_iter = 12
boost_12 = ps6.Boosting(Xtrain, ytrain, num_iter)
boost_12.train()
good, bad = boost_12.evaluate()
boost_train_accuracy_12 = float(good) / (good + bad)
results.append(boost_train_accuracy_12)
# Picking random numbers
rand_y = np.random.choice([-1, 1], (len(ytest)))
matching_indices = np.where(rand_y == ytest)[0]
rand_test_accuracy = matching_indices.shape[0] / ytest.shape[0]
# print('(Random) Testing accuracy: {0:.2f}%'.format(rand_test_accuracy))
# Using Weak Classifier
wk_results = [wk_clf.predict(x) for x in Xtest]
matching_indices = np.where(wk_results == ytest)[0]
wk_test_accuracy = matching_indices.shape[0] / ytest.shape[0]
results.append(wk_test_accuracy)
# print('(Weak) Testing accuracy {0:.2f}%'.format(wk_test_accuracy))
y_pred = boost.predict(Xtest)
matching_indices = np.where(y_pred == ytest)[0]
boost_test_accuracy = matching_indices.shape[0] / ytest.shape[0]
results.append(boost_test_accuracy)
# print('(Boosting) Testing accuracy {0:.2f}%'.format(boost_test_accuracy))
y_pred = boost_12.predict(Xtest)
matching_indices = np.where(y_pred == ytest)[0]
boost_test_accuracy_12 = matching_indices.shape[0] / ytest.shape[0]
results.append(boost_test_accuracy_12)
return results
def part_2a():
y0 = 1
y1 = 2
X, y = ps6.load_images(FACES94_DIR)
# Select only the y0 and y1 classes
idx = y == y0
idx |= y == y1
X = X[idx, :]
y = y[idx]
# Label them 1 and -1
y0_ids = y == y0
y1_ids = y == y1
y[y0_ids] = 1
y[y1_ids] = -1
p = 0.8
Xtrain, ytrain, Xtest, ytest = ps6.split_dataset(X, y, p)
# Picking random numbers
rand_y = np.random.choice([-1, 1], (len(ytrain)))
random_correctness = np.zeros_like(rand_y)
random_correctness[rand_y == ytrain] = 1
rand_accuracy = 100 * float(np.sum(random_correctness)) / (len(ytrain))
print('(Random) Training accuracy: {0:.2f}%'.format(rand_accuracy))
# Using Weak Classifier
uniform_weights = np.ones((Xtrain.shape[0], )) / Xtrain.shape[0]
wk_clf = ps6.WeakClassifier(Xtrain, ytrain, uniform_weights)
wk_clf.train()
wk_results = [wk_clf.predict(x) for x in Xtrain]
wk_correctness = np.zeros_like(wk_results)
wk_correctness[wk_results == ytrain] = 1
wk_accuracy = 100 * float(np.sum(wk_correctness)) / (len(ytrain))
print('(Weak) Training accuracy {0:.2f}%'.format(wk_accuracy))
num_iter = 5
boost = ps6.Boosting(Xtrain, ytrain, num_iter)
boost.train()
good, bad = boost.evaluate()
boost_accuracy = 100 * float(good) / (good + bad)
print('(Boosting) Training accuracy {0:.2f}%'.format(boost_accuracy))
# Picking random numbers
rand_y = np.random.choice([-1, 1], (len(ytest)))
random_correctness = np.zeros_like(rand_y)
random_correctness[rand_y == ytest] = 1
rand_accuracy = 100 * float(np.sum(random_correctness)) / (len(ytest))
print('(Random) Testing accuracy: {0:.2f}%'.format(rand_accuracy))
# Using Weak Classifier
wk_results = [wk_clf.predict(x) for x in Xtest]
wk_correctness = np.zeros_like(wk_results)
wk_correctness[wk_results == ytest] = 1
wk_accuracy = 100 * float(np.sum(wk_correctness)) / (len(ytest))
print('(Weak) Testing accuracy {0:.2f}%'.format(wk_accuracy))
y_pred = boost.predict(Xtest)
boost_correctness = np.zeros_like(y_pred)
boost_correctness[y_pred == ytest] = 1
boost_accuracy = 100 * float(np.sum(boost_correctness)) / (len(ytest))
print('(Boosting) Testing accuracy {0:.2f}%'.format(boost_accuracy))
def part_1c():
runk = 1
runp = 1
if runk:
p = 0.5 # Select a split percentage value
ks = []
accuracy = []
for k in range(1, 30):
size = (32, 32)
X, y = ps6.load_images(YALE_FACES_DIR, size)
Xtrain, ytrain, Xtest, ytest = ps6.split_dataset(X, y, p)
# training
mu = ps6.get_mean_face(Xtrain)
eig_vecs, eig_vals = ps6.pca(Xtrain, k)
Xtrain_proj = np.dot(Xtrain - mu, eig_vecs)
# testing
mu = ps6.get_mean_face(Xtest)
Xtest_proj = np.dot(Xtest - mu, eig_vecs)
good = 0
bad = 0
for i, obs in enumerate(Xtest_proj):
dist = [np.linalg.norm(obs - x) for x in Xtrain_proj]
idx = np.argmin(dist)
y_pred = ytrain[idx]
if y_pred == ytest[i]:
good += 1
else:
bad += 1
print 'Good predictions = ', good, 'Bad predictions = ', bad
ks.append(k)
accuracy.append(100 * float(good) / (good + bad))
print '{0:.2f}% accuracy'.format(100 * float(good) / (good + bad))
plt.figure()
plt.ylabel('Accuracy')
plt.xlabel('# of PCs')
plt.title('Accuracy vs Number of PCs ')
plt.plot(ks, accuracy)
plt.grid()
plt.draw()
plt.savefig('./pca_plot.png')
#plt.show()
if runp:
k = 10
accuracy = []
ps = []
for p in np.arange(0.2, 1.0, 0.1):
size = (32, 32)
X, y = ps6.load_images(YALE_FACES_DIR, size)
Xtrain, ytrain, Xtest, ytest = ps6.split_dataset(X, y, p)
# training
mu = ps6.get_mean_face(Xtrain)
eig_vecs, eig_vals = ps6.pca(Xtrain, k)
Xtrain_proj = np.dot(Xtrain - mu, eig_vecs)
# testing
mu = ps6.get_mean_face(Xtest)
Xtest_proj = np.dot(Xtest - mu, eig_vecs)
good = 0
bad = 0
for i, obs in enumerate(Xtest_proj):
dist = [np.linalg.norm(obs - x) for x in Xtrain_proj]
idx = np.argmin(dist)
y_pred = ytrain[idx]
if y_pred == ytest[i]:
good += 1
else:
bad += 1
print 'Good predictions = ', good, 'Bad predictions = ', bad
ps.append(p)
accuracy.append(100 * float(good) / (good + bad))
print '{0:.2f}% accuracy'.format(100 * float(good) / (good + bad))
plt.figure()
plt.ylabel('Accuracy')
plt.xlabel('Percentage of data split')
plt.title('Accuracy vs data split percentage ')
plt.plot(ps, accuracy)
plt.grid()
plt.draw()
plt.savefig('./split_P_plot.png')
def part_2a(p = 0.8, num_iter = 5, seed = 1, verbose = True):
y0 = 1
y1 = 2
X, y = ps6.load_images(FACES94_DIR)
# Select only the y0 and y1 classes
idx = y == y0
idx |= y == y1
X = X[idx.flatten(),:]
y = y[idx]
# Label them 1 and -1
y0_ids = y == y0
y1_ids = y == y1
y[y0_ids] = 1
y[y1_ids] = -1
Xtrain, ytrain, Xtest, ytest = ps6.split_dataset(X, y, p, seed = seed)
# Picking random numbers
rand_y = np.random.choice([-1, 1], (len(ytrain)))
# TODO: find which of these labels match ytrain and report its accuracy
rand_accuracy = 100*sum(ytrain==rand_y)*1./ytrain.shape[0]
# raise NotImplementedError
if verbose:
print '(Random) Training accuracy: {0:.2f}%'.format(rand_accuracy)
# Using Weak Classifier
uniform_weights = np.ones((Xtrain.shape[0],)) / Xtrain.shape[0]
wk_clf = ps6.WeakClassifier(Xtrain, ytrain, uniform_weights)
wk_clf.train()
wk_results = [wk_clf.predict(x) for x in Xtrain]
# TODO: find which of these labels match ytrain and report its accuracy
wk_accuracy = 100*sum(ytrain==wk_results)*1./ytrain.shape[0]
#raise NotImplementedError
if verbose:
print '(Weak) Training accuracy {0:.2f}%'.format(wk_accuracy)
boost = ps6.Boosting(Xtrain, ytrain, num_iter)
boost.train()
good, bad = boost.evaluate()
boost_accuracy = 100 * float(good) / (good + bad)
if verbose:
print '(Boosting) Training accuracy {0:.2f}%'.format(boost_accuracy)
results = [p, num_iter, rand_accuracy, wk_accuracy, boost_accuracy ]
# Picking random numbers
rand_y = np.random.choice([-1, 1], (len(ytest)))
# TODO: find which of these labels match ytest and report its accuracy
rand_accuracy = 100*sum(ytest==rand_y)*1./ytest.shape[0]
if verbose:
print '(Random) Testing accuracy: {0:.2f}%'.format(rand_accuracy)
# Using Weak Classifier
wk_results = [wk_clf.predict(x) for x in Xtest]
# TODO: find which of these labels match ytest and report its accuracy
wk_accuracy = 100*sum(ytest==wk_results)*1./ytest.shape[0]
if verbose:
print '(Weak) Testing accuracy {0:.2f}%'.format(wk_accuracy)
y_pred = boost.predict(Xtest)
# TODO: find which of these labels match ytest and report its accuracy
boost_accuracy = 100*sum(ytest==y_pred)*1./ytest.shape[0]
if verbose:
print '(Boosting) Testing accuracy {0:.2f}%'.format(boost_accuracy)
results += [rand_accuracy, wk_accuracy, boost_accuracy ]
return results
def part_2a():
y0 = 1
y1 = 2
X, y = ps6.load_images(FACES94_DIR)
# Select only the y0 and y1 classes
idx = y == y0
idx |= y == y1
X = X[idx, :]
y = y[idx]
# Label them 1 and -1
y0_ids = y == y0
y1_ids = y == y1
y[y0_ids] = 1
y[y1_ids] = -1
p = 0.8
Xtrain, ytrain, Xtest, ytest = ps6.split_dataset(X, y, p)
# Picking random numbers
rand_y = np.random.choice([-1, 1], (len(ytrain)))
matches = [rand_y[i] == ytrain[i] for i in range(0, len(rand_y))]
corr = np.sum([int(x) for x in matches])
rand_accuracy = float(corr) / float(len(ytrain)) * 100
print '(Random) Training accuracy: {0:.2f}%'.format(rand_accuracy)
# Using Weak Classifier
uniform_weights = np.ones((Xtrain.shape[0], )) / Xtrain.shape[0]
wk_clf = ps6.WeakClassifier(Xtrain, ytrain, uniform_weights)
wk_clf.train()
wk_results = [wk_clf.predict(x) for x in Xtrain]
matches = [ytrain[i] == wk_results[i] for i in range(0, len(ytrain))]
corr = np.sum([int(x) for x in matches])
wk_accuracy = float(corr) / float(len(ytrain)) * 100
print '(Weak) Training accuracy {0:.2f}%'.format(wk_accuracy)
# num_iter = 5
for i in range(5, 10):
print i
num_iter = i
boost = ps6.Boosting(Xtrain, ytrain, num_iter)
boost.train()
good, bad = boost.evaluate()
# print good, bad
boost_accuracy = 100 * float(good) / (good + bad)
print '(Boosting) Training accuracy {0:.2f}%'.format(boost_accuracy)
y_pred = boost.predict(Xtest)
matches = [y_pred[i] == ytest[i] for i in range(0, len(ytest))]
corr = np.sum(np.array([int(x) for x in matches]))
boost_accuracy = corr / float(len(ytest)) * 100
print '(Boosting) Testing accuracy {0:.2f}%'.format(boost_accuracy)
# Picking random numbers
rand_y = np.random.choice([-1, 1], (len(ytest)))
matches = [rand_y[i] == ytest[i] for i in range(0, len(ytest))]
# print matches
corr = np.sum(np.array([int(x) for x in matches]))
rand_accuracy = corr / float(len(ytest)) * 100
print '(Random) Testing accuracy: {0:.2f}%'.format(rand_accuracy)
# Using Weak Classifier
wk_results = [wk_clf.predict(x) for x in Xtest]
matches = [ytest[i] == wk_results[i] for i in range(0, len(Xtest))]
# print matches
corr = np.sum(np.array([int(x) for x in matches]))
# print corr
wk_accuracy = corr / float(len(ytest)) * 100
print '(Weak) Testing accuracy {0:.2f}%'.format(wk_accuracy)
def part_2a():
y0 = 1
y1 = 2
X, y = ps6.load_images(FACES94_DIR)
# Select only the y0 and y1 classes
idx = y == y0
idx |= y == y1
X = X[idx, :]
y = y[idx]
# Label them 1 and -1
y0_ids = y == y0
y1_ids = y == y1
y[y0_ids] = 1
y[y1_ids] = -1
p = 0.8
Xtrain, ytrain, Xtest, ytest = ps6.split_dataset(X, y, p)
# Picking random numbers
rand_y = np.random.choice([-1, 1], (len(ytrain)))
# the accuracy is the percent of correct answer. Loop over the lenght
correct = 0
for i in range(len(ytrain)):
if rand_y[i] == ytrain[i]:
correct += 1
# convert to a %
rand_accuracy = 100 * (float(correct) / float(len(ytrain)))
print '(Random) Training accuracy: {0:.2f}%'.format(rand_accuracy)
# Picking random numbers
rand_y = np.random.choice([-1, 1], (len(ytest)))
correct = 0
for i in range(len(ytest)):
if rand_y[i] == ytest[i]:
correct += 1
rand_accuracy = 100 * (float(correct) / float(len(ytest)))
print '(Random) Testing accuracy: {0:.2f}%'.format(rand_accuracy)
# Using Weak Classifier
uniform_weights = np.ones((Xtrain.shape[0],)) / Xtrain.shape[0]
wk_clf = ps6.WeakClassifier(Xtrain, ytrain, uniform_weights)
wk_clf.train()
wk_results = [wk_clf.predict(x) for x in Xtrain]
correct = 0
for i in range(len(ytrain)):
if wk_results[i] == ytrain[i]:
correct += 1
# convert to a %
wk_accuracy = 100 * (float(correct) / float(len(ytrain)))
print '(Weak) Training accuracy {0:.2f}%'.format(wk_accuracy)
# Using Weak Classifier
wk_results = [wk_clf.predict(x) for x in Xtest]
correct = 0
for i in range(len(ytest)):
if wk_results[i] == ytest[i]:
correct += 1
wk_accuracy = 100 * (float(correct) / float(len(ytest)))
print '(Weak) Testing accuracy {0:.2f}%'.format(wk_accuracy)
num_iter = 5
# for num_iter in range(1, 11):
boost = ps6.Boosting(Xtrain, ytrain, num_iter)
boost.train()
good, bad = boost.evaluate()
boost_accuracy = 100 * float(good) / (good + bad)
print '(Boosting) Training accuracy {0:.2f}%'.format(boost_accuracy)
y_pred = boost.predict(Xtest)
correct = 0
for i in range(len(ytest)):
if y_pred[i] == ytest[i]:
correct += 1
boost_accuracy = 100 * (float(correct) / float(len(ytest)))
print '(Boosting) Testing accuracy {0:.2f}%'.format(boost_accuracy)
def part_2a():
y0 = 1
y1 = 2
X, y = ps6.load_images(FACES94_DIR)
# Select only the y0 and y1 classes
idx = y == y0
idx |= y == y1
# print(np.shape(X))
X = X[idx, :]
y = y[idx]
# print(np.shape(y))
# Label them 1 and -1
y0_ids = y == y0
y1_ids = y == y1
# print(np.shape(y))
y[y0_ids] = 1
y[y1_ids] = -1
p = 0.1
Xtrain, ytrain, Xtest, ytest = ps6.split_dataset(X, y, p)
# Picking random numbers
rand_y = np.random.choice([-1, 1], (len(ytrain)))
# TODO: find which of these labels match ytrain and report its accuracy
temp_y = np.zeros_like(rand_y)
temp_y[rand_y == ytrain] = 1
rand_accuracy = 100 * float(np.sum(temp_y)) / (len(ytrain)) #None
# raise NotImplementedError
print('(Random) Training accuracy: {0:.2f}%'.format(rand_accuracy))
# Using Weak Classifier
uniform_weights = np.ones((Xtrain.shape[0], )) / Xtrain.shape[0]
wk_clf = ps6.WeakClassifier(Xtrain, ytrain, uniform_weights)
wk_clf.train()
wk_results = [wk_clf.predict(x) for x in Xtrain]
temp_wk = np.zeros_like(wk_results)
temp_wk[wk_results == ytrain] = 1
# TODO: find which of these labels match ytrain and report its accuracy
wk_accuracy = 100 * float(np.sum(temp_wk)) / (len(ytrain)) #None
# raise NotImplementedError
print('(Weak) Training accuracy {0:.2f}%'.format(wk_accuracy))
num_iter = 20
# print(np.shape(Xtrain))
boost = ps6.Boosting(Xtrain, ytrain, num_iter)
boost.train()
good, bad = boost.evaluate()
boost_accuracy = 100 * float(good) / (good + bad)
print('(Boosting) Training accuracy {0:.2f}%'.format(boost_accuracy))
# Picking random numbers
rand_y = np.random.choice([-1, 1], (len(ytest)))
# TODO: find which of these labels match ytest and report its accuracy
temp_y = np.zeros_like(rand_y)
temp_y[rand_y == ytest] = 1
rand_accuracy = 100 * float(np.sum(temp_y)) / (len(ytest))
# raise NotImplementedError
print('(Random) Testing accuracy: {0:.2f}%'.format(rand_accuracy))
# Using Weak Classifier
wk_results = [wk_clf.predict(x) for x in Xtest]
# TODO: find which of these labels match ytest and report its accuracy
temp_wk = np.zeros_like(wk_results)
temp_wk[wk_results == ytest] = 1
wk_accuracy = 100 * float(np.sum(temp_wk)) / (len(ytest))
# raise NotImplementedError
print('(Weak) Testing accuracy {0:.2f}%'.format(wk_accuracy))
y_pred = boost.predict(Xtest)
# TODO: find which of these labels match ytest and report its accuracy
temp_b = np.zeros_like(y_pred)
temp_b[y_pred == ytest] = 1
boost_accuracy = 100 * float(np.sum(temp_b)) / (len(ytest))
# raise NotImplementedError
print('(Boosting) Testing accuracy {0:.2f}%'.format(boost_accuracy))