notebooks/exercise solutions/00_tensor_basics_solutions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "445dff59",
   "metadata": {},
   "source": [
    "# Tensor Basics: answers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "27d27982",
   "metadata": {},
   "outputs": [],
   "source": [
    "# import libraries\n",
    "import torch\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62a137de",
   "metadata": {},
   "source": [
    "## Creating tensors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "10e30422",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exercise 1 solution:\n",
      " tensor([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10])\n",
      "\n",
      "Exercise 2 solution:\n",
      " tensor([[1., 0., 0.],\n",
      "        [0., 1., 0.],\n",
      "        [0., 0., 1.]])\n"
     ]
    }
   ],
   "source": [
    "# Exercise 1 solution\n",
    "tensor_exercise1 = torch.arange(1, 11)\n",
    "print(\"Exercise 1 solution:\\n\", tensor_exercise1)\n",
    "\n",
    "# Exercise 2 solution\n",
    "tensor_exercise2 = torch.eye(3)\n",
    "print(\"\\nExercise 2 solution:\\n\", tensor_exercise2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b7c0900",
   "metadata": {},
   "source": [
    "##  Operations with tensors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "58578988",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([-1.2649, -0.6325,  0.0000,  0.6325,  1.2649])\n"
     ]
    }
   ],
   "source": [
    "# Exercise 3 solution:\n",
    "\n",
    "# Given this tensor:\n",
    "x = torch.tensor([1.0, 2.0, 3.0, 4.0, 5.0])\n",
    "\n",
    "# Compute the mean and standard deviation\n",
    "mean = torch.mean(x)\n",
    "std = torch.std(x)\n",
    "\n",
    "# Normalize the tensor by subtracting the mean and dividing by the standard deviation\n",
    "normalized_x = (x - mean) / std\n",
    "\n",
    "# Print the normalized tensor\n",
    "print(normalized_x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "bb3b8295",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 1,  2,  3],\n",
      "        [ 4,  5,  6],\n",
      "        [ 7,  8,  9],\n",
      "        [10, 11, 12]])\n"
     ]
    }
   ],
   "source": [
    "# Exercise 4 solution:\n",
    "\n",
    "# Create the input tensors\n",
    "x = torch.tensor([[1, 2, 3], [4, 5, 6]])\n",
    "y = torch.tensor([[7, 8, 9], [10, 11, 12]])\n",
    "\n",
    "# Concatenate tensors along the rows (dimension 0)\n",
    "concatenated_tensor = torch.cat((x, y), dim=0)\n",
    "\n",
    "# Print the concatenated tensor\n",
    "print(concatenated_tensor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "bf8031e1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[[-1.4353, -1.2890],\n",
      "         [ 0.4348,  1.0837]],\n",
      "\n",
      "        [[ 0.5278,  0.8892],\n",
      "         [-0.4966, -1.0028]]])\n",
      "tensor(-1.2882)\n"
     ]
    }
   ],
   "source": [
    "# Exercise 5 solution:\n",
    "\n",
    "# Create a tensor with dimensions (2, 2, 2) filled with random values\n",
    "x = torch.randn((2, 2, 2))\n",
    "print(x)\n",
    "\n",
    "# Compute the sum of all elements\n",
    "sum_of_elements = x.sum()\n",
    "\n",
    "# Print the result\n",
    "print(sum_of_elements)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "728e1a88",
   "metadata": {},
   "source": [
    "# Manipulating tensor shapes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "cdafe879",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original Tensor Shape: torch.Size([2, 3, 4, 5])\n",
      "Reshaped Tensor Shape: torch.Size([2, 3, 20])\n"
     ]
    }
   ],
   "source": [
    "# Exercise 6 solution:\n",
    "# Create the tensor with dimensions (2, 3, 4, 5)\n",
    "tensor = torch.arange(120).reshape(2, 3, 4, 5)\n",
    "print(\"Original Tensor Shape:\", tensor.shape)\n",
    "\n",
    "# Reshape the tensor to have one less dimension using -1\n",
    "reshaped_tensor = tensor.reshape(2, 3, -1)\n",
    "print(\"Reshaped Tensor Shape:\", reshaped_tensor.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dfb870d8",
   "metadata": {},
   "source": [
    "#  Moving tensors from CPU to GPU and vice versa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "6c213bd0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Device of x (after moving to GPU): cuda:0\n",
      "Device of x (after moving back to CPU): cpu\n"
     ]
    }
   ],
   "source": [
    "# Exercise 7 solution:\n",
    "# Step 1: Create a tensor on the CPU\n",
    "x = torch.randn((3, 3))\n",
    "\n",
    "# Step 2: Move the tensor to the GPU\n",
    "x = x.to(\"cuda\") # x = x.cuda()\n",
    "\n",
    "# Step 3: Print the device attribute of x (GPU)\n",
    "print(\"Device of x (after moving to GPU):\", x.device)\n",
    "\n",
    "# Step 4: Move the tensor back to the CPU\n",
    "x = x.to(\"cpu\") # x = x.cpu()\n",
    "\n",
    "# Step 5: Print the device attribute of x (CPU)\n",
    "print(\"Device of x (after moving back to CPU):\", x.device)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}