notebooks/06-1_Pytorch_Basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Tensors\n",
    "\n",
    "## What is a Tensor?\n",
    "\n",
    "- Definition: \"A tensor is a multi-dimensional array, a generalization of matrices to higher dimensions.\"\n",
    "- Key Points:\n",
    "  - Fundamental data structure in PyTorch.\n",
    "  - Similar to NumPy arrays, but with additional functionality for GPU acceleration.\n",
    "  - You can create tensors from lists, with specific values, shapes, data types, and even from NumPy arrays."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating Tensors from Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "\n",
    "# Creating a tensor from a list\n",
    "data = [1.0, 2.0, 3.0]\n",
    "tensor_from_list = torch.tensor(data)\n",
    "print(\"Tensor from list:\", tensor_from_list, tensor_from_list.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating Tensors with Specific Values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating a 2D tensor (matrix) of zeros\n",
    "zeros_matrix = torch.zeros(2, 3)\n",
    "print(\"Zeros matrix:\\n\", zeros_matrix)\n",
    "\n",
    "# Creating a 2D tensor (matrix) of ones\n",
    "ones_matrix = torch.ones(2, 3)\n",
    "print(\"Ones matrix:\\n\", ones_matrix)\n",
    "\n",
    "# Creating a 2D tensor (matrix) with random values\n",
    "random_matrix = torch.rand(2, 3)\n",
    "print(\"Random matrix:\\n\", random_matrix)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating Tensors with Specific Shapes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating a 2D tensor (matrix) of zeros\n",
    "zeros_matrix = torch.zeros(2, 3)\n",
    "print(\"Zeros matrix:\\n\", zeros_matrix)\n",
    "\n",
    "# Creating a 2D tensor (matrix) of ones\n",
    "ones_matrix = torch.ones(2, 3)\n",
    "print(\"Ones matrix:\\n\", ones_matrix)\n",
    "\n",
    "# Creating a 2D tensor (matrix) with random values\n",
    "random_matrix = torch.rand(2, 3)\n",
    "print(\"Random matrix:\\n\", random_matrix)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating Tensors with Specific Data Types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating a tensor with integer values\n",
    "int_tensor = torch.tensor([1, 2, 3], dtype=torch.int32)\n",
    "print(\"Integer tensor:\", int_tensor)\n",
    "\n",
    "# Creating a tensor with floating-point values\n",
    "float_tensor = torch.tensor([1.0, 2.0, 3.0], dtype=torch.float32)\n",
    "print(\"Float tensor:\", float_tensor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating Tensors from NumPy Arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "# Creating a NumPy array\n",
    "np_array = np.array([1.0, 2.0, 3.0])\n",
    "\n",
    "# Converting NumPy array to PyTorch tensor\n",
    "tensor_from_np = torch.tensor(np_array)\n",
    "print(\"Tensor from NumPy array:\", tensor_from_np)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic Tensor Operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Addition\n",
    "a = torch.tensor([1.0, 2.0, 3.0])\n",
    "b = torch.tensor([4.0, 5.0, 6.0])\n",
    "c = a + b\n",
    "print(\"Addition:\", c)\n",
    "\n",
    "# Multiplication\n",
    "d = a * b\n",
    "print(\"Multiplication:\", d)\n",
    "\n",
    "# Matrix Multiplication\n",
    "matrix_a = torch.tensor([[1, 2], [3, 4]])\n",
    "matrix_b = torch.tensor([[5, 6], [7, 8]])\n",
    "matrix_c = torch.mm(matrix_a, matrix_b)\n",
    "print(\"Matrix Multiplication:\\n\", matrix_c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Example Code of Object 6OD Pose Estimation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define the Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "\n",
    "# Define a simple neural network for 6D pose estimation\n",
    "class PoseEstimationNN(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(PoseEstimationNN, self).__init__()\n",
    "        self.fc1 = nn.Linear(10, 128)\n",
    "        self.fc2 = nn.Linear(128, 128)\n",
    "        self.fc3 = nn.Linear(128, 6)  # 3 for position (x, y, z) and 3 for orientation (roll, pitch, yaw)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = torch.relu(self.fc1(x))\n",
    "        x = torch.relu(self.fc2(x))\n",
    "        x = self.fc3(x)\n",
    "        return x\n",
    "\n",
    "model = PoseEstimationNN()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define the MSE Loss and Optimizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Mean Squared Error loss\n",
    "mse_loss = nn.MSELoss()\n",
    "\n",
    "# Stochastic Gradient Descent optimizer\n",
    "optimizer = optim.Adam(model.parameters(), lr=0.001)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step-by-Step Optimization\n",
    "\n",
    "1. Forward Pass: Compute predictions using the current model parameters.\n",
    "2. Compute Loss: Measure how far the predictions are from the actual values.\n",
    "3. Backward Pass: Calculate gradients of the loss with respect to each parameter.\n",
    "4. Update Parameters: Adjust parameters using the optimizer to reduce the loss."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [10/100], Loss: 1.3683\n",
      "Epoch [20/100], Loss: 0.3462\n",
      "Epoch [30/100], Loss: 0.0464\n",
      "Epoch [40/100], Loss: 0.0338\n",
      "Epoch [50/100], Loss: 0.0119\n",
      "Epoch [60/100], Loss: 0.0033\n",
      "Epoch [70/100], Loss: 0.0014\n",
      "Epoch [80/100], Loss: 0.0006\n",
      "Epoch [90/100], Loss: 0.0001\n",
      "Epoch [100/100], Loss: 0.0001\n"
     ]
    }
   ],
   "source": [
    "# Example input (features) and target (actual 6D pose)\n",
    "inputs = torch.randn(1, 10)  # Random input tensor with 10 features\n",
    "target = torch.tensor([[1.0, 2.0, 3.0, 0.1, 0.2, 0.3]])  # Example target 6D pose\n",
    "\n",
    "# Example training loop\n",
    "num_epochs = 100\n",
    "loss_history = []  # To store loss values\n",
    "\n",
    "for epoch in range(num_epochs):\n",
    "    optimizer.zero_grad()         # Zero the gradients\n",
    "    predictions = model(inputs)   # Forward pass\n",
    "    loss = mse_loss(predictions, target)  # Compute loss\n",
    "    loss.backward()               # Backward pass (compute gradients)\n",
    "    optimizer.step()              # Update parameters (optimize)\n",
    "\n",
    "    loss_history.append(loss.item())\n",
    "    \n",
    "    if (epoch+1) % 10 == 0:\n",
    "        print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualizing Optimization Progress\n",
    "\n",
    "- Plot the loss over epochs to show how the model improves.\n",
    "- Lower loss indicates better model performance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Plotting loss history\n",
    "plt.plot(range(num_epochs), loss_history)\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Loss')\n",
    "plt.title('Loss Reduction Over Time')\n",
    "plt.show()\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "summer_camp",
   "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.10.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}