tensor/tensor-initiation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"https://colab.research.google.com/github/sugarme/nb/blob/master/tensor/tensor-initiation.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tensor Initiation\n",
    "\n",
    "This notebook using\n",
    "\n",
    "1. [GoTch - Pytorch C++ APIs Go bindind](https://github.com/sugarme/gotch)\n",
    "2. [GopherNotes - Jupyter Notebook Go kernel](https://github.com/gopherdata/gophernotes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"border: 2pt solid blue\"> </hr>\n",
    "\n",
    "## Install Go kernel - GopherNotes (Google Colab Only)\n",
    "\n",
    "- Save a copy to your Google Drive\n",
    "- Change Runtime type to use GPU if needed (Runtime/Change runtime type/Hardware accelerator/GPU)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# run this cell first time using python runtime\n",
    "!add-apt-repository ppa:longsleep/golang-backports -y > /dev/null\n",
    "!apt update > /dev/null \n",
    "!apt install golang-go > /dev/null\n",
    "%env GOPATH=/root/go\n",
    "!go get -u github.com/gopherdata/gophernotes\n",
    "!cp ~/go/bin/gophernotes /usr/bin/\n",
    "!mkdir /usr/local/share/jupyter/kernels/gophernotes\n",
    "!cp ~/go/src/github.com/gopherdata/gophernotes/kernel/* \\\n",
    "       /usr/local/share/jupyter/kernels/gophernotes\n",
    "# then refresh (browser), it will now use gophernotes. Skip to golang in later cells"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note**: refresh (reload) browswer after this step!\n",
    "\n",
    "<hr style=\"border:1px solid red\"> </hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Install Pytorch C++ APIs and Go binding - GoTch\n",
    "\n",
    "NOTE: `ldconfig` (GLIBC) current version 2.27 is currently broken when linking Libtorch library\n",
    "\n",
    "see issue: https://discuss.pytorch.org/libtorch-c-so-files-truncated-error-when-ldconfig/46404/6\n",
    "\n",
    "Google Colab default settings:\n",
    "```bash\n",
    "LD_LIBRARY_PATH=/usr/lib64-nvidia\n",
    "LIBRARY_PATH=/usr/local/cuda/lib64/stubs\n",
    "```\n",
    "We copy directly `libtorch/lib` to those paths as a hacky way. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "$wget -q --show-progress --progress=bar:force:noscroll -O /tmp/libtorch-cxx11-abi-shared-with-deps-1.7.0%2Bcu101.zip https://download.pytorch.org/libtorch/cu101/libtorch-cxx11-abi-shared-with-deps-1.7.0%2Bcu101.zip\n",
    "$unzip -qq /tmp/libtorch-cxx11-abi-shared-with-deps-1.7.0%2Bcu101.zip -d /usr/local\n",
    "$unzip -qq -j /tmp/libtorch-cxx11-abi-shared-with-deps-1.7.0%2Bcu101.zip libtorch/lib/* -d /usr/lib64-nvidia/\n",
    "$unzip -qq -j /tmp/libtorch-cxx11-abi-shared-with-deps-1.7.0%2Bcu101.zip libtorch/lib/* -d /usr/local/cuda/lib64/stubs/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import(\"os\")\n",
    "os.Setenv(\"CPATH\", \"usr/local/libtorch/lib:/usr/local/libtorch/include:/usr/local/libtorch/include/torch/csrc/api/include\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "$rm -f -- go.mod\n",
    "$go mod init github.com/sugarme/playgo\n",
    "$go get github.com/sugarme/gotch@v0.3.2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import(\n",
    "    \"fmt\"\n",
    "\n",
    "    \"github.com/sugarme/gotch\"\n",
    "    ts \"github.com/sugarme/gotch/tensor\"\n",
    ") "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ...and we are ready to Go! Thank you for using GoTch!\n",
    "\n",
    "<hr style=\"border:2pt solid blue\"> </hr>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import(\n",
    "    \"fmt\"\n",
    "    \n",
    "    ts \"github.com/sugarme/gotch/tensor\"\n",
    "    \"github.com/sugarme/gotch\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tensor `OfSlice` - From slice of values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1  2  3  4  5  \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "16 <nil>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "intSlice := []int64{1, 2, 3, 4, 5}\n",
    "ts1, err := ts.OfSlice(intSlice)\n",
    "if err != nil {fmt.Print(err)}\n",
    "fmt.Print(ts1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `NewTensorFromData` - Specified data and shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.1  0.2  0.3  \n",
      "0.4  0.5  0.6  \n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "33 <nil>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// A alternative `OfSlice` which auto-infer data type of slice.\n",
    "flSlice := [][]float64{\n",
    "    []float64{0.1, 0.2, 0.3},\n",
    "    []float64{0.4, 0.5, 0.6},\n",
    "}\n",
    "ts2, err := ts.NewTensorFromData(flSlice, []int64{2, 3})\n",
    "if err != nil {fmt.Print(err)}\n",
    "fmt.Printf(\"%.1f\", ts2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tensor `Ones` - values of one"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0  1.0  1.0  1.0  \n",
      "1.0  1.0  1.0  1.0  \n",
      "1.0  1.0  1.0  1.0  \n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "64 <nil>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ts3, err := ts.Ones([]int64{3,4}, gotch.Double, gotch.CPU)\n",
    "fmt.Printf(\"%.1f\", ts3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tensor `Zeros` - values of zero"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0  0  0  \n",
      "0  0  0  \n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "21 <nil>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ts3, err := ts.Zeros([]int64{2,3}, gotch.Int64, gotch.CPU)\n",
    "fmt.Printf(\"%d\", ts3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tensor `Arange` - specified number of elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 0.0   1.0   2.0   3.0  \n",
      " 4.0   5.0   6.0   7.0  \n",
      " 8.0   9.0  10.0  11.0  \n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "76 <nil>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ts4, err := ts.Arange(ts.IntScalar(12), gotch.Double, gotch.CPU)\n",
    "if err != nil { fmt.Print(err)}\n",
    "fmt.Printf(\"%4.1f\", ts1.MustView([]int64{3,4}, true))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0  1  2  \n",
      "3  4  5  \n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "22 <nil>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ts5, err := ts.Arange(ts.IntScalar(6), gotch.Double, gotch.CPU)\n",
    "if err != nil { fmt.Print(err)}\n",
    "fmt.Printf(\"%v\\n\", ts5.MustView([]int64{2,3}, true))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tensor `Arange1` - specified `start` (inclusive) value and `end` (exclusive) value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.0   4.0   5.0   6.0   7.0   8.0   9.0   10.0  11.0  \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "55 <nil>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ts6, err := ts.Arange1(ts.IntScalar(3), ts.IntScalar(12), gotch.Double, gotch.CPU)\n",
    "if err != nil { fmt.Print(err)}\n",
    "fmt.Printf(\"%.1f\", ts6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tensor `Arange2` - specified `start`, `end` and `step` values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0   2.0   4.0   6.0   8.0   10.0  \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "37 <nil>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ts7, err := ts.Arange2(ts.IntScalar(0), ts.IntScalar(12), ts.IntScalar(2), gotch.Double, gotch.CPU)\n",
    "if err != nil { fmt.Print(err)}\n",
    "fmt.Printf(\"%.1f\", ts7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tensor `Rand` -  random values with specified shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1,.,.) =\n",
      "0.280  0.538  0.002  0.566  \n",
      "0.392  0.219  0.956  0.221  \n",
      "0.399  0.300  0.947  0.252  \n",
      "\n",
      "(2,.,.) =\n",
      "0.113  0.615  0.814  0.540  \n",
      "0.705  0.087  0.920  0.247  \n",
      "0.512  0.773  0.357  0.009  \n",
      "\n",
      "(3,.,.) =\n",
      "0.295  0.848  0.591  0.362  \n",
      "0.493  0.973  0.437  0.816  \n",
      "0.790  0.794  0.573  0.273  \n",
      "\n",
      "(4,.,.) =\n",
      "0.546  0.270  0.589  0.695  \n",
      "0.582  0.076  0.363  0.865  \n",
      "0.385  0.644  0.601  0.648  \n",
      "\n",
      "(5,.,.) =\n",
      "0.743  0.646  0.171  0.405  \n",
      "0.150  0.142  0.643  0.158  \n",
      "0.999  0.465  0.757  0.946  \n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "490 <nil>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// NOTE: `Rand` always take float type only. To initiate int values, use `Randint`\n",
    "ts2 := ts.MustRand([]int64{5,3,4}, gotch.Double, gotch.CPU)\n",
    "fmt.Printf(\"%.3f\", ts2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tensor `Randint` - Random int values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1,.,.) =\n",
      "1  3  3  6  \n",
      "8  5  3  4  \n",
      "5  2  3  7  \n",
      "\n",
      "(2,.,.) =\n",
      "8  7  1  8  \n",
      "2  2  4  3  \n",
      "4  3  7  0  \n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "100 <nil>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// First argument is the upper bound for random values\n",
    "ts7, err := ts.Randint(9,[]int64{2,3,4}, gotch.Int64, gotch.CPU)\n",
    "if err != nil { fmt.Print(err)}\n",
    "fmt.Printf(\"%d\", ts7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tensor `Empty` returns a tensor filled with uninitialized data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.00  0.00  0.00  0.00  \n",
      "0.00  0.00  0.00  0.00  \n",
      "0.00  0.00  0.00  0.00  \n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "76 <nil>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "xs, err := ts.Empty([]int64{3,4}, gotch.Double, gotch.CPU)\n",
    "if err != nil {fmt.Print(err)}\n",
    "fmt.Printf(\"%.2f\", xs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tensor `Eye` returns 2D tensor with ones on the diagnal and zeros elsewhere"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.00  0.00  0.00  0.00  0.00  0.00  \n",
      "0.00  1.00  0.00  0.00  0.00  0.00  \n",
      "0.00  0.00  1.00  0.00  0.00  0.00  \n",
      "0.00  0.00  0.00  1.00  0.00  0.00  \n",
      "0.00  0.00  0.00  0.00  1.00  0.00  \n",
      "0.00  0.00  0.00  0.00  0.00  1.00  \n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "223 <nil>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ts9, err := ts.Eye(6, gotch.Double, gotch.CPU)\n",
    "if err != nil{fmt.Print(err)}\n",
    "fmt.Printf(\"%.2f\", ts9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tensor `Eye1` - with an additional parameter specifying number of columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.00  0.00  0.00  0.00  \n",
      "0.00  1.00  0.00  0.00  \n",
      "0.00  0.00  1.00  0.00  \n",
      "0.00  0.00  0.00  1.00  \n",
      "0.00  0.00  0.00  0.00  \n",
      "0.00  0.00  0.00  0.00  \n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "151 <nil>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "xs, err := ts.Eye1(6, 4, gotch.Double, gotch.CPU)\n",
    "if err != nil{fmt.Print(err)}\n",
    "fmt.Printf(\"%.2f\", xs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tensor `EyeOut` - specify output tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before:\n",
      "0.00  0.00  0.00  0.00  0.00  0.00  \n",
      "0.00  0.00  0.00  0.00  0.00  0.00  \n",
      "0.00  0.00  0.00  0.00  0.00  0.00  \n",
      "0.00  0.00  0.00  0.00  0.00  0.00  \n",
      "0.00  0.00  0.00  0.00  0.00  0.00  \n",
      "0.00  0.00  0.00  0.00  0.00  0.00  \n",
      "\n",
      "After:\n",
      "1.00  0.00  0.00  0.00  0.00  0.00  \n",
      "0.00  1.00  0.00  0.00  0.00  0.00  \n",
      "0.00  0.00  1.00  0.00  0.00  0.00  \n",
      "0.00  0.00  0.00  1.00  0.00  0.00  \n",
      "0.00  0.00  0.00  0.00  1.00  0.00  \n",
      "0.00  0.00  0.00  0.00  0.00  1.00  \n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "230 <nil>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "out := ts.MustEmpty([]int64{6,6}, gotch.Double, gotch.CPU)\n",
    "fmt.Printf(\"Before:\\n%.2f\", out)\n",
    "ts.EyeOut(out, 6)\n",
    "fmt.Printf(\"After:\\n%.2f\", out)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tensor `EyeOut1` - specify output tensor and number of columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before:\n",
      "0.00  0.00  0.00  0.00  0.00  0.00  0.00  0.00  \n",
      "0.00  0.00  0.00  0.00  0.00  0.00  0.00  0.00  \n",
      "0.00  0.00  0.00  0.00  0.00  0.00  0.00  0.00  \n",
      "0.00  0.00  0.00  0.00  0.00  0.00  0.00  0.00  \n",
      "0.00  0.00  0.00  0.00  0.00  0.00  0.00  0.00  \n",
      "0.00  0.00  0.00  0.00  0.00  0.00  0.00  0.00  \n",
      "\n",
      "After:\n",
      "1.00  0.00  0.00  0.00  \n",
      "0.00  1.00  0.00  0.00  \n",
      "0.00  0.00  1.00  0.00  \n",
      "0.00  0.00  0.00  1.00  \n",
      "0.00  0.00  0.00  0.00  \n",
      "0.00  0.00  0.00  0.00  \n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "158 <nil>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "out := ts.MustEmpty([]int64{6,8}, gotch.Double, gotch.CPU)\n",
    "fmt.Printf(\"Before:\\n%.2f\", out)\n",
    "ts.EyeOut1(out, 6, 4)\n",
    "fmt.Printf(\"After:\\n%.2f\", out)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tensor `Linspace` - creates 1D tensor of size `steps` whose values evenly spaced from `start` to `end` inclusive\n",
    "\n",
    "NOTE: values are calculated as: `start, start + (end - start)/steps, ..., (start + step - 1) * (end - start)/steps, end` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.00   4.75   6.50   8.25   10.00  \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "36 <nil>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "xs, err := ts.Linspace(ts.FloatScalar(3.0), ts.FloatScalar(10.0), []int64{5}, gotch.Double, gotch.CPU)\n",
    "if err != nil {fmt.Print(err)}\n",
    "fmt.Printf(\"%.2f\", xs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tensor `Normal_` creates normal distribution with specified `mean` and `std` values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.33  1.91  2.56  3.18  \n",
      "2.65  2.50  1.70  1.92  \n",
      "1.87  3.27  2.51  2.19  \n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "76 <nil>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "xs, err := ts.Empty([]int64{3,4}, gotch.Double, gotch.CPU)\n",
    "err := xs.Normal_(2.3, 0.5)\n",
    "if err != nil{fmt.Print(err)}\n",
    "fmt.Printf(\"%.2f\", xs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tensor `Uniform_` creates uniform distribution with specified `from` and `end` values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  1.98    8.38   11.98    7.59  \n",
      "  2.72    5.50    1.57    2.95  \n",
      "  3.34   10.64    5.60    1.53  \n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "100 <nil>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "xs, err := ts.Empty([]int64{3,4}, gotch.Double, gotch.CPU)\n",
    "err := xs.Uniform_(0.1, 12.0)\n",
    "if err != nil {fmt.Print(err)}\n",
    "fmt.Printf(\"%6.2f\", xs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tensor `Totype` convert tensor to specified `DType`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input tensor: 0  1  2  3  \n",
      "Output tensor: false  true   true   true   \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "44 <nil>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inputTs, err := ts.Arange(ts.IntScalar(4), gotch.Double, gotch.CPU)\n",
    "if err != nil{fmt.Print(err)}\n",
    "fmt.Printf(\"Input tensor: %v\", inputTs)\n",
    "xs, err := inputTs.Totype(gotch.Bool, true)\n",
    "fmt.Printf(\"Output tensor: %v\", xs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Go",
   "language": "go",
   "name": "gophernotes"
  },
  "language_info": {
   "codemirror_mode": "",
   "file_extension": ".go",
   "mimetype": "",
   "name": "go",
   "nbconvert_exporter": "",
   "pygments_lexer": "",
   "version": "go1.15.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}