def main():
train, train_targets = data_handling.read_train_dataset()
test, test_targets = data_handling.read_test_dataset()
layers_list = 3
my_epochs = 500
# for layers in layers_list:
mel_training(my_epochs, layers_list, train, test, train_targets,
test_targets)
def main():
# We use the prenormalized data given to us
train, train_targets = data_handling.read_train_dataset()
test, test_targets = data_handling.read_test_dataset()
epochs = 75
diff_nodes = [50, 75, 100, 150]
plot_everything(diff_nodes, epochs, train, test)
def main():
train, train_targets = data_handling.read_train_dataset()
test, test_targets = data_handling.read_test_dataset()
input_img = Input(shape=(784, ))
layers_list = 3
my_epochs = 500
# for layers in layers_list:
training(my_epochs, layers_list, input_img, train, test, train_targets,
test_targets)
def main():
#Read data
train, train_targets = data_handling.read_train_dataset()
test, test_targets = data_handling.read_test_dataset()
learning_rate = 0.06
n_iter = 20
mlp = MLPClassifier(hidden_layer_sizes=(150, 120, 90),
max_iter=n_iter,
alpha=1e-4,
solver='sgd',
verbose=10,
tol=1e-4,
random_state=1,
learning_rate_init=learning_rate)
mlp.fit(train, train_targets)
print("Training set score: %f" % mlp.score(train, train_targets))
print("Test set score: %f" % mlp.score(test, test_targets))
predictions = mlp.predict(test)
evaluate(test_targets, predictions)
def main():
#Read data
train, train_targets = data_handling.read_train_dataset()
test, test_targets = data_handling.read_test_dataset()
## Models with different number of hidden nodes: 50,75,100,150
logistic_50 = linear_model.LogisticRegression()
logistic_75 = linear_model.LogisticRegression()
logistic_100 = linear_model.LogisticRegression()
logistic_150 = linear_model.LogisticRegression()
rbm_50 = BernoulliRBM(random_state=0, verbose=True)
rbm_75 = BernoulliRBM(random_state=0, verbose=True)
rbm_100 = BernoulliRBM(random_state=0, verbose=True)
rbm_150 = BernoulliRBM(random_state=0, verbose=True)
# Hyper-parameters:
learning_rate = 0.06
n_iter = 20
# More components (hidden nodes) tend to give better prediction performance, but larger fitting time
error_50 = []
error_75 = []
error_100 = []
error_150 = []
#Training:
classifier_50, rbm_50 = train_classifier(rbm_50,
logistic_50,
train,
train_targets,
learning_rate,
n_iter,
n_hnodes=50)
classifier_75, rbm_75 = train_classifier(rbm_75,
logistic_75,
train,
train_targets,
learning_rate,
n_iter,
n_hnodes=75)
classifier_100, rbm_100 = train_classifier(rbm_100,
logistic_100,
train,
train_targets,
learning_rate,
n_iter,
n_hnodes=100)
classifier_150, rbm_150 = train_classifier(rbm_150,
logistic_150,
train,
train_targets,
learning_rate,
n_iter,
n_hnodes=150)
# Evaluation
print("Evaluation:")
print(
"Logistic regression using RBM features with 50 hidden nodes:\n%s\n" %
(metrics.classification_report(test_targets,
classifier_50.predict(test))))
print(
"Logistic regression using RBM features with 75 hidden nodes:\n%s\n" %
(metrics.classification_report(test_targets,
classifier_75.predict(test))))
print(
"Logistic regression using RBM features with 100 hidden nodes:\n%s\n" %
(metrics.classification_report(test_targets,
classifier_100.predict(test))))
print(
"Logistic regression using RBM features with 150 hidden nodes:\n%s\n" %
(metrics.classification_report(test_targets,
classifier_150.predict(test))))
# Plotting
plot_images(rbm_50, rbm_75, rbm_100, rbm_150)
# Predict test set
# image from each digit
example_digits_indexs = [
18, 3, 7, 0, 2, 1, 14, 8, 6, 5
] # indexs in the test partition digits: 0,1,2,3,4,5,6,7,8,9
prediction_50 = rbm_50.gibbs(test).astype(int)
prediction_75 = rbm_75.gibbs(test).astype(int)
prediction_100 = rbm_100.gibbs(test).astype(int)
prediction_150 = rbm_150.gibbs(test).astype(int)
print(calculate_error(prediction_50, test))
print(calculate_error(prediction_75, test))
print(calculate_error(prediction_100, test))
print(calculate_error(prediction_150, test))
plt.figure(figsize=(20, 20))
for index, i in enumerate(example_digits_indexs):
plt.subplot(10, 5, 5 * index + 1)
plt.imshow(test[i].reshape((28, 28)),
cmap=plt.cm.gray_r,
interpolation='nearest')
plt.subplot(10, 5, 5 * index + 2)
plt.imshow(prediction_50[i].reshape((28, 28)),
cmap=plt.cm.gray_r,
interpolation='nearest')
plt.subplot(10, 5, 5 * index + 3)
plt.imshow(prediction_75[i].reshape((28, 28)),
cmap=plt.cm.gray_r,
interpolation='nearest')
plt.subplot(10, 5, 5 * index + 4)
plt.imshow(prediction_100[i].reshape((28, 28)),
cmap=plt.cm.gray_r,
interpolation='nearest')
plt.subplot(10, 5, 5 * index + 5)
plt.imshow(prediction_150[i].reshape((28, 28)),
cmap=plt.cm.gray_r,
interpolation='nearest')
plt.show()
def main():
layers = 3
#Read data
train, train_targets = data_handling.read_train_dataset()
test, test_targets = data_handling.read_test_dataset()
## Models with different number of hidden nodes: 50,75,100,150
logistic_150 = linear_model.LogisticRegression()
rbm1_150 = BernoulliRBM(random_state=0, verbose=True)
rbm2 = BernoulliRBM(random_state=0, verbose=True)
rbm3 = BernoulliRBM(random_state=0, verbose=True)
# Hyper-parameters:
learning_rate = 0.06
n_iter = 20
# More components (hidden nodes) tend to give better prediction performance, but larger fitting time
#Training:
rbm1_150.learning_rate = learning_rate
rbm1_150.n_iter = n_iter
rbm1_150.n_components = 150
rbm2.learning_rate = learning_rate
rbm2.n_iter = n_iter
rbm2.n_components = 120
rbm3.learning_rate = learning_rate
rbm3.n_iter = n_iter
rbm3.n_components = 90
logistic_150.C = 6000.0
if layers == 1:
classifier = Pipeline(steps=[("rbm",
rbm1_150), ("logistic", logistic_150)])
if layers == 2:
classifier = Pipeline(
steps=[('rbm1', rbm1_150), ('rbm2',
rbm2), ('logistic', logistic_150)])
if layers == 3:
classifier = Pipeline(
steps=[('rbm1',
rbm1_150), ('rbm2',
rbm2), ('rbm3',
rbm3), ('logistic', logistic_150)])
# Training RBM-Logistic Pipeline
classifier.fit(train, train_targets)
logistic_classifier = linear_model.LogisticRegression(C=100.0)
logistic_classifier.fit(train, train_targets)
# Evaluation
print("Evaluation:")
print(
"Logistic regression using RBM features with 150 hidden nodes:\n%s\n" %
(metrics.classification_report(test_targets,
classifier.predict(test))))
print()
print("Logistic regression using raw pixel features:\n%s\n" %
(metrics.classification_report(test_targets,
logistic_classifier.predict(test))))
# Plotting
plt.figure(figsize=(10, 10))
for i, comp in enumerate(rbm1_150.components_):
plt.subplot(10, 15, i + 1)
plt.imshow(comp.reshape((28, 28)),
cmap=plt.cm.gray_r,
interpolation='nearest')
plt.xticks(())
plt.yticks(())
plt.suptitle('150 components extracted by RBM', fontsize=16)
plt.subplots_adjust(0.08, 0.02, 0.92, 0.85, 0.08, 0.23)
plt.show()
plt.figure(figsize=(10, 10))
for i, comp in enumerate(rbm2.components_):
plt.subplot(10, 12, i + 1)
plt.imshow(comp.reshape((10, 15)),
cmap=plt.cm.gray_r,
interpolation='nearest')
plt.xticks(())
plt.yticks(())
plt.suptitle('120 components extracted by RBM', fontsize=16)
plt.subplots_adjust(0.08, 0.02, 0.92, 0.85, 0.08, 0.23)
plt.show()
plt.figure(figsize=(10, 10))
for i, comp in enumerate(rbm3.components_):
plt.subplot(10, 10, i + 1)
plt.imshow(comp.reshape((10, 12)),
cmap=plt.cm.gray_r,
interpolation='nearest')
plt.xticks(())
plt.yticks(())
plt.suptitle('90 components extracted by RBM', fontsize=16)
plt.subplots_adjust(0.08, 0.02, 0.92, 0.85, 0.08, 0.23)
plt.show()