Unerwartete Ausgabe während der Verwendung von 'neuralnet" in R

Ich bin mit der neuralnet Paket R für die Vorhersage von hand geschriebene Ziffern. MNIST-Datenbank verwendet wird für die Ausbildung und Prüfung dieses Algorithmus. Hier ist die R code, den ich verwendet:

# Importing the data into R
path <- "path_to_data_folder/MNIST_database_of_handwritten_digits/"  # Data can be downloaded from: http://yann.lecun.com/exdb/mnist/
to.read = file(paste0(path, "train-images-idx3-ubyte"), "rb")
to.read_Label = file(paste0(path, "train-labels-idx1-ubyte"), "rb")
magicNumber <- readBin(to.read, integer(), n=1, endian="big")
magicNumber_Label <- readBin(to.read_Label, integer(), n=1, endian="big")
numberOfImages <- readBin(to.read, integer(), n=1, endian="big")
numberOfImages_Label <- readBin(to.read_Label, integer(), n=1, endian="big")
rowPixels <- readBin(to.read, integer(), n=1, endian="big")
columnPixels <- readBin(to.read, integer(), n=1, endian="big")

# image(1:rowPixels, 1:columnPixels, matrix(readBin(to.read, integer(), n=(rowPixels*columnPixels), size=1, endian="big"), rowPixels, columnPixels)[,columnPixels:1], col=gray((0:255)/255))

trainDigits <- NULL
trainDigits <- vector(mode="list", length=numberOfImages)
for(i in 1:numberOfImages)
  trainDigits[[i]] <- as.vector(matrix(readBin(to.read, integer(), n=(rowPixels*columnPixels), size=1, endian="big"), rowPixels, columnPixels)[,columnPixels:1])

trainDigits <- t(data.frame(trainDigits))  # Takes a minute
trainDigits <- data.frame(trainDigits, row.names=NULL)

# i <- 1  # Specify the image number to visualize the image
# image(1:rowPixels, 1:columnPixels, matrix(trainDigits[i,], rowPixels, columnPixels), col=gray((0:255)/255))

trainDigits_Label <- NULL
for(i in 1:numberOfImages_Label)
  trainDigits_Label <- c(trainDigits_Label, readBin(to.read_Label, integer(), n=1, size=1, endian="big"))

# appending the labels to the training data
trainDigits <- cbind(trainDigits, trainDigits_Label)

#################### Modelling ####################

library(neuralnet)
# Considering only 500 rows for training due to time and memory constraints
myNnet <- neuralnet(formula = as.formula(paste0("trainDigits_Label ~ ", paste0("X",1:(ncol(trainDigits)-1), collapse="+"))),
                                data = trainDigits[1:500,], hidden = 10, algorithm='rprop+', learningrate=0.01)

#################### Test Data ####################

to.read_test = file(paste0(path, "t10k-images-idx3-ubyte"), "rb")
to.read_Label_test = file(paste0(path, "t10k-labels-idx1-ubyte"), "rb")
magicNumber <- readBin(to.read_test, integer(), n=1, endian="big")
magicNumber_Label <- readBin(to.read_Label_test, integer(), n=1, endian="big")
numberOfImages_test <- readBin(to.read_test, integer(), n=1, endian="big")
numberOfImages_Label_test <- readBin(to.read_Label_test, integer(), n=1, endian="big")
rowPixels <- readBin(to.read_test, integer(), n=1, endian="big")
columnPixels <- readBin(to.read_test, integer(), n=1, endian="big")

testDigits <- NULL
testDigits <- vector(mode="list", length=numberOfImages_test)
for(i in 1:numberOfImages_test)
  testDigits[[i]] <- as.vector(matrix(readBin(to.read_test, integer(), n=(rowPixels*columnPixels), size=1, endian="big"), rowPixels, columnPixels)[,columnPixels:1])

testDigits <- t(data.frame(testDigits))  # Takes a minute
testDigits <- data.frame(testDigits, row.names=NULL)

testDigits_Label <- NULL
for(i in 1:numberOfImages_Label_test)
  testDigits_Label <- c(testDigits_Label, readBin(to.read_Label_test, integer(), n=1, size=1, endian="big"))

#################### 'neuralnet' Predictions ####################

predictOut <- compute(myNnet, testDigits)
table(round(predictOut$net.result), testDigits_Label)

#################### Random Forest ####################
# Cross-validating NN results with Random Forest

library(randomForest)
myRF <- randomForest(x=trainDigits[,-ncol(trainDigits)], y=as.factor(trainDigits_Label), ntree=100)

predRF <- predict(myRF, newdata=testDigits)
table(predRF, testDigits_Label)  # Confusion Matrix
sum(diag(table(predRF, testDigits_Label)))/sum(table(predRF, testDigits_Label))  # % of correct predictions

60.000 training Bilder (28*28 pixel-Bilder) und die Ziffern 0 bis 9 verteilt sind (fast) gleichmäßig auf den gesamten Datenbestand. Anders als in der 'Modellierung' Teil oben, wo ich nur 500 Bilder, die ich verwendet, der gesamte Trainings-Datensatz zum trainieren myNnet Modell (28*28=784 Eingänge und 10 Ausgänge) und dann vorausgesagt, dass die Ausgabe der 10.000 Bilder in der test-Datensatz. (Ich habe nur 10 Neuronen in der versteckten Schicht aufgrund von Speichermangel.)

Die Ergebnisse habe ich erhalten mit der Vorhersage sind seltsam: der Ausgang war so eine Art GAUSS-Verteilung, wo 4 wurde vorhergesagt und die Vorhersagen zwischen 0 und 9 aus 4 verringert (Art der) exponentiell. Sie können sehen, die Verwirrung, die matrix unten (ich abgerundet werden die Ausgänge, da waren Sie nicht ganze zahlen):

> table(round(predictOut$net.result), testDigits_Label)
    testDigits_Label
       0   1   2   3   4   5   6   7   8   9
  -2   1   1   4   1   1   3   0   4   1   2
  -1   8  17  12   9   7   8   8  12   7  10
  0   38  50  44  45  35  28  36  40  30  39
  1   77 105  86  80  71  69  68  75  67  77
  2  116 163 126 129 101  97 111 101  99 117
  3  159 205 196 174 142 140 153 159 168 130
  4  216 223 212 183 178 170 177 169 181 196
  5  159 188 150 183 183 157 174 176 172 155
  6  119 111 129 125 143 124 144 147 129 149
  7   59  53  52  60  74  52  51  91  76  77
  8   22  14  18  14  32  36  28  38  35  41
  9    6   5   3   7  15   8   8  16   9  16

Dachte ich, es muss etwas falsch mein Ansatz, also habe ich versucht Vorhersagen unter Verwendung der randomForest Paket R. Aber randomForest fein gearbeitet, was einer Genauigkeit von mehr als 95%. Hier ist die confusion-matrix der randomForest Vorhersagen:

> table(predRF, testDigits_Label)
      testDigits_Label
predRF    0    1    2    3    4    5    6    7    8    9
     0  967    0    6    1    1    7   11    2    5    5
     1    0 1123    0    0    0    1    3    7    0    5
     2    1    2  974    9    3    1    3   25    4    2
     3    0    3    5  963    0   21    0    0    9   10
     4    0    0   12    0  940    1    4    2    7   15
     5    4    0    2   16    0  832    6    0   11    4
     6    6    5    5    0    7   11  929    0    3    2
     7    1    1   14    7    2    2    0  979    4    6
     8    1    1   12    7    5   11    2    1  917   10
     9    0    0    2    7   24    5    0   12   14  950

  • Frage 1: ja, kann jemand bitte erklären Sie mir, warum ist neuralnet dass dieses seltsame Verhalten mit diesem dataset? (BTW, neuralnet war in Ordnung arbeiten mit iris dataset, wenn ich überprüft).

    • EDIT: ich glaube, ich Verstand den Grund für die Gaußsche Art der Verteilung in die Ausgabe, wenn neuralnet verwendet wird. Es gibt nur ein output-Knoten (oder ist es ein neuron?) statt einen Knoten für die einzelnen output-Klasse (die 10-Klassen hier), wenn neuralnet verwendet wird. Also, bei der Berechnung der delta für back-propagation berechnet der Algorithmus die Differenz der 'erwartete Ausgabe' auf 'berechnete Ausgabe", die auf die Aggregation für alle Instanzen wird zumindest für jene Fälle, wo der Ausgang ist entweder 4 oder 5.Unerwartete Ausgabe während der Verwendung von 'neuralnet Also, die GEWICHTE werden angepasst, während der back-propagation in der Weise, dass der Ausgang error wird minimiert. Dieses "könnte" der Grund für die Gaußsche Art von Ausgabe, die von neuralnet.

  • Frage 2: Und ich möchte auch wissen, wie dies zu korrigieren Verhalten neuralnet bekommen und Vorhersagen, die auf Augenhöhe mit den randomForest Ergebnisse.

InformationsquelleAutor StrikeR | 2014-02-17
  1. 10

    Einige vorläufige Beratung, Sie können laden Sie Ihre Daten wie diese, die ein wenig mehr effizient:

    # Read in data.
trainDigits <- replicate(numberOfImages,c(matrix(readBin(to.read, integer(), n=(rowPixels*columnPixels), size=1, endian="big"),rowPixels,columnPixels)[,columnPixels:1]))
trainDigits <- data.frame(t(trainDigits),row.names=NULL)
trainDigits_Label<-replicate(numberOfImages,readBin(to.read_Label, integer(), n=1, size=1, endian="big"))

    Ihre erste problem ist, dass Sie nicht angegeben haben, eine multiclass Vorhersage neuralnet. Was Sie Taten, war die Vorhersage eine reelle Zahl von 0 bis 9. Das ist, warum es war nur eine Ausgabe, statt 10 Vorhersagen.

    Wenn man sich in ?neuralnet es ist ein Beispiel für eine multiclass Vorhersage; du musst jede Klasse in eine separate variable, und legen Sie es auf der linken Seite des formula. Andere Pakete, wie nnet, erkennt automatisch eine factor - und dies für Sie tun. Sie können die classInd Funktion split ein Faktor in mehreren Variablen:

    # appending the labels to the training data
output <- class.ind(trainDigits_Label)
colnames(output)<-paste0('out.',colnames(output))
output.names<-colnames(output)
input.names<-colnames(trainDigits)
trainDigits<-cbind(output,trainDigits)

    Jetzt können Sie fügen Sie zusammen eine Formel:

    # Considering only 500 rows
trainsize=500
# neuralnet:::varify.variables (sic) does not pass "data" when calling "terms".
# If it did, you wouldn't have to construct the formula like this.
library(neuralnet)
myNnet <- neuralnet(formula = paste(paste(output.names,collapse='+'),'~',
                              paste(input.names,collapse='+')),
                    data = trainDigits[1:trainsize,],
                    hidden = 10, 
                    algorithm='rprop+', 
                    learningrate=0.01,
                    rep=1)

    Die Korrektur noch nicht dazu, dass das neuronale Netz auch durchführen zu können. Um eine Idee zu bekommen, wie schlecht das neuronale Netzwerk ansieht, wie es sich verhält auf die Trainingsdaten. Es sollte ziemlich gut sein, weil es gesehen hat, alle diese Daten vor:

    # Accuracy on training data
res<-compute(myNnet,trainDigits[1:trainsize,input.names])
picks<-(0:9)[apply(res$net.result,1,which.max)]
prop.table(table(trainDigits_Label[1:trainsize] == picks))
# FALSE  TRUE 
# 0.376 0.624

    Einer Genauigkeit von 62% ist schrecklich auf den Trainingsdaten. Wie Sie vielleicht erwarten, es führt zu kaum mehr als zufällig auf den rest der Daten:

    # Accuracy on test data
res<-compute(myNnet,trainDigits[(trainsize+1):60000,input.names])
picks<-(0:9)[apply(res$net.result,1,which.max)]
prop.table(table(trainDigits_Label[(trainsize+1):60000] == picks))
# FALSE         TRUE 
# 0.8612268908 0.1387731092 
# 14% accuracy

    Random forest funktioniert erstaunlich gut mit den exakt gleichen Daten. Es gibt einen guten Grund, warum es so populär geworden in letzter Zeit.

    trainsize=500
library(randomForest)
myRF <- randomForest(trainDigits_Label~.,
                     data=data.frame(trainDigits_Label=as.factor(trainDigits_Label),
                                     trainDigits[input.names])[1:trainsize,],
                     ntree=100)

# Train
p <- as.numeric(as.character(predict(myRF)))
prop.table(table(trainDigits_Label[1:trainsize]==p))
# Accuracy: 79%    

# Test
p <- as.numeric(as.character(predict(myRF,trainDigits[(trainsize+1):60000,])))
prop.table(table(trainDigits_Label[(trainsize+1):60000]==p))
# Accuracy: 76%

    So, Ihre zweite Frage, meine Gegenfrage ist: warum würden Sie erwarten, dass das neuronale Netzwerk zu tun, sowie random forest? Sie haben vielleicht einige vage strukturelle ähnlichkeiten, aber die Montage-Prozess ist ganz anders. Ich denke, man könnte pore über die Knoten des neuronalen Netzes und vergleichen Sie mit der wichtigsten Variablen in der random-forest-Modell. Aber an diesem Punkt, es ist eher eine statistische Frage als eine Programmierung ein.

    • Vielen Dank für die Einblicke, wie neuralnet für multi-class classification. Ja, es ist sehr interessant zu sehen, wie die RF so einfachen Algorithmus in der Lage, so gut auf diese Aufgabe. Bezüglich deiner Gegenfrage, ich sehe neuronale Netze werden, einen Algorithmus so mächtig, dass Sie lernen, zu erkennen, jede Art von Muster, die werden kaum von anderen ML-algorithmen. Sogar im Falle von einfachen mustern, ich erwartet, dass neuronale Netzwerke einstellen würden, seine GEWICHTE in einer solchen Weise, dass es imitieren das Verhalten anderer algorithmen, die erkennen würde, diese Muster.
    • Ich bin damit einverstanden, dass neuronale Netze flexible, und dies kann es Ihnen ermöglichen, sich Muster erkennen, ungesehen von anderen Maschinen. Aber das bedeutet nicht, dass Sie mehr leistungsstarke; die Flexibilität macht Sie härter, um zu passen, einfacher für Sie zu get gefangen in lokalen minima, und eher overfit, um Trainingsdaten (wie in diesem Fall).
    InformationsquelleAutor nograpes
Schreibe einen Kommentar