Subsampling

This homework involves a lot of computation which means it might take a while for your code to run. This can make problem solving hard if you have to wait every time you want to run some code.

You might try writing the code using a smaller data set. When you get the code working you can then run it on the larger, original data set. The code below randomly samples 200 observations (out of the 1320) original observations).

# subsample the data
set.seed(8599)
train <- train[sample(x=1:dim(train)[1], size=200), ]

Use the subsampled data to get the code working (you can also subsample the test data). Once the code is working re-run it on the entire data set (which might take a while, but if your code works you should be able to just chill while it runs).

If the knn() function really takes a long time on your computer (e.g. a minute for one call to knn()) then you can hand in the assignment for the subsampled data.

KNN cross-validation

Recall in the lecture notes that using cross-validation we found that K = 1 is the “best” value for KNN on the Human Activity Recognition dataset. But is this truly the best value of K?

Let’s call the plot of error vs. K the tuning error curve (e.g. the plot in this section from the notes).

# use these k values for KNN
k_values <- seq(from=1, to= 41, by=2)

knn_tuning_error_plot <- function(train, test, k_cv, k_values, cv_seed=NA){
# Returns the tuning error plots for KNN with the three tuning error curves
    # train, CV, and test error
# train and test: are the train and test data
    # both are a data frame with the same column names
    # one column in named y which is the class labels
# k_cv: is the number of cross validation folds
# k_values: is the sequence of K values try for KNN
# cv_seed: is the seed for the cross validation folds
# returns a ggplot object    
    
    # set seed if it is given
    if(!is.na(cv_seed)){
        set.seed(cv_seed)
    }

    
    
    # p <- ggplot() + ...
    # return(p)
}

Q3: Nearest Centroid

Recall the nearest centroid classifer is a simple linear classifier.

3a. Write a function that implements the nearest centroid classifier. The function should take the training and test data as input and return the predictions on the test data set.

train_x <- train %>% select(-activity)
train_y <- train$activity


test_x <- test %>% select(-activity)
test_y <- test$activity

nearest_centroid <- function(train_x, train_y, test_x){
    # returns the predictions for nearest centroid on a test set
    # train_x and test_x: are the train/test x data
        # assume these are both numerical matrices with the same number of columns
    # train_y: is a vector of class labels for the training data
    # return a vector of predicted class labels for the test data
    
    
    # find number of test points
    n_test <- 
    
    # find unique class labels (hint: the unique() function)
    # you will designate one class the "positive" class and the
    # other class the "negative" class
    class_labels <- 
    
    # separate x training data by classes
    train_x_pos <- 
    train_x_neg <-
    
    # compute each class mean
    mean_pos <-
    mean_neg <-
    
    
    # you can EITHER use a for loop or the apply() function to compute the predictiosn
    # WARNING: on my computer a for loop took 45 seconds while apply() took .01 seconds
    ######## compute predictions with a for loop #########
    # initialize test prediciton vector
    test_y_pred <-
    
    # get prediciton for each test point
    for(i in 1:n_test){
        
        # grab one test point
        x <- 
        
        # compute the euclidean distance between the test point and each class mean
        dist_pos <-
        dist_neg <- 
        
        # decide which mean the test point is closer to and classify the test point to that class
        # you can either use an if/else statment or the ifelse() function
        test_y_pred[i] <-
    }
    
    # if you don't want to use apply() ignore this code
    ########### compute predictions with the apply function #############
    
    # use apply to compute the distance from each test point to the positive class mean
    # dist_pos <-
    
    # similarly for the negative class mean
    # dist_neg <- 
    
    # use the ifelse() function to compute the test predictions
    # test_y_pred <-
    
    ##############################################################################
        
    return(test_y_pred)
}


nearest_centroid(train_x, train_y, test_x)

You can write this function many different ways – if you do it another way than above that’s fine (as long as it works!).

You will get 3 bonus points on this assignment if you use the apply function. For example code using the apply() function see this section of the notes and/or read this tutorial.

3b. Using the nearest_centroid function compute the training and test set error for the Human Activity Recognition dataset.

Support Vector Machine

This questions examines how the “optimal” parameter values can change depending on how you do cross-validation and also compares linear SVM to radial SVM.

Let’s see how SVM does on the human activity recognition data: try linear SVM and kernel SVM with a radial kernel. Use the caret package to fit the SVM models for this section.

Hint: The code should be pretty similar to the lecture code, you mostly have to play around with the arguments to train.

C_values <- tibble(C=10^seq(from=-5, to=5, by=1))

# sigma values to use
sigma_values <- 10^seq(from=-5, to=5, by=1)

# hint: you need to use expand.grid to make a grid of sigma and C values.