{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tensor operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/lln/Documentos/recreate_pytorch/PyNorch\n"
     ]
    }
   ],
   "source": [
    "%cd .."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1 - Basic operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "t1 =\n",
      "tensor([[1.0, 2.0,],\n",
      "[3.0, 4.0,]], device=\"cpu\", requires_grad=False)\n",
      "t2 =\n",
      "tensor([[4.0, 3.0,],\n",
      "[2.0, 1.0,]], device=\"cpu\", requires_grad=False)\n",
      "\n",
      "Some basic operations\n",
      "x1 + x2: \n",
      "tensor([[5.0, 5.0,],\n",
      "[5.0, 5.0,]], device=\"cpu\", requires_grad=False)\n",
      "x1 - x2: \n",
      "tensor([[-3.0, -1.0,],\n",
      "[1.0, 3.0,]], device=\"cpu\", requires_grad=False)\n",
      "x1 * x2: \n",
      "tensor([[4.0, 6.0,],\n",
      "[6.0, 4.0,]], device=\"cpu\", requires_grad=False)\n",
      "x1 / x2: \n",
      "tensor([[0.25, 0.6666666865348816,],\n",
      "[1.5, 4.0,]], device=\"cpu\", requires_grad=False)\n",
      "x1 / 10: \n",
      "tensor([[0.10000000149011612, 0.20000000298023224,],\n",
      "[0.30000001192092896, 0.4000000059604645,]], device=\"cpu\", requires_grad=False)\n",
      "x1 @ x2: \n",
      "tensor([[8.0, 5.0,],\n",
      "[20.0, 13.0,]], device=\"cpu\", requires_grad=False)\n",
      "x1 ** 2: \n",
      "tensor([[1.0, 4.0,],\n",
      "[9.0, 16.0,]], device=\"cpu\", requires_grad=False)\n"
     ]
    }
   ],
   "source": [
    "import norch\n",
    "\n",
    "x1 = norch.Tensor([[1, 2], \n",
    "                  [3, 4]])\n",
    "x2 = norch.Tensor([[4, 3], \n",
    "                  [2, 1]])\n",
    "\n",
    "print(f\"t1 =\\n{x1}\")\n",
    "print(f\"t2 =\\n{x2}\")\n",
    "\n",
    "print(\"\\nSome basic operations\")\n",
    "print(f\"x1 + x2: \\n{x1 + x2}\")\n",
    "print(f\"x1 - x2: \\n{x1 - x2}\")\n",
    "print(f\"x1 * x2: \\n{x1 * x2}\")\n",
    "print(f\"x1 / x2: \\n{x1 / x2}\")\n",
    "print(f\"x1 / 10: \\n{x1 / 10}\")\n",
    "print(f\"x1 @ x2: \\n{x1 @ x2}\")\n",
    "print(f\"x1 ** 2: \\n{x1 ** 2}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x1 reshape: \n",
      "tensor([[1.0, 2.0, 3.0, 4.0,]], device=\"cpu\", requires_grad=False)\n",
      "x1 transpose axes: \n",
      "tensor([[1.0, 3.0,],\n",
      "[2.0, 4.0,]], device=\"cpu\", requires_grad=False)\n",
      "x1 transpose: \n",
      "tensor([[1.0, 3.0,],\n",
      "[2.0, 4.0,]], device=\"cpu\", requires_grad=False)\n",
      "x1 zeros_like: \n",
      "tensor([[0.0, 0.0,],\n",
      "[0.0, 0.0,]], device=\"cpu\", requires_grad=None)\n",
      "x1 ones_like: \n",
      "tensor([[1.0, 1.0,],\n",
      "[1.0, 1.0,]], device=\"cpu\", requires_grad=None)\n",
      "sin(x1): \n",
      "tensor([[0.8414709568023682, 0.9092974066734314,],\n",
      "[0.14112000167369843, -0.756802499294281,]], device=\"cpu\", requires_grad=False)\n",
      "cos(x1): \n",
      "tensor([[0.5403022766113281, -0.416146844625473,],\n",
      "[-0.9899924993515015, -0.6536436080932617,]], device=\"cpu\", requires_grad=False)\n"
     ]
    }
   ],
   "source": [
    "print(f\"x1 reshape: \\n{x1.reshape([1, 4])}\")\n",
    "print(f\"x1 transpose axes: \\n{x1.transpose(1, 0)}\")\n",
    "print(f\"x1 transpose: \\n{x1.T}\")\n",
    "\n",
    "print(f\"x1 zeros_like: \\n{x1.zeros_like()}\")\n",
    "print(f\"x1 ones_like: \\n{x1.ones_like()}\")\n",
    "\n",
    "print(f\"sin(x1): \\n{x1.sin()}\")\n",
    "print(f\"cos(x1): \\n{x1.cos()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2 - Autograd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a.shape: [5, 3, 2]\n",
      "b.shape: [5, 4, 3]\n",
      "\n",
      "\n",
      "gradient a: tensor([[\n",
      "[18.437000274658203, 18.437000274658203,],\n",
      "    [22.269001007080078, 22.269001007080078,],\n",
      "    [5.723199844360352, 5.723199844360352,]],\n",
      "[\n",
      "[18.437000274658203, 18.437000274658203,],\n",
      "    [22.269001007080078, 22.269001007080078,],\n",
      "    [5.723199844360352, 5.723199844360352,]],\n",
      "[\n",
      "[18.437000274658203, 18.437000274658203,],\n",
      "    [22.269001007080078, 22.269001007080078,],\n",
      "    [5.723199844360352, 5.723199844360352,]],\n",
      "[\n",
      "[18.437000274658203, 18.437000274658203,],\n",
      "    [22.269001007080078, 22.269001007080078,],\n",
      "    [5.723199844360352, 5.723199844360352,]],\n",
      "[\n",
      "[18.437000274658203, 18.437000274658203,],\n",
      "    [22.269001007080078, 22.269001007080078,],\n",
      "    [5.723199844360352, 5.723199844360352,]]], device=\"cpu\", requires_grad=None)\n"
     ]
    }
   ],
   "source": [
    "a = norch.Tensor([\n",
    "        [[1.234, 2.123], [3.635, 4.456], [5.678, 6.789]],\n",
    "        [[7.890, 8.901], [9.012, 1.234], [2.345, 3.456]],\n",
    "        [[4.567, 5.678], [6.789, 7.890], [8.901, 9.012]],\n",
    "        [[1.234, 2.345], [3.456, 4.567], [5.678, 6.789]],\n",
    "        [[7.890, 8.901], [9.012, 1.234], [2.345, 3.456]]\n",
    "    ], requires_grad=True)\n",
    "\n",
    "\n",
    "b = norch.Tensor([[\n",
    "        [1.234, 2.123, 1.5],\n",
    "        [5.678, 6.789, 1.293],\n",
    "        [3.635, 4.456, 1.0202],\n",
    "        [7.890, 8.901, 1.91],\n",
    "    ],[\n",
    "        [1.234, 2.123, 1.5],\n",
    "        [5.678, 6.789, 1.293],\n",
    "        [3.635, 4.456, 1.0202],\n",
    "        [7.890, 8.901, 1.91],\n",
    "    ],[\n",
    "        [1.234, 2.123, 1.5],\n",
    "        [5.678, 6.789, 1.293],\n",
    "        [3.635, 4.456, 1.0202],\n",
    "        [7.890, 8.901, 1.91],\n",
    "    ],[\n",
    "        [1.234, 2.123, 1.5],\n",
    "        [5.678, 6.789, 1.293],\n",
    "        [3.635, 4.456, 1.0202],\n",
    "        [7.890, 8.901, 1.91],\n",
    "    ],[\n",
    "        [1.234, 2.123, 1.5],\n",
    "        [5.678, 6.789, 1.293],\n",
    "        [3.635, 4.456, 1.0202],\n",
    "        [7.890, 8.901, 1.91],\n",
    "    ]])\n",
    "\n",
    "print(f\"a.shape: {a.shape}\")\n",
    "print(f\"b.shape: {b.shape}\\n\\n\")\n",
    "\n",
    "result = b @ a\n",
    "result = result.sum()\n",
    "result.backward()\n",
    "\n",
    "print(f\"gradient a: {a.grad}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import norch.nn as nn\n",
    "\n",
    "class MyModule(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(MyModule, self).__init__()\n",
    "\n",
    "        self.layer1 = nn.Linear(100, 1000)\n",
    "        self.sigmoid1 = nn.Sigmoid()\n",
    "        self.layer2 = nn.Linear(1000, 2)\n",
    "        self.sigmoid2 = nn.Sigmoid()\n",
    "\n",
    "    def forward(self, x):\n",
    "        out = self.layer1(x)\n",
    "        out = self.sigmoid1(out)\n",
    "        out = self.layer2(out)\n",
    "        out = self.sigmoid2(out)\n",
    "\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MyModule(\n",
       "   (layer1): Linear(input_dim=100, output_dim=1000, bias=True)\n",
       "   (sigmoid1): Sigmoid()\n",
       "   (layer2): Linear(input_dim=1000, output_dim=2, bias=True)\n",
       "   (sigmoid2): Sigmoid()\n",
       ")"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = MyModule()\n",
    "model"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}