# fnn.predict

0th

Percentile

##### Prediction using Functional Neural Networks

The prediction function associated with the fnn model allowing for users to quickly get scalar or functional outputs.

##### Usage
fnn.predict(
model,
func_cov,
scalar_cov = NULL,
basis_choice = c("fourier"),
num_basis = c(7),
domain_range = list(c(0, 1)),
covariate_scaling = TRUE,
raw_data = FALSE
)
##### Arguments
model

A keras model as outputted by fnn.fit().

func_cov

The form of this depends on whether the raw_data argument is true or not. If true, then this is a list of k matrices. The dimensionality of the matrices should be the same (n x p) where n is the number of observations and p is the number of longitudinal observations. If raw_data is false, then the input should be a tensor with dimensionality b x n x k where b is the number of basis functions used to define the functional covariates, n is the number of observations, and k is the number of functional covariates. Must be the same covariates as input into fnn.fit() although here, they will likely be the 'test' observations.

scalar_cov

A matrix contained the multivariate information associated with the data set. This is all of your non-longitudinal data. Must be the same covariates as input into fnn.fit() although here, they will likely be the 'test' observations.

basis_choice

A vector of size k (the number of functional covariates) with either "fourier" or "bspline" as the inputs. This is the choice for the basis functions used for the functional weight expansion. If you only specify one, with k > 1, then the argument will repeat that choice for all k functional covariates. Should be the same choices as input into fnn.fit().

num_basis

A vector of size k defining the number of basis functions to be used in the basis expansion. Must be odd for fourier basis choices. If you only specify one, with k > 1, then the argument will repeat that choice for all k functional covariates. Should be the same values as input into fnn.fit().

domain_range

List of size k. Each element of the list is a 2-dimensional vector containing the upper and lower bounds of the k-th functional weight. Must be the same covariates as input into fnn.fit().

covariate_scaling

If TRUE, then data will be internally scaled before model development.

raw_data

If TRUE, then user does not need to create functional observations beforehand. The function will internally take care of that pre-processing.

##### Value

The following is returned:

Predictions -- A vector of scalar predictions or a matrix of basis coefficients for functional responses.

• fnn.predict
##### Examples
# NOT RUN {
# First, we do an example with a scalar response:

tecator = FuncNN::tecator

# libraries
library(fda)

# define the time points on which the functional predictor is observed.
timepts = tecator$absorp.fdata$argvals

# define the fourier basis
nbasis = 29
spline_basis = create.fourier.basis(tecator$absorp.fdata$rangeval, nbasis)

# convert the functional predictor into a fda object and getting deriv
tecator_fd =  Data2fd(timepts, t(tecator$absorp.fdata$data), spline_basis)
tecator_deriv = deriv.fd(tecator_fd)
tecator_deriv2 = deriv.fd(tecator_deriv)

# Non functional covariate
tecator_scalar = data.frame(water = tecator$y$Water)

# Response
tecator_resp = tecator$y$Fat

# Getting data into right format
tecator_data = array(dim = c(nbasis, length(tecator_resp), 3))
tecator_data[,,1] = tecator_fd$coefs tecator_data[,,2] = tecator_deriv$coefs
tecator_data[,,3] = tecator_deriv2$coefs # Splitting into test and train for third FNN ind = 1:165 tec_data_train <- array(dim = c(nbasis, length(ind), 3)) tec_data_test <- array(dim = c(nbasis, nrow(tecator$absorp.fdata$data) - length(ind), 3)) tec_data_train = tecator_data[, ind, ] tec_data_test = tecator_data[, -ind, ] tecResp_train = tecator_resp[ind] tecResp_test = tecator_resp[-ind] scalar_train = data.frame(tecator_scalar[ind,1]) scalar_test = data.frame(tecator_scalar[-ind,1]) # Setting up network tecator_fnn = fnn.fit(resp = tecResp_train, func_cov = tec_data_train, scalar_cov = scalar_train, basis_choice = c("fourier", "fourier", "fourier"), num_basis = c(5, 5, 7), hidden_layers = 4, neurons_per_layer = c(64, 64, 64, 64), activations_in_layers = c("relu", "relu", "relu", "linear"), domain_range = list(c(850, 1050), c(850, 1050), c(850, 1050)), epochs = 300, learn_rate = 0.002) # Predicting pred_tec = fnn.predict(tecator_fnn, tec_data_test, scalar_cov = scalar_test, basis_choice = c("fourier", "fourier", "fourier"), num_basis = c(5, 5, 7), domain_range = list(c(850, 1050), c(850, 1050), c(850, 1050))) # Now an example with functional responses # libraries library(fda) # Loading data data("daily") # Creating functional data temp_data = array(dim = c(65, 35, 1)) tempbasis65 = create.fourier.basis(c(0,365), 65) tempbasis7 = create.bspline.basis(c(0,365), 7, norder = 4) timepts = seq(1, 365, 1) temp_fd = Data2fd(timepts, daily$tempav, tempbasis65)
prec_fd = Data2fd(timepts, daily$precav, tempbasis7) prec_fd$coefs = scale(prec_fd$coefs) # Data set up temp_data[,,1] = temp_fd$coefs
resp_mat = prec_fd$coefs # Non functional covariate weather_scalar = data.frame(total_prec = apply(daily$precav, 2, sum))

# Splitting into test and train
ind = 1:30
nbasis = 65
weather_data_train <- array(dim = c(nbasis, length(ind), 1))
weather_data_test <- array(dim = c(nbasis, ncol(daily$tempav) - length(ind), 1)) weather_data_train[,,1] = temp_data[, ind, ] weather_data_test[,,1] = temp_data[, -ind, ] scalar_train = data.frame(weather_scalar[ind,1]) scalar_test = data.frame(weather_scalar[-ind,1]) resp_train = t(resp_mat[,ind]) resp_test = t(resp_mat[,-ind]) # Running model weather_func_fnn <- fnn.fit(resp = resp_train, func_cov = weather_data_train, scalar_cov = scalar_train, basis_choice = c("bspline"), num_basis = c(7), hidden_layers = 2, neurons_per_layer = c(1024, 1024), activations_in_layers = c("sigmoid", "linear"), domain_range = list(c(1, 365)), epochs = 300, learn_rate = 0.01, func_resp_method = 1) # Getting Predictions predictions = fnn.predict(weather_func_fnn, weather_data_test, scalar_cov = scalar_test, basis_choice = c("bspline"), num_basis = c(7), domain_range = list(c(1, 365))) # Looking at predictions predictions # Classification Prediction # Loading data tecator = FuncNN::tecator # Making classification bins tecator_resp = as.factor(ifelse(tecator$y$Fat > 25, 1, 0)) # Non functional covariate tecator_scalar = data.frame(water = tecator$y$Water) # Splitting data ind = sample(1:length(tecator_resp), round(0.75*length(tecator_resp))) train_y = tecator_resp[ind] test_y = tecator_resp[-ind] train_x = tecator$absorp.fdata$data[ind,] test_x = tecator$absorp.fdata\$data[-ind,]
scalar_train = data.frame(tecator_scalar[ind,1])
scalar_test = data.frame(tecator_scalar[-ind,1])

# Making list element to pass in
func_covs_train = list(train_x)
func_covs_test = list(test_x)

# Now running model
fit_class = fnn.fit(resp = train_y,
func_cov = func_covs_train,
scalar_cov = scalar_train,
hidden_layers = 6,
neurons_per_layer = c(24, 24, 24, 24, 24, 58),
activations_in_layers = c("relu", "relu", "relu", "relu", "relu", "linear"),
domain_range = list(c(850, 1050)),
learn_rate = 0.001,
epochs = 100,
raw_data = TRUE,
early_stopping = TRUE)

# Running prediction
predict_class = fnn.predict(fit_class,
func_cov = func_covs_test,
scalar_cov = scalar_test,
domain_range = list(c(850, 1050)),
raw_data = TRUE)

# Rounding predictions (they are probabilities)
rounded_preds = ifelse(round(predict_class)[,2] == 1, 1, 0)

# Confusion matrix
# caret::confusionMatrix(as.factor(rounded_preds), as.factor(test_y))
# }
# NOT RUN {

# }

Documentation reproduced from package FuncNN, version 1.0, License: GPL-3

### Community examples

Looks like there are no examples yet.