I'm trying to evaluate the residual normality for three objects: one lm() object, one nnet() and one randomForest(). For lm() using the code:
> qqnorm(rstudent(lmodel)); qqline(rstudent(lmodel))"
it worked fine. But for nnet() and RandomForest() I had no success:
> Error in UseMethod("rstudent") :
no applicable method for 'rstudent' applied to an object of class "nnet"
Does somebody have some suggestion to deal with this issue?
rstudent is a so called generic function, this means that rstudent will call a different function for different input objects. In computer science this is known as polymorphism, i.e. rstudent is a polymorphic function. For example, rstudent(lm()) will trigger the function rstudent.lm.
These specific implementation of the generic function need to be written for every object type the function supports, and are not automagically generated. The error you get indicates that there is no specific implementation of rstudent for the output of your neural net function, i.e. No rstudent.nnet.
The solution is to write this specific implementation yourself, or propose its implementation to the package maintainer.
Related
It often seems to be the case that R packages contain multiple functions that create an object of some class, specified by the package, with generic or non-generic methods that apply to all objects of that class. Although it is generally easy to find out about the functions in a package, I have not found any equally straightforward way to find a precise description of the class itself for S3 classes. I think this is at least partly intentional. Class definitions may be regarded as the sort of internal workings that, on one hand, the user should not have to think about, and on the other, may be changeable by the package creator, who wants people not to rely on them.
However, I find that I sometimes want to create additional objects of the same class that work with the package functions that are methods for that class. And it is not always easy to deduce what features an object must have in order to be usable by package functions that do various things to objects of that class, especially as instances created by different functions may or may not all have exactly the same structure.
The example with which I am currently wrestling are forecast objects created by various functions of the forecast package. The forecast package provides a large number of functions that take forecast objects as inputs. This blog post by Rob Hyndman describes a function to do cross validation and requires an object of class forecast as an argument The tsCV function documentation says it takes a "forecastFunction" as an argument, which must return an object of class forecast and have a univariate time series as its first object (of forecasts, one assumes) and have an argument h giving the horizon. Well, that sounds easy enough. But then in Hyndman’s associated textbook, section 3.6, we are told that forecast objects contain information about the forecasting method, the data, the point forecasts, prediction intervals, residuals, and fitted values. That’s a lot of things, and I am not sure if they are all mandatory or if some are optional, or required only if you intend to use certain methods. And I don’t know anything about mandatory internal structure of the class.
Finally, I particularly want to know if the new fable package, intended as a forecast package replacement, uses the same forecast class mechanism and require the same internal structure., or if not, how they are different. I have not been able to find, in fpp3 or elsewhere, anything that either describes a change or contains a comparable description of objects of class forecast.
I’m going to be embarrassed if there is some simple function,
you_should_know_this_dummy(package = “forecast”, class = “forecast”),
that returns a detailed description of the class. But I have looked for such a function every way I could think of and not found it.
O.K., my bad. I was trying so hard to find a way of locating the help file for the class description (which I don't think exists) that I overlooked the existence of a pretty good description of the class forecast under the function forecast() in the manual for the package forecast. Here it is:
An object of class "forecast" is a list usually containing at least the following elements:
model A list containing information about the fitted model
method The name of the forecasting method as a character string
mean Point forecasts as a time series
lower Lower limits for prediction intervals
upper Upper limits for prediction intervals
level The confidence values associated with the prediction intervals
x The original time series (either object itself or the time series used to create the model stored as object).
residuals Residuals from the fitted model. For models with additive errors, the residuals will be x minus the fitted values.
fitted Fitted values (one-step forecasts)
This still leaves some questions unanswered, like the format for the model information argument model, and for the x argument with multivariate models. But I am hoping that these are similar to those handed to or returned by, e.g., lm(). I think this gives me enough to get started and to hope for informative errors.
I still don't know if the fable package also uses objects of class forecast. The forecast package documents the forecast() function as a generic. The fable package does not document the generic, though it has a very similar list of functions that look like methods, e.g., forecast.whatever. If I figure out the answer, I'll post it here.
I am also looking for a number of other package that provide time series forecast of particular types. I'm hoping that they provide output similar enough that I can use the forecast/fable functions for display, cross-validation, and so forth. We'll see.
I've got a gbm object and I want to use it from C++. For example, use the predict.gbm() in C++ with new data. At first I tried to translate the if-else rule in C++ and just output the tree to a file. However, I found that the gbm result doesn't match the tree it generates. For example, when I use just the first tree, the SplitCodePred value in the tree doesn't match the value generated by predict.gbm(). So anybody knows how to do the prediction manually based on the gbm model?
See my answer to your question on Cross Validated.
In short, you should be able to call e.g. gbm_pred directly from the C/C++ source. The source is available here. You can see how the gbm output object is mapped onto the arguments for gbm_pred in the R function predict.gbm.
I'm attempting to run a cv DFA on a set of species X site data (species are columns, sites are rows) with a grouping row named "ZONE".
I'm using a stock script I've successfully used before, but now I'm getting a new error from the predict function that I can't make heads or tails of.
My code is simply:
data2.lda<-lda(ZONE~SP1+SP2+SP3+SP4+SP5+SP6+SP7+SP8+SP9+SP10+SP11+SP12+SP13+SP14+SP15
,data=data2.x, Cna.action="na.omit",CV=TRUE)
list(data2.lda)
data2.lda.p<-predict(data2.lda,newdata=data2.lda.x(,c[2:17]))$class
data2.lda.p
the error I receive is:
Error in UseMethod("predict") :
no applicable method for 'predict' applied to an object of class "list"
My data are in the same form as previous uses of this code.
Where did I go wrong?
Any help is appreciated, thanks!
UPDATE: I've figured out that the issue involves the cross validation portion of the code. Are there additional rules for cross validating an LDA that I'm missing when it comes to coding in R?
Your problem is that predict requires a model object for its first argument. When you run lda with the CV=T option, it returns a list object not a model object. The lda documentation says
If CV = TRUE the return value is a list with components class, the MAP
classification (a factor), and posterior, posterior probabilities for
the classes.
Otherwise it is an object of class "lda" containing the
following components:
As per PCantalupo's answer, I managed to arrive at my goal. The cross validation procedure needs to be applied during the predict model, not the original model. The functional code is:
data2.lda<-lda(ZONE~SP1+SP2+SP3+SP4+SP5+SP6+SP7+SP8+SP9+SP10+SP11+SP12+SP13+SP14+SP15
,data=data2.x, Cna.action="na.omit")
list(data2.lda)
data2.lda.p<-predict(data2.lda,CV=TRUE,newdata=data1[c(2:17)])$class
data2.lda.p
tab<-table(data2.lda.p,data2[,1])
tab
summary(table(data2.lda.p,data2[,1]))
diag(prop.table(tab,1))
sum(diag(prop.table(tab)))
I need to see the code for the summary function which is used in mirt package to see the factor loading matrix.
I have tried edit(summary) which in return giving me this
function (object, ...)
standardGeneric("summary")
which is not very helpful for me. How can I see the code for summary?
summary is a generic function. So you need to see the class-specific method for whatever type of object you're trying to summary-ize. E.g., see summary.lm (for lm objects). You don't specify the object class you're working with, so it's impossible to say what specific summary function you need to look at.
UPDATE: These are s4 generics, which is a bit more complicated than summary.lm, which is s3. Some quick googling reveals that you can see the relevant s4 methods on the package's Github page. The contents of summary will depend on what specific class you're looking at (and there appear to be four classes in the package):
Exploratory
Mixed
Confirmatory
MultipleGroup
This question and answer will also be helpful for addressing these kinds of questions in general in the future.
I am using caret package for R to select variables for my model. When using rfe command, one should pass rfeControl object, which has a method parameter. Options for this parameter are boot, cv, LOOCV and LGOCV. Since I am dealing with time series data I need to use special bootstrapping/cross-validation techniques as normal ones do not apply for time series data (otherwise distributions get corrupted etc.).
My question is how would I plug-in my own implementation of bootstrapping but still use caret rfe method, which has every other thing I need.
There isn't an easy way. If you study the code for rfe.default() you will note that in cases where method = "boot" the createResample() function is used. This is the function that generates the bootstrap samples. Similar functions are used for the other CV methods.
There is a hard way; overtake the create*() function that is most appropriate; say you want to do a block bootstrap or ME bootstrap, take over the createResample() function and use method = "boot", or if you want a special form of CV, use method = "cv" and take over createFolds().
You will need to write your own create*() function and replace the one in the caret NAMESPACE with your version. Not easy but eminently doable. Say you write your own createResample() function; first you need to note that this function creates n = times bootstrap samples returning this in a matrix with times columns and as many rows as your have samples. You need to write a custom createResample() function that returns the same object but which performs the time series bootstrapping you want to employ.
Once you have written that function you then need to get it into the caret namespace so that it is used by functions in the caret package. For this you use assignInNamespace(). Say your new bootstrapping function is called createMyResample() and it is your workspace, to insert this into the caret namespace do:
assignInNamespace("createResample", createMyResample, ns = "caret")
Sorry I can't be more specific but you don't say how you want the bootstrap/CV to be performed nor what R code you want to use to do the resampling. If you provide further details on how you would do the resampling I will take another look and see if I can help you write your create*() function.
Failing all of this, contact Max Kuhn, the author and maintainer of caret; he may be able to advice further or at least you can suggest this feature as a wish-list for a future version.