perceptron | R Documentation |

An implementation of a perceptron—a single level neural network–=for classification. Given labeled data, a perceptron can be trained and saved for future use; or, a pre-trained perceptron can be used for classification on new points.

```
perceptron(
input_model = NA,
labels = NA,
max_iterations = NA,
test = NA,
training = NA,
verbose = getOption("mlpack.verbose", FALSE)
)
```

`input_model` |
Input perceptron model (PerceptronModel). |

`labels` |
A matrix containing labels for the training set (integer row). |

`max_iterations` |
The maximum number of iterations the perceptron is to be ru. Default value "1000" (integer). |

`test` |
A matrix containing the test set (numeric matrix). |

`training` |
A matrix containing the training set (numeric matrix). |

`verbose` |
Display informational messages and the full list of parameters and timers at the end of execution. Default value "getOption("mlpack.verbose", FALSE)" (logical). |

This program implements a perceptron, which is a single level neural network. The perceptron makes its predictions based on a linear predictor function combining a set of weights with the feature vector. The perceptron learning rule is able to converge, given enough iterations (specified using the "max_iterations" parameter), if the data supplied is linearly separable. The perceptron is parameterized by a matrix of weight vectors that denote the numerical weights of the neural network.

This program allows loading a perceptron from a model (via the "input_model" parameter) or training a perceptron given training data (via the "training" parameter), or both those things at once. In addition, this program allows classification on a test dataset (via the "test" parameter) and the classification results on the test set may be saved with the "predictions" output parameter. The perceptron model may be saved with the "output_model" output parameter.

A list with several components:

`output_model` |
Output for trained perceptron model (PerceptronModel). |

`predictions` |
The matrix in which the predicted labels for the test set will be written (integer row). |

mlpack developers

```
# The training data given with the "training" option may have class labels as
# its last dimension (so, if the training data is in CSV format, labels
# should be the last column). Alternately, the "labels" parameter may be
# used to specify a separate matrix of labels.
#
# All these options make it easy to train a perceptron, and then re-use that
# perceptron for later classification. The invocation below trains a
# perceptron on "training_data" with labels "training_labels", and saves the
# model to "perceptron_model".
## Not run:
output <- perceptron(training=training_data, labels=training_labels)
perceptron_model <- output$output_model
## End(Not run)
# Then, this model can be re-used for classification on the test data
# "test_data". The example below does precisely that, saving the predicted
# classes to "predictions".
## Not run:
output <- perceptron(input_model=perceptron_model, test=test_data)
predictions <- output$predictions
## End(Not run)
# Note that all of the options may be specified at once: predictions may be
# calculated right after training a model, and model training can occur even
# if an existing perceptron model is passed with the "input_model" parameter.
# However, note that the number of classes and the dimensionality of all
# data must match. So you cannot pass a perceptron model trained on 2
# classes and then re-train with a 4-class dataset. Similarly, attempting
# classification on a 3-dimensional dataset with a perceptron that has been
# trained on 8 dimensions will cause an error.
```

Embedding an R snippet on your website

Add the following code to your website.

For more information on customizing the embed code, read Embedding Snippets.