diff --git a/notebooks/User_guide_for_ND4J_and_DL4J.ipynb b/notebooks/User_guide_for_ND4J_and_DL4J.ipynb new file mode 100644 index 0000000000..6c1ad6b7ab --- /dev/null +++ b/notebooks/User_guide_for_ND4J_and_DL4J.ipynb @@ -0,0 +1,272 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# ND4J and DL4J exploration" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "ND4J is a tensor & N-dimensional array scientific computing library built for the JVM and is part of the [Deeplearning4j](https://deeplearning4j.org/) suite of software. This notebook serves as the user guide to understand the main functionality of ND4J. In this notebook, we'll explore its use-cases through numerous examples and then we'll discuss its usage in the project. So, let's begin with loading some essential JARs." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "method": "display_data" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "79464426-0661-46aa-9c0d-f252429dbef1", + "version_major": 2, + "version_minor": 0 + }, + "method": "display_data" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%classpath add mvn org.nd4j nd4j-native-platform 0.9.0" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "method": "display_data" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e1be3069-6c5b-4b18-b424-5235b361ca78", + "version_major": 2, + "version_minor": 0 + }, + "method": "display_data" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%classpath add mvn org.bytedeco javacpp 1.5" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "ND4J(N-Dimensions For Java) or – as its creators present it – the “numpy” for the JVM, allows the user to create and perform various mathematical operations on N-Dimensional arrays. Throughout this notebook, we’ll use the term **NDArray** to refer to the general concept of an n-dimensional array; the term **INDArray** refers specifically to the [Java interface](https://github.com/deeplearning4j/nd4j/blob/master/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ndarray/INDArray.java) that ND4J defines. In practice, these two terms can be used interchangeably. \n", + "\n", + "First, let's see how to create an NDArray:-" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Creating NDArrays\n", + "\n", + "Before we begin with creating an NDArray, let's see some concepts you should be familiar with:\n", + "\n", + "* The rank of an NDArray is the number of dimensions. 2d NDArrays have a rank of 2, 3d arrays have a rank of 3, and so on. You can create NDArrays with any arbitrary rank.\n", + "* The shape of an NDArray defines the size of each of the dimensions. Suppose we have a 2d array with 3 rows and 5 columns. This NDArray would have shape [3,5].\n", + "* The length of an NDArray defines the total number of elements in the array. The length is always equal to the product of the values that make up the shape.\n", + "* The stride of an NDArray is defined as the separation (in the underlying data buffer) of contiguous elements in each dimension. Stride is defined per dimension, so a rank N NDArray has N stride values, one for each dimension. Note that most of the time, you don’t need to know (or concern yourself with) the stride - just be aware that this is how ND4J operates internally.\n", + "\n", + "Now, let's see the different ways to create an NDArray:-" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Nd4j.zeros(nRows, nColumns)\n", + "[[0.00, 0.00, 0.00, 0.00, 0.00], \n", + " [0.00, 0.00, 0.00, 0.00, 0.00], \n", + " [0.00, 0.00, 0.00, 0.00, 0.00]]\n", + "\n", + "\n", + "Nd4j.ones(nRows, nColumns)\n", + "[[1.00, 1.00, 1.00, 1.00, 1.00], \n", + " [1.00, 1.00, 1.00, 1.00, 1.00], \n", + " [1.00, 1.00, 1.00, 1.00, 1.00]]\n", + "\n", + "\n", + "Nd4j.valueArrayOf(nRows, nColumns, 10.0)\n", + "[[10.00, 10.00, 10.00, 10.00, 10.00], \n", + " [10.00, 10.00, 10.00, 10.00, 10.00], \n", + " [10.00, 10.00, 10.00, 10.00, 10.00]]\n", + "\n", + "\n", + "INDArray defined from double[][]:\n", + "[[1.00, 2.00, 3.00], \n", + " [4.00, 5.00, 6.00]]\n", + "\n", + "\n", + "Uniform random array:\n", + "[[0.62, 0.39, 0.59, 0.29, 0.59], \n", + " [0.35, 0.13, 0.05, 0.67, 0.71], \n", + " [0.70, 0.48, 0.59, 0.90, 0.23]]\n", + "\n", + "\n", + "Creating INDArrays from other INDArrays, using hstack and vstack:\n", + "vStack:\n", + "[[0.00, 0.00, 0.00, 0.00, 0.00], \n", + " [0.00, 0.00, 0.00, 0.00, 0.00], \n", + " [0.00, 0.00, 0.00, 0.00, 0.00], \n", + " [1.00, 1.00, 1.00, 1.00, 1.00], \n", + " [1.00, 1.00, 1.00, 1.00, 1.00], \n", + " [1.00, 1.00, 1.00, 1.00, 1.00]]\n", + "hStack:\n", + "[[0.00, 0.00, 0.00, 0.00, 0.00, 1.00, 1.00, 1.00, 1.00, 1.00], \n", + " [0.00, 0.00, 0.00, 0.00, 0.00, 1.00, 1.00, 1.00, 1.00, 1.00], \n", + " [0.00, 0.00, 0.00, 0.00, 0.00, 1.00, 1.00, 1.00, 1.00, 1.00]]\n", + "\n", + "\n", + "Nd4j.eye(3):\n", + "[[1.00, 0.00, 0.00], \n", + " [0.00, 1.00, 0.00], \n", + " [0.00, 0.00, 1.00]]\n", + "Nd4j.linspace(1,10,10):\n", + "[1.00, 2.00, 3.00, 4.00, 5.00, 6.00, 7.00, 8.00, 9.00, 10.00]\n" + ] + }, + { + "data": { + "text/plain": [ + "null" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import org.nd4j.linalg.api.ndarray.INDArray;\n", + "import org.nd4j.linalg.factory.Nd4j;\n", + "\n", + "import java.util.Arrays;\n", + "\n", + "//First, we'll see how to create INDArrays with different scalar value initializations\n", + "int nRows = 3;\n", + "int nColumns = 5;\n", + "INDArray allZeros = Nd4j.zeros(nRows, nColumns);\n", + "System.out.println(\"Nd4j.zeros(nRows, nColumns)\");\n", + "System.out.println(allZeros);\n", + "\n", + "INDArray allOnes = Nd4j.ones(nRows, nColumns);\n", + "System.out.println(\"\\n\\nNd4j.ones(nRows, nColumns)\");\n", + "System.out.println(allOnes);\n", + "\n", + "INDArray allTens = Nd4j.valueArrayOf(nRows, nColumns, 10.0);\n", + "System.out.println(\"\\n\\nNd4j.valueArrayOf(nRows, nColumns, 10.0)\");\n", + "System.out.println(allTens);\n", + "\n", + "//We can also create INDArrays from double[] and double[][] (or, float/int etc Java arrays)\n", + "\n", + "double[][] matrixDouble = new double[][]{\n", + " {1.0, 2.0, 3.0},\n", + " {4.0, 5.0, 6.0}};\n", + "INDArray matrix = Nd4j.create(matrixDouble);\n", + "System.out.println(\"\\n\\nINDArray defined from double[][]:\");\n", + "System.out.println(matrix);\n", + "\n", + "//It is also possible to create random INDArrays:\n", + "\n", + "int[] shape = new int[]{nRows, nColumns};\n", + "INDArray uniformRandom = Nd4j.rand(shape);\n", + "System.out.println(\"\\n\\nUniform random array:\");\n", + "System.out.println(uniformRandom);\n", + "\n", + "//We can create INDArrays by combining other INDArrays, too:\n", + "\n", + "INDArray vStack = Nd4j.vstack(allZeros, allOnes);//Vertical stack: [1,3]+[1,3] to [2,3]\n", + "INDArray hStack = Nd4j.hstack(allZeros, allOnes);//Horizontal stack: [1,3]+[1,3] to [1,6]\n", + "System.out.println(\"\\n\\nCreating INDArrays from other INDArrays, using hstack and vstack:\");\n", + "System.out.println(\"vStack:\\n\" + vStack);\n", + "System.out.println(\"hStack:\\n\" + hStack);\n", + "\n", + "//There's some other miscellaneous methods, too:\n", + "\n", + "INDArray identityMatrix = Nd4j.eye(3);\n", + "System.out.println(\"\\n\\nNd4j.eye(3):\\n\" + identityMatrix);\n", + "INDArray linspace = Nd4j.linspace(1,10,10); //Values 1 to 10, in 10 steps\n", + "System.out.println(\"\\n\\nNd4j.linspace(1,10,10):\\n\" + linspace);" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Java", + "language": "java", + "name": "java" + }, + "language_info": { + "codemirror_mode": "text/x-java", + "file_extension": ".java", + "mimetype": "", + "name": "Java", + "nbconverter_exporter": "", + "version": "1.8.0_144" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": false, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": false, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}