def solve(tX, y):
tX_tr, y_tr, tX_te, y_te = split_data(tX, y, ratio=0.8, seed=2019)
lambda_ = 1
w, _ = ridge_regression(y_tr, tX_tr, lambda_)
y_pr_tr = predict_labels(w, tX_tr)
y_pr_te = predict_labels(w, tX_te)
acc_tr = compute_accuracy(y_tr, y_pr_tr)
acc_te = compute_accuracy(y_te, y_pr_te)
return acc_tr, acc_te
def train_3models(tX, y):
# Preprocess data together to have the same shifts while creating log or root features
prep_param = {
"bias": True,
"fill": True,
"standardize": False,
"degree": 8,
"log": True,
"root": True
}
tX_new, y_new, _ = preprocess_data(tX, y, prep_param)
tX_tr, y_tr, tX_te, y_te = split_data(tX_new, y_new, ratio=0.8, seed=2019)
# Split data according to PRI_jet_num value
tX_tr_splitted, indices_tr = divide_data(tX_tr)
tX_te_splitted, indices_te = divide_data(tX_te)
n_models = len(tX_tr_splitted)
y_tr_splitted = []
for i in range(len(indices_tr)):
y_tr_splitted.append(y_tr[indices_tr[i]])
print(tX_tr_splitted[i].shape)
# Train
weights = []
for i in range(n_models):
lambda_ = lambda_cv(tX_tr_splitted[i], y_tr_splitted[i])
print(f"Class {i}, lambda: {lambda_}")
weights.append(
ridge_regression(y_tr_splitted[i], tX_tr_splitted[i], lambda_)[0])
print(len(weights[-1]))
# Predict
y_pr_tr = np.zeros(y_tr.shape)
y_pr_te = np.zeros(y_te.shape)
for i in range(n_models):
y_pr_tr[indices_tr[i]] = predict_labels(weights[i], tX_tr_splitted[i])
y_pr_te[indices_te[i]] = predict_labels(weights[i], tX_te_splitted[i])
# Get accuracy
acc_tr = compute_accuracy(y_tr, y_pr_tr)
acc_te = compute_accuracy(y_te, y_pr_te)
print(f"Total accuracy tr: {acc_tr}, te: {acc_te}")
for i in range(n_models):
acc_tr = compute_accuracy(y_tr[indices_tr[i]], y_pr_tr[indices_tr[i]])
acc_te = compute_accuracy(y_te[indices_te[i]], y_pr_te[indices_te[i]])
print(f"Class {i}, Accuracy tr: {acc_tr}, te: {acc_te}")
def cross_validation(y, x, k_indices, k, lambda_, degree):
# Dividing in subgroups
te_indice = k_indices[k]
tr_indice = k_indices[~(np.arange(k_indices.shape[0]) == k)]
tr_indice = tr_indice.reshape(-1)
y_te = y[te_indice]
y_tr = y[tr_indice]
tx_te = x[te_indice]
tx_tr = x[tr_indice]
# Preprocessing data: cleaning, standardazing and adding constant column
tx_tr, tx_te = process_data(tx_tr, tx_te, y_tr, y_te)
# Feature augmentation through polynomials
tx_tr = build_poly(tx_tr, degree)
tx_te = build_poly(tx_te, degree)
# Printing degree and lambda tested
print("Test: d = ", degree, "; l = ", lambda_)
# Training with ridge regression
w, loss = ridge_regression(y_tr, tx_tr, lambda_)
# Computing prediction vector
y_pred = predict_labels(w, tx_te)
# Computing accuracy on test set
accuracy = compute_accuracy(y_te, y_pred)
# Log informations
print("Accuracy = ", accuracy, "; loss = ", loss, "\n")
return loss_te, accuracy
def logistic_trials(y, tx, tx_sub, degree_range, partitions=2):
## Split data into test and training sets
## If partitions > 2, use k-fold cross-validation
glob_tx_tr, glob_tx_te, glob_y_tr, glob_y_te = split_data(tx, y, 0.8)
## Initial results: losses, weights, preditions and (test) losses
models = []
losses = []
accuracies = []
predictions = []
## Loops over range of degrees
degrees = range(degree_range[0], degree_range[1])
for degree in degrees:
print("Trying degree", degree, ":")
tx_tr, tx_te, tx_pred = expand(degree, glob_tx_tr, glob_tx_te, tx_sub)
initial_w = np.ones(tx_tr.shape[1])
w, loss = logistic_regression(glob_y_tr, tx_tr, initial_w, MAX_ITERS,
GAMMA)
print("\tTraining Loss = ", loss)
y_test = predict_labels(w, tx_te)
test_loss = compute_loss(glob_y_te, tx_te, w, func="logistic")
accuracy = compute_accuracy((y_test + 1) / 2, glob_y_te)
y_pred = predict_labels(w, tx_pred)
print("\tTest Loss = ", test_loss, " Test Accuracy = ", accuracy)
models.append(("logistic_SGD", degree, w))
losses.append(test_loss)
accuracies.append(accuracy)
predictions.append(y_pred)
return models, losses, accuracies, predictions
def main():
y_train, tX_train, ids = load_csv_data(DATA_TRAIN_PATH)
_, tX_test, ids_test = load_csv_data(DATA_TEST_PATH)
np.random.seed(2019)
# Preprocess data together to have the same shifts while creating log or root features
tX_stacked = np.vstack((tX_train, tX_test))
prep_param = {
"bias": True,
"fill": True,
"standardize": False,
"degree": 8,
"log": True,
"root": True
}
tX_stacked_prep, *_ = preprocess_data(tX_stacked, None, prep_param)
tX_train_prep, tX_test_prep = np.split(tX_stacked_prep, [len(tX_train)])
# Split data according to PRI_jet_num value
tX_tr_splitted, indices_tr = divide_data(tX_train_prep)
tX_te_splitted, indices_te = divide_data(tX_test_prep)
n_models = len(indices_tr)
y_tr_splitted = []
for i in range(n_models):
y_tr_splitted.append(y_train[indices_tr[i]])
# Train
weights = []
for i in range(n_models):
lambda_ = lambda_cv(tX_tr_splitted[i], y_tr_splitted[i])
print(f"Class {i}, lambda: {lambda_}")
weights.append(
ridge_regression(y_tr_splitted[i], tX_tr_splitted[i], lambda_)[0])
# Predict
y_pr_tr = np.zeros(tX_train.shape[0])
y_pr_te = np.zeros(tX_test.shape[0])
for i in range(n_models):
y_pr_tr[indices_tr[i]] = predict_labels(weights[i], tX_tr_splitted[i])
y_pr_te[indices_te[i]] = predict_labels(weights[i], tX_te_splitted[i])
acc_tr = compute_accuracy(y_train, y_pr_tr)
print(f"Total accuracy train: {acc_tr}")
_, counts = np.unique(y_pr_te, return_counts=True)
print(
f"Distribution on test data class -1: {counts[0]}, class +1: {counts[1]}"
)
create_csv_submission(ids_test, y_pr_te, OUTPUT_PATH)
def ridge_trials(y, tx, tx_sub, degree_range, lambda_range, partitions=2):
## Split data into test and training sets
## If partitions > 2, use k-fold cross-validation
glob_tx_tr, glob_tx_te, glob_y_tr, glob_y_te = split_data(tx, y, 0.8)
## Initial results: losses, weights, preditions and (test) losses
models = []
losses = []
accuracies = []
predictions = []
## Loops over range of degrees
degrees = range(degree_range[0], degree_range[1])
lambdas = np.logspace(lambda_range[0],
lambda_range[1],
num=1 + (lambda_range[1] - lambda_range[0]))
for degree in degrees:
## Loops over range of lambdas
for lambda_ in lambdas:
print("Trying degree", degree, "with lambda =", lambda_, ":")
tx_tr, tx_te, tx_pred = expand(degree, glob_tx_tr, glob_tx_te,
tx_sub)
w, loss = ridge_regression(glob_y_tr, tx_tr, lambda_)
print("\tTraining Loss = ", loss)
y_test = predict_labels(w, tx_te)
test_loss = compute_loss(glob_y_te, tx_te, w)
accuracy = compute_accuracy((y_test + 1) / 2, glob_y_te)
y_pred = predict_labels(w, tx_pred)
print("\tTest Loss = ", test_loss, " Test Accuracy = ", accuracy)
models.append(("ridge_regression", degree, lambda_, w))
losses.append(test_loss)
accuracies.append(accuracy)
predictions.append(y_pred)
return models, losses, accuracies, predictions
def train_ref(model,
criterion,
optimizer,
input,
target,
nb_epochs=200,
verbose=False):
mini_batch_size = 100
#empty recipient
loss_evolution = []
precision_evolution = []
#actual training
for e in range(nb_epochs):
loss_e = 0.
for b in range(0, input.size(0), mini_batch_size):
output = model(input.narrow(0, b, mini_batch_size))
loss = criterion(output, target.narrow(0, b, mini_batch_size))
loss_e += loss
model.zero_grad()
loss.backward()
optimizer.step()
#record the data
precision_evolution.append(
helpers.compute_accuracy(model, input, target) / target.shape[0] *
100)
loss_evolution.append(loss_e)
if verbose:
message = "epoch {:3}, loss {:10.4}".format(e, loss_e)
helpers.update_progress((e + 1.) / nb_epochs, message=message)
return loss_evolution, precision_evolution
model = -1
while model < 0 or model > 7:
model = input("Enter a valid number: ")
try:
model = int(model)
except ValueError:
model = -1
#Load the train and test data
print("Loading the data...")
y_tr, input_data_train, _ = load_csv_data("data/train.csv")
y_te, input_data_test, ids_test = load_csv_data("data/test.csv")
#Preprocess train and test data
print("Preprocessing the data...")
tx_tr = preprocess(input_data_train)
tx_te = preprocess(input_data_test)
#Compute the optimal weights
print("Computing the optimal weights...")
losses, optimal_weights = choose_model(y_tr, tx_tr, models[model], np.zeros(tx_tr.shape[1]), 500, 2e-6, 0.0008)
print("Test accuracy: ", compute_accuracy(y_te, tx_te, optimal_weights))
print("Training accuracy: ", compute_accuracy(y_tr, tx_tr, optimal_weights))
y_pred = predict_labels(optimal_weights, tx_te)
create_csv_submission(ids_test, y_pred, "submission.csv")
import torch
import torchvision
from Classifier import Classifier
from classes import classes
from helpers import show_image, compute_accuracy, get_test_set_and_loader
if __name__ == '__main__':
torch.multiprocessing.freeze_support()
_, test_loader = get_test_set_and_loader()
dataiter = iter(test_loader)
images, labels = dataiter.next()
show_image(torchvision.utils.make_grid(images))
print('GroundTruth: ',
' '.join('%5s' % classes[labels[j]] for j in range(4)))
classifier = Classifier()
classifier.load_state_dict(torch.load('./model_storage/cifar_net.pth'))
outputs = classifier(images)
_, predicted = torch.max(outputs, 1)
print('Predicted: ',
' '.join('%5s' % classes[predicted[j]] for j in range(4)))
compute_accuracy(test_loader, classifier)
for epoch in range(num_epoch):
nn_model.train()
loss_acc = 0
correct_samples = 0
total_samples = 0
for i_step, (x, y) in enumerate(train_loader):
prediction = nn_model(x)
loss_value = loss(prediction, y)
optimizer.zero_grad()
loss_value.backward()
optimizer.step()
_, indices = torch.max(prediction, 1)
correct_samples += torch.sum(indices == y)
total_samples += y.shape[0]
loss_acc += loss_value
ave_loss = loss_acc / (i_step + 1)
train_accuracy = 100 * float(correct_samples) / total_samples
val_accuracy = compute_accuracy(nn_model, val_loader)
loss_history.append(float(ave_loss))
train_history.append(train_accuracy)
val_history.append(val_accuracy)
print("Average loss: %f, Train accuracy: %f, Val accuracy: %f" %
(ave_loss, train_accuracy, val_accuracy))
#define optimizer
optim = Optimizer.SGD(parameters=model.param(), lr=1e-1)
#train the model
loss, accuracy = train(model,
criterion,
optim,
train_input,
train_target,
nb_epochs=200,
verbose=True)
#compute statistics on test
output = model.forward(test_input)
loss_test = criterion.forward(output, test_target)
accuracy_test = compute_accuracy(model.forward, test_input, test_target)
print("")
print("TRAIN: accuracy {:.4}%, loss {:.4}".format(accuracy[-1], loss[-1]))
print("TEST : accuracy {:.4}%, loss {:.4}".format(
accuracy_test / test_target.shape[0] * 100, loss_test))
#vizualisation
plt.subplot(121)
plt.plot(loss, label="loss", c="orange")
plt.legend()
plt.subplot(122)
plt.plot(accuracy, label="accuracy", c="blue")
plt.legend()
plt.savefig("../results/plots/test.png", bbox_inches="tight")
#plt.show()
k_indices = k_fold_indices(train_data_split.shape[0], 5, SEED)
for i, deg in enumerate(POSSIBLE_DEGREES):
train_data, _ = preprocessing_pipeline(train_data_split,
degree=deg)
train_set_folds = k_fold_cross_split_data(train_classes_split,
train_data, k_indices)
for j, lambda_ in enumerate(POSSIBLE_LAMBDA_VALUES):
folds_train_accuracy = []
folds_validation_accuracy = []
# Train a Ridge Regression model on each fold
for x_train, y_train, x_test, y_test in train_set_folds:
w, train_loss = ridge_regression(y_train, x_train, lambda_)
folds_train_accuracy.append(
compute_accuracy(predict_labels(w, x_train), y_train))
folds_validation_accuracy.append(
compute_accuracy(predict_labels(w, x_test), y_test))
train_accuracy_matrix[jet_num, 0, i, j] = \
(np.mean(folds_train_accuracy), np.std(folds_train_accuracy))
validation_accuracy_matrix[jet_num, 0, i, j] = \
(np.mean(folds_validation_accuracy), np.std(folds_validation_accuracy))
train_data_log_svm = preprocessing_pipeline(train_data_split,
degree=deg,
norm_first=False)
train_set_folds = k_fold_cross_split_data(train_classes_split,
train_data_log_svm,
k_indices)
for j, lambda_ in enumerate(POSSIBLE_LAMBDA_LOG):
