Repository: incubator-systemml Updated Branches: refs/heads/master 43c321d18 -> 2a4e4f8b3
[MINOR] Naming updates in the MNIST LeNet & softmax examples, and README fix. Project: http://git-wip-us.apache.org/repos/asf/incubator-systemml/repo Commit: http://git-wip-us.apache.org/repos/asf/incubator-systemml/commit/2a4e4f8b Tree: http://git-wip-us.apache.org/repos/asf/incubator-systemml/tree/2a4e4f8b Diff: http://git-wip-us.apache.org/repos/asf/incubator-systemml/diff/2a4e4f8b Branch: refs/heads/master Commit: 2a4e4f8b30fce0ea8a4a6cfec9c0cced377534ad Parents: 43c321d Author: Mike Dusenberry <mwdus...@us.ibm.com> Authored: Wed Apr 26 15:32:25 2017 -0700 Committer: Mike Dusenberry <mwdus...@us.ibm.com> Committed: Wed Apr 26 15:32:25 2017 -0700 ---------------------------------------------------------------------- scripts/nn/README.md | 2 +- scripts/nn/examples/mnist_lenet-train.dml | 12 ++++----- scripts/nn/examples/mnist_lenet.dml | 34 ++++++++++++------------ scripts/nn/examples/mnist_softmax-train.dml | 12 ++++----- scripts/nn/examples/mnist_softmax.dml | 34 ++++++++++++------------ 5 files changed, 47 insertions(+), 47 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/incubator-systemml/blob/2a4e4f8b/scripts/nn/README.md ---------------------------------------------------------------------- diff --git a/scripts/nn/README.md b/scripts/nn/README.md index b80f2c6..3943765 100644 --- a/scripts/nn/README.md +++ b/scripts/nn/README.md @@ -22,7 +22,7 @@ limitations under the License. ### A deep learning library for [Apache SystemML](https://github.com/apache/incubator-systemml). ## Examples: -#### Please see the [`examples`](nn/examples) folder for more detailed examples, or view the following two quick examples. +#### Please see the [`examples`](examples) folder for more detailed examples, or view the following two quick examples. ### Neural net for regression with vanilla SGD: ```python # Imports http://git-wip-us.apache.org/repos/asf/incubator-systemml/blob/2a4e4f8b/scripts/nn/examples/mnist_lenet-train.dml ---------------------------------------------------------------------- diff --git a/scripts/nn/examples/mnist_lenet-train.dml b/scripts/nn/examples/mnist_lenet-train.dml index 0fc733e..5064eab 100644 --- a/scripts/nn/examples/mnist_lenet-train.dml +++ b/scripts/nn/examples/mnist_lenet-train.dml @@ -81,7 +81,7 @@ out_dir = ifdef($out_dir, ".") images = train[,2:ncol(train)] labels = train[,1] X_test = test[,2:ncol(test)] -y_test = test[,1] +Y_test = test[,1] # Scale images to [-1,1], and one-hot encode the labels n = nrow(train) @@ -89,16 +89,16 @@ n_test = nrow(test) images = (images / 255.0) * 2 - 1 labels = table(seq(1, n), labels+1, n, 10) X_test = (X_test / 255.0) * 2 - 1 -y_test = table(seq(1, n_test), y_test+1, n_test, 10) +Y_test = table(seq(1, n_test), Y_test+1, n_test, 10) # Split into training (55,000 examples) and validation (5,000 examples) X = images[5001:nrow(images),] X_val = images[1:5000,] -y = labels[5001:nrow(images),] -y_val = labels[1:5000,] +Y = labels[5001:nrow(images),] +Y_val = labels[1:5000,] # Train -[W1, b1, W2, b2, W3, b3, W4, b4] = mnist_lenet::train(X, y, X_val, y_val, C, Hin, Win, epochs) +[W1, b1, W2, b2, W3, b3, W4, b4] = mnist_lenet::train(X, Y, X_val, Y_val, C, Hin, Win, epochs) # Write model out write(W1, out_dir+"/W1") @@ -112,7 +112,7 @@ write(b4, out_dir+"/b4") # Eval on test set probs = mnist_lenet::predict(X_test, C, Hin, Win, W1, b1, W2, b2, W3, b3, W4, b4) -[loss, accuracy] = mnist_lenet::eval(probs, y_test) +[loss, accuracy] = mnist_lenet::eval(probs, Y_test) # Output results print("Test Accuracy: " + accuracy) http://git-wip-us.apache.org/repos/asf/incubator-systemml/blob/2a4e4f8b/scripts/nn/examples/mnist_lenet.dml ---------------------------------------------------------------------- diff --git a/scripts/nn/examples/mnist_lenet.dml b/scripts/nn/examples/mnist_lenet.dml index e5755c4..986d797 100644 --- a/scripts/nn/examples/mnist_lenet.dml +++ b/scripts/nn/examples/mnist_lenet.dml @@ -33,8 +33,8 @@ source("nn/layers/relu.dml") as relu source("nn/layers/softmax.dml") as softmax source("nn/optim/sgd_nesterov.dml") as sgd_nesterov -train = function(matrix[double] X, matrix[double] y, - matrix[double] X_val, matrix[double] y_val, +train = function(matrix[double] X, matrix[double] Y, + matrix[double] X_val, matrix[double] Y_val, int C, int Hin, int Win, int epochs) return (matrix[double] W1, matrix[double] b1, matrix[double] W2, matrix[double] b2, @@ -44,14 +44,14 @@ train = function(matrix[double] X, matrix[double] y, * Trains a convolutional net using the "LeNet" architecture. * * The input matrix, X, has N examples, each represented as a 3D - * volume unrolled into a single vector. The targets, y, have K + * volume unrolled into a single vector. The targets, Y, have K * classes, and are one-hot encoded. * * Inputs: * - X: Input data matrix, of shape (N, C*Hin*Win). - * - y: Target matrix, of shape (N, K). + * - Y: Target matrix, of shape (N, K). * - X_val: Input validation data matrix, of shape (N, C*Hin*Win). - * - y_val: Target validation matrix, of shape (N, K). + * - Y_val: Target validation matrix, of shape (N, K). * - C: Number of input channels (dimensionality of input depth). * - Hin: Input height. * - Win: Input width. @@ -68,7 +68,7 @@ train = function(matrix[double] X, matrix[double] y, * - b4: 4th layer biases vector, of shape (1, K). */ N = nrow(X) - K = ncol(y) + K = ncol(Y) # Create network: # conv1 -> relu1 -> pool1 -> conv2 -> relu2 -> pool2 -> affine3 -> relu3 -> affine4 -> softmax @@ -110,7 +110,7 @@ train = function(matrix[double] X, matrix[double] y, beg = ((i-1) * batch_size) %% N + 1 end = min(N, beg + batch_size - 1) X_batch = X[beg:end,] - y_batch = y[beg:end,] + y_batch = Y[beg:end,] # Compute forward pass ## layer 1: conv1 -> relu1 -> pool1 @@ -146,8 +146,8 @@ train = function(matrix[double] X, matrix[double] y, # Compute validation loss & accuracy probs_val = predict(X_val, C, Hin, Win, W1, b1, W2, b2, W3, b3, W4, b4) - loss_val = cross_entropy_loss::forward(probs_val, y_val) - accuracy_val = mean(rowIndexMax(probs_val) == rowIndexMax(y_val)) + loss_val = cross_entropy_loss::forward(probs_val, Y_val) + accuracy_val = mean(rowIndexMax(probs_val) == rowIndexMax(Y_val)) # Output results print("Epoch: " + e + ", Iter: " + i + ", Train Loss: " + loss + ", Train Accuracy: " @@ -283,37 +283,37 @@ predict = function(matrix[double] X, int C, int Hin, int Win, } } -eval = function(matrix[double] probs, matrix[double] y) +eval = function(matrix[double] probs, matrix[double] Y) return (double loss, double accuracy) { /* * Evaluates a convolutional net using the "LeNet" architecture. * * The probs matrix contains the class probability predictions - * of K classes over N examples. The targets, y, have K classes, + * of K classes over N examples. The targets, Y, have K classes, * and are one-hot encoded. * * Inputs: * - probs: Class probabilities, of shape (N, K). - * - y: Target matrix, of shape (N, K). + * - Y: Target matrix, of shape (N, K). * * Outputs: * - loss: Scalar loss, of shape (1). * - accuracy: Scalar accuracy, of shape (1). */ # Compute loss & accuracy - loss = cross_entropy_loss::forward(probs, y) - correct_pred = rowIndexMax(probs) == rowIndexMax(y) + loss = cross_entropy_loss::forward(probs, Y) + correct_pred = rowIndexMax(probs) == rowIndexMax(Y) accuracy = mean(correct_pred) } generate_dummy_data = function() - return (matrix[double] X, matrix[double] y, int C, int Hin, int Win) { + return (matrix[double] X, matrix[double] Y, int C, int Hin, int Win) { /* * Generate a dummy dataset similar to the MNIST dataset. * * Outputs: * - X: Input data matrix, of shape (N, D). - * - y: Target matrix, of shape (N, K). + * - Y: Target matrix, of shape (N, K). * - C: Number of input channels (dimensionality of input depth). * - Hin: Input height. * - Win: Input width. @@ -326,6 +326,6 @@ generate_dummy_data = function() K = 10 # num target classes X = rand(rows=N, cols=C*Hin*Win, pdf="normal") classes = round(rand(rows=N, cols=1, min=1, max=K, pdf="uniform")) - y = table(seq(1, N), classes) # one-hot encoding + Y = table(seq(1, N), classes) # one-hot encoding } http://git-wip-us.apache.org/repos/asf/incubator-systemml/blob/2a4e4f8b/scripts/nn/examples/mnist_softmax-train.dml ---------------------------------------------------------------------- diff --git a/scripts/nn/examples/mnist_softmax-train.dml b/scripts/nn/examples/mnist_softmax-train.dml index 09970f0..e0c6867 100644 --- a/scripts/nn/examples/mnist_softmax-train.dml +++ b/scripts/nn/examples/mnist_softmax-train.dml @@ -73,7 +73,7 @@ out_dir = ifdef($out_dir, ".") images = train[,2:ncol(train)] labels = train[,1] X_test = test[,2:ncol(test)] -y_test = test[,1] +Y_test = test[,1] # Scale images to [0,1], and one-hot encode the labels n = nrow(train) @@ -82,16 +82,16 @@ classes = 10 images = images / 255.0 labels = table(seq(1, n), labels+1, n, classes) X_test = X_test / 255.0 -y_test = table(seq(1, n_test), y_test+1, n_test, classes) +Y_test = table(seq(1, n_test), Y_test+1, n_test, classes) # Split into training (55,000 examples) and validation (5,000 examples) X = images[5001:nrow(images),] X_val = images[1:5000,] -y = labels[5001:nrow(images),] -y_val = labels[1:5000,] +Y = labels[5001:nrow(images),] +Y_val = labels[1:5000,] # Train -[W, b] = mnist_softmax::train(X, y, X_val, y_val, epochs) +[W, b] = mnist_softmax::train(X, Y, X_val, Y_val, epochs) # Write model out write(W, out_dir+"/W") @@ -99,7 +99,7 @@ write(b, out_dir+"/b") # Eval on test set probs = mnist_softmax::predict(X_test, W, b) -[loss, accuracy] = mnist_softmax::eval(probs, y_test) +[loss, accuracy] = mnist_softmax::eval(probs, Y_test) # Output results print("Test Accuracy: " + accuracy) http://git-wip-us.apache.org/repos/asf/incubator-systemml/blob/2a4e4f8b/scripts/nn/examples/mnist_softmax.dml ---------------------------------------------------------------------- diff --git a/scripts/nn/examples/mnist_softmax.dml b/scripts/nn/examples/mnist_softmax.dml index a529a12..4a0664f 100644 --- a/scripts/nn/examples/mnist_softmax.dml +++ b/scripts/nn/examples/mnist_softmax.dml @@ -28,21 +28,21 @@ source("nn/layers/cross_entropy_loss.dml") as cross_entropy_loss source("nn/layers/softmax.dml") as softmax source("nn/optim/sgd_nesterov.dml") as sgd_nesterov -train = function(matrix[double] X, matrix[double] y, - matrix[double] X_val, matrix[double] y_val, +train = function(matrix[double] X, matrix[double] Y, + matrix[double] X_val, matrix[double] Y_val, int epochs) return (matrix[double] W, matrix[double] b) { /* * Trains a softmax classifier. * * The input matrix, X, has N examples, each with D features. - * The targets, y, have K classes, and are one-hot encoded. + * The targets, Y, have K classes, and are one-hot encoded. * * Inputs: * - X: Input data matrix, of shape (N, D). - * - y: Target matrix, of shape (N, K). + * - Y: Target matrix, of shape (N, K). * - X_val: Input validation data matrix, of shape (N, C*Hin*Win). - * - y_val: Target validation matrix, of shape (N, K). + * - Y_val: Target validation matrix, of shape (N, K). * - epochs: Total number of full training loops over the full data set. * * Outputs: @@ -51,7 +51,7 @@ train = function(matrix[double] X, matrix[double] y, */ N = nrow(X) # num examples D = ncol(X) # num features - K = ncol(y) # num classes + K = ncol(Y) # num classes # Create softmax classifier: # affine -> softmax @@ -75,7 +75,7 @@ train = function(matrix[double] X, matrix[double] y, beg = ((i-1) * batch_size) %% N + 1 end = min(N, beg + batch_size - 1) X_batch = X[beg:end,] - y_batch = y[beg:end,] + y_batch = Y[beg:end,] # Compute forward pass ## affine & softmax: @@ -86,8 +86,8 @@ train = function(matrix[double] X, matrix[double] y, loss = cross_entropy_loss::forward(probs, y_batch) accuracy = mean(rowIndexMax(probs) == rowIndexMax(y_batch)) probs_val = predict(X_val, W, b) - loss_val = cross_entropy_loss::forward(probs_val, y_val) - accuracy_val = mean(rowIndexMax(probs_val) == rowIndexMax(y_val)) + loss_val = cross_entropy_loss::forward(probs_val, Y_val) + accuracy_val = mean(rowIndexMax(probs_val) == rowIndexMax(Y_val)) print("Epoch: " + e + ", Iter: " + i + ", Train Loss: " + loss + ", Train Accuracy: " + accuracy + ", Val Loss: " + loss_val + ", Val Accuracy: " + accuracy_val) @@ -130,37 +130,37 @@ predict = function(matrix[double] X, matrix[double] W, matrix[double] b) probs = softmax::forward(out) } -eval = function(matrix[double] probs, matrix[double] y) +eval = function(matrix[double] probs, matrix[double] Y) return (double loss, double accuracy) { /* * Evaluates a softmax classifier. * * The probs matrix contains the class probability predictions - * of K classes over N examples. The targets, y, have K classes, + * of K classes over N examples. The targets, Y, have K classes, * and are one-hot encoded. * * Inputs: * - probs: Class probabilities, of shape (N, K). - * - y: Target matrix, of shape (N, K). + * - Y: Target matrix, of shape (N, K). * * Outputs: * - loss: Scalar loss, of shape (1). * - accuracy: Scalar accuracy, of shape (1). */ # Compute loss & accuracy - loss = cross_entropy_loss::forward(probs, y) - correct_pred = rowIndexMax(probs) == rowIndexMax(y) + loss = cross_entropy_loss::forward(probs, Y) + correct_pred = rowIndexMax(probs) == rowIndexMax(Y) accuracy = mean(correct_pred) } generate_dummy_data = function() - return (matrix[double] X, matrix[double] y, int C, int Hin, int Win) { + return (matrix[double] X, matrix[double] Y, int C, int Hin, int Win) { /* * Generate a dummy dataset similar to the MNIST dataset. * * Outputs: * - X: Input data matrix, of shape (N, D). - * - y: Target matrix, of shape (N, K). + * - Y: Target matrix, of shape (N, K). * - C: Number of input channels (dimensionality of input depth). * - Hin: Input height. * - Win: Input width. @@ -173,6 +173,6 @@ generate_dummy_data = function() T = 10 # num targets X = rand(rows=N, cols=C*Hin*Win, pdf="normal") classes = round(rand(rows=N, cols=1, min=1, max=T, pdf="uniform")) - y = table(seq(1, N), classes) # one-hot encoding + Y = table(seq(1, N), classes) # one-hot encoding }