MINI MINI MANI MO
%
% Copyright (c) 2012, 2014, Oracle and/or its affiliates. All rights reserved.
%
\name{ore.neural}
\alias{ore.neural}
\alias{predict.ore.neural}
\alias{print.ore.neural}
\alias{coef.ore.neural}
\alias{summary.ore.neural}
\title{
Oracle R Enterprise - Mehrschichtige neuronale Feedforward-Netzmodelle
}
\description{
Erstellt mehrschichtige neuronale Feedforward-Netzmodelle mit
\code{ore.frame}-Daten.
}
\usage{
ore.neural(
formula,
data,
weight = NULL,
xlev = NULL,
hiddenSizes = NULL,
activations = NULL,
gradTolerance = 1E-1,
maxIterations = 200L,
objMinProgress = 1E-6,
lowerBound = -0.7,
upperBound = 0.7,
nUpdates = 20L,
scaleHessian = TRUE,
trace = getOption("ore.trace", FALSE))
## Specific methods for ore.neural objects
\method{predict}{ore.neural}(object, newdata, supplemental.cols = NULL, ...)
\method{print}{ore.neural}(x, ...)
\method{coef}{ore.neural}(object, ...)
\method{summary}{ore.neural}(object, ...)
}
\arguments{
\item{ formula }{
Ein \code{\link[stats]{formula}}-Objekt, das das neuronale
Netz für das Training darstellt.
}
\item{ data }{
Ein \code{ore.frame}-Objekt, das die Daten für das Modell angibt.
}
\item{ hiddenSizes }{
Ein ganzzahliger Vektor, dessen Elemente die Anzahl von
Neuronen in jeder verborgenen Schicht speichern soll. \code{ore.neural} unterstützt eine beliebige
Anzahl von verborgenen Schichten. Die Länge von \code{hiddenSizes} gibt die Anzahl von
verborgenen Schichten in dem Modell an, und \code{hiddenSizes[k]} speichert die Anzahl von
Neuronen in der \code{k}-ten verborgenen Schicht. Der \code{hiddenSizes}-Wert kann \code{NULL} sein.
In diesem Fall werden Eingabeeinheiten direkt mit den
Ausgabeneuronen verbunden (keine verborgene Struktur). Wenn ein Element von \code{hiddenSizes}
Null ist, werden alle verborgenen Neuronen gelöscht, was gleichbedeutend mit
\code{hiddenSizes=NULL} ist.
Beispiel: \code{hiddenSizes=c(10, 4)} gibt ein neuronales Netz mit zwei
verborgenen Schichten an (\code{length(hiddenSizes)} ist 2); die erste verborgene Schicht
enthält 10 Neuronen und die zweite 4.
Beispiel: \code{hiddenSizes=c(101, 20, 1)} gibt ein neuronales Netz mit drei
verborgenen Schichten mit jeweils 101, 20 bzw. 1 Einheiten an.
In einem typischen Trainingszenario (bei dem von keinen Vorkenntnissen des Modells
ausgegangen wird) können Sie mit einer einzelnen verborgenen Schicht und einer kleinen Anzahl
von verborgenen Neuronen beginnen (z.B. \code{hiddenSizes=1}). Sie können dann die Anzahl von Neuronen
(und möglicherweise Schichten) graduell erhöhen, bis keine weitere Fehlerreduzierung
mehr in dem Validierungsdataset beobachtet werden kann.
}
\item{ activations }{
Dieses Argument gibt die Aktivierungsfunktionen für die verborgenen
und ausgegebenen neuronales Netzschichten an. Die \code{ore.neural}-Funktion
unterstützt eine einzelne Aktivierungsfunktion pro Schicht. Neuronen werden in
Schichten gruppiert, und jeder Schicht (einer Teilmenge von Neuronen) kann ihre
eigene Aktivierungsfunktion zugewiesen werden. Hinweis: Der Zielvariablenbereich muss
dem Bereich der Ausgabeaktivierungsfunktion entsprechen. Beispiel: Die logistische Sigmoidfunktion
kann zur Modellierung von Zielen im Bereich von Null bis Eins (Bereich der
Sigmoidfunktion) verwendet werden. Die \code{ore.neural}-Funktion nimmt keine Vorverarbeitung der Eingabedaten vor;
eine entsprechende Datennormalisierung und Skalierung wird unbedingt empfohlen.
Wenn das \code{activations}-Argument \code{NULL} ist, ist die Aktivierungsfunktion für jede
verborgene Schicht die bipolare Sigmoidfunktion; für die Ausgabe wird die lineare Funktion verwendet.
Wenn \code{activations} nicht \code{NULL} ist, muss die Größe
\code{length(hiddenSizes) + 1} sein,
wobei das letzte Element der Ausgabeschicht entspricht.
Mögliche Werte:
\tabular{lll}{
\code{"atan"} \tab arctangent \tab \eqn{f(x) = \\arctan x }\cr
\code{"bSigmoid"} \tab bipolar sigmoid \tab \eqn{f(x) = \\frac{1 - e^{-x}}{1 + e^{-x}} }\cr
\code{"cos"} \tab cosine \tab \eqn{f(x) = \\cos x }\cr
\code{"gaussian"} \tab Gaussian \tab \eqn{f(x) = e^{-x^2} }\cr
\code{"gaussError"} \tab Gauss error \tab \eqn{f(x) = \\frac{2}{\\sqrt{\\pi}} \\int_0^x e^{-t^2} dt}\cr
\code{"gompertz"} \tab Gompertz \tab \eqn{f(x) = e^{-e^{-x}} }\cr
\code{"linear"} \tab linear \tab \eqn{f(x) = x }\cr
\code{"reciprocal"} \tab reciprocal \tab \eqn{f(x) = \\frac{1}{x} }\cr
\code{"sigmoid"} \tab logistic sigmoid \tab \eqn{f(x) = \\frac{1}{1 + e^{-x}} }\cr
\code{"sigmoidModulus"}\tab sigmoid modulus \tab \eqn{f(x) = \\frac{x}{1 + |x|} }\cr
\code{"sigmoidSqrt"} \tab sigmoid sqrt \tab \eqn{f(x) = \\frac{x}{\\sqrt{1 + x^2}} }\cr
\code{"sin"} \tab sine \tab \eqn{f(x) = \\sin x }\cr
\code{"square"} \tab square \tab \eqn{f(x) = x^2 }\cr
\code{"tanh"} \tab hyperbolic tangent\tab \eqn{f(x) = \\tanh x }\cr
\code{"wave"} \tab wave \tab \eqn{f(x) = \\frac{x}{1 + x^2} }\cr
\code{"entropy"} \tab entropy (output only) \tab \eqn{f(x) = \\log(1 + \\exp(x)) - yx }
}
Beispiel: \code{activations=c("wave", "tanh", "linear")} entspricht einem
neuronalen Netz mit zwei verborgenen Schichten. Die erste verborgene Schicht ist
der \code{"wave"}-Aktivierungsfunktion und die zweite verborgene Schicht der
\code{"tanh"}-Aktivierungsfunktion zugewiesen. Die Ausgabeschicht (Zielschicht) ist
\code{"linear"} zugewiesen.
}
\item{ gradTolerance }{
Stoppkriterium für numerische Optimierung: Gewünschte
Gradientennorm.
}
\item{ maxIterations }{
Stoppkriterium für numerische Optimierung: Maximale
Anzahl von Iterationen.
}
\item{ objMinProgress }{
Stoppkriterium für numerische Optimierung: Minimale
relative Änderung im Wert der objektiven Funktion.
}
\item{ nUpdates }{
Anzahl von L-BFGS-Aktualisierungspaaren.
}
\item{ scaleHessian }{
Angabe, ob der Kehrwert der Hesse-Matrix in
L-BFGS-Aktualisierungen skaliert werden soll.
}
\item{ lowerBound }{
Unterer Grenzwert der Gewichtungsinitialisierung (wird nicht verwendet, wenn
keine Gewichtungen angegeben werden).
}
\item{ upperBound }{
Oberer Grenzwert der Gewichtungsinitialisierung (wird nicht verwendet, wenn
keine Gewichtungen angegeben werden).
}
\item{ weight }{
Anfänglicher Gewichtungsvektor (kann NULL sein, in diesem Fall wird ein
zufälliger Ausgangspunkt generiert). Nützlich bei Verwendung einer Lösung
aus einem vorher aufgelösten Modell. Hinweis: Die vorherige neuronale
Netzarchitektur (Anzahl von Eingabe-, Ausgabe-, verborgenen Schichten und
verborgenen Neuronen in jeder Schicht und Typ der Aktivierungsfunktionen) muss identisch
mit der aktuellen Architektur sein.
}
\item{ xlev }{
Eine benannte \code{\link[base]{list}} von
\code{\link[base]{character}}-Vektoren, die die
\code{\link[base]{levels}} für jede
\code{\link[OREbase:ore.factor-class]{ore.factor}}-Variable angeben.
}
\item{ trace }{
Berichtiterationslog für den Big Data (out-of-core) Solver.
}
\item{ object, x }{
Ein \code{ore.neural}-Objekt.
}
\item{ newdata }{
Ein \code{ore.frame}-Objekt, Testdaten.
}
\item{ supplemental.cols }{
Zusätzliche Spalten, die in dem Vorhersageergebnis
aus dem \code{newdata}-Dataset einbezogen werden sollen.
}
\item{ \dots }{
Zusätzliche Argumente.
}
}
\value{
Ein Objekt der Klasse \code{"ore.neural"}. Einige der Komponenten sind:
\item{ weight }{ Gewichtungskoeffizienten. }
\item{ nLayers }{ Anzahl Schichten. }
}
\details{
Die \code{ore.neural}-Funktion löst mehrschichtige neuronale Feedforward-Netzwerkmodelle
auf. Sie unterstützt eine beliebige Anzahl von ausgeblendeten Schichten und eine
beliebige Anzahl von Neuronen pro Schicht. Der L-BFGS-Algorithmus wird zur Auflösung
des zugrunde liegenden uneingeschränkten nicht-linearen Optimierungsproblems verwendet.
Die globale \code{\link[OREbase:ore.options]{"ore.parallel"}}-Option wird von \code{ore.neural} verwendet, um den bevorzugten
Parallelitätsgrad zu bestimmen, der innerhalb des Oracle
R Enterprise-Servers verwendet werden soll.
}
\references{
Christopher Bishop (1996) \emph{Neural Networks for Pattern Recognition}
Simon Haykin (2008) \emph{Neural Networks and Learning Machines (3rd
Edition)}
Stephen Marsland (2009) \emph{Machine Learning: An Algorithmic Perspective}
\href{http://www.oracle.com/technetwork/database/database-technologies/r/r-enterprise/documentation/index.html}{Oracle R Enterprise}
}
\author{
Oracle \email{oracle-r-enterprise@oracle.com}
}
\seealso{
\link[OREstats]{model.matrix,formula-method} (\pkg{OREstats} package),
\code{\link[OREbase:ore.options]{ore.parallel}}
}
\examples{
###############################################################
# Two hidden layers (20 neurons in the first layer, 5 hidden #
# neurons in the second layer). #
# #
# Use bipolar sigmoid activation function for the first #
# hidden layer, hyperbolic tangent for the second hidden #
# layer, and linear activation function for the output layer. #
# #
# Note that the dimension (number of elements) of the #
# "activations" argument is always greater by exactly one #
# than the dimension of "hiddenSizes". #
# #
# Least-squares objective function. #
###############################################################
IRIS <- ore.push(iris)
fit <- ore.neural(Petal.Length ~ Petal.Width + Sepal.Length,
data = IRIS,
hiddenSizes = c(20L, 5L),
activations = c("bSigmoid", "tanh", "linear"))
ans <- predict(fit, newdata = IRIS,
supplemental.cols = c("Petal.Length"))
###############################################################
# Entropy objective function. #
###############################################################
INFERT <- ore.push(infert)
fit <- ore.neural(case ~ ., data = INFERT,
activations = c('entropy'), objMinProgress = 1E-7)
# Entropy (max likelihood) model with one hidden layer.
fit <- ore.neural(
formula = case ~ .,
data = INFERT,
hiddenSizes = c(40L),
activations = c("sigmoid", "entropy"),
lowerBound = -0.7,
upperBound = 0.7,
objMinProgress = 1E-12,
maxIterations = 300L)
}
\keyword{neural}
OHA YOOOO