Assignment-91.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `Theoretical:`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Q1. What is different data structures used in Tensorflow ? Give some examples."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "TensorFlow, a popular open-source machine learning framework, provides several different data structures to efficiently handle and manipulate data for building and training machine learning models. Some of the key data structures used in TensorFlow include:\n",
    "\n",
    "1. `Tensors` : Tensors are the fundamental building blocks in TensorFlow. They are n-dimensional arrays that represent the data in the computation graph. Tensors can be scalars (0-dimensional), vectors (1-dimensional), matrices (2-dimensional), or higher-dimensional arrays. TensorFlow tensors can be created using functions like tf.constant(), tf.Variable(), and by performing various operations on existing tensors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "# Creating tensors\n",
    "scalar = tf.constant(5)\n",
    "vector = tf.constant([1, 2, 3])\n",
    "matrix = tf.constant([[1, 2], [3, 4]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(), dtype=int32, numpy=5>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scalar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3,), dtype=int32, numpy=array([1, 2, 3])>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(2, 2), dtype=int32, numpy=\n",
       "array([[1, 2],\n",
       "       [3, 4]])>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. `Variables`: TensorFlow Variables are special tensors that can hold mutable state. They are often used to store model parameters that need to be learned during training. Variables are typically initialized with some initial values and then updated through operations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating a variable\n",
    "initial_value = tf.random.normal(shape=(3, 3))\n",
    "model_weights = tf.Variable(initial_value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3, 3), dtype=float32, numpy=\n",
       "array([[-0.22304398, -0.5119891 , -1.1783562 ],\n",
       "       [ 0.42625085,  1.4870982 , -0.11363219],\n",
       "       [ 0.16197778,  0.6218072 ,  0.9455533 ]], dtype=float32)>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "initial_value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Variable 'Variable:0' shape=(3, 3) dtype=float32, numpy=\n",
       "array([[-0.22304398, -0.5119891 , -1.1783562 ],\n",
       "       [ 0.42625085,  1.4870982 , -0.11363219],\n",
       "       [ 0.16197778,  0.6218072 ,  0.9455533 ]], dtype=float32)>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_weights"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. `Constants`: Constants are tensors with fixed values that remain unchanged throughout the computation. They are often used for providing constant inputs or values to the computation graph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating a constant\n",
    "pi = tf.constant(3.14159)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(), dtype=float32, numpy=3.14159>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. `Placeholders (Deprecated)`: In older versions of TensorFlow (before TensorFlow 2.0), placeholders were used to feed data into the computation graph during training. However, placeholders have been deprecated in favor of the new tf.data API and eager execution in TensorFlow 2.0 and later.\n",
    "\n",
    "5. `Sparse Tensors`: Sparse tensors are designed to efficiently represent tensors with a large number of zero elements. They are useful for tasks involving sparse data, such as natural language processing or certain types of neural networks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "indices = [[0, 1], [1, 2]]\n",
    "values = [1, 2]\n",
    "shape = [3, 4]\n",
    "sparse_tensor = tf.SparseTensor(indices, values, shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SparseTensor(indices=tf.Tensor(\n",
       "[[0 1]\n",
       " [1 2]], shape=(2, 2), dtype=int64), values=tf.Tensor([1 2], shape=(2,), dtype=int32), dense_shape=tf.Tensor([3 4], shape=(2,), dtype=int64))"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sparse_tensor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6. `Ragged Tensors`: Ragged tensors are used to represent tensors with varying lengths along one or more dimensions. They are useful for sequences or nested data structures."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating a ragged tensor\n",
    "values = tf.ragged.constant([[1, 2], [3, 4, 5], [6]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.RaggedTensor [[1, 2], [3, 4, 5], [6]]>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7. `TensorArray`: TensorArray is a dynamic data structure that allows you to store tensors of different shapes and sizes. It's often used in dynamic loop constructs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating a TensorArray\n",
    "ta = tf.TensorArray(dtype=tf.float32, size=0, dynamic_size=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.ops.tensor_array_ops.TensorArray at 0x24c0378ce10>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ta"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These are some of the key data structures used in TensorFlow. TensorFlow's flexible and powerful data structure system allows developers to efficiently build and train a wide variety of machine learning models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Q2. How does TensorFlow constant differ from TensorFlow Variable? Explain with example."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Both TensorFlow constants and variables are fundamental data structures, but they have different purposes and behaviors within a TensorFlow computation graph.\n",
    "\n",
    "### TensorFlow Constants:\n",
    "- Constants are tensors with fixed values that remain unchanged throughout the computation.\n",
    "- They are typically used to provide inputs or fixed values to the computation graph.\n",
    "- Constants cannot be modified or updated after they are created.\n",
    "\n",
    "### TensorFlow Variables:\n",
    "- Variables are tensors that hold mutable state, often used for model parameters that need to be learned during training.\n",
    "- They are initialized with initial values and can be updated through operations like assignments.\n",
    "- Variables can be used to store and update values as the model iteratively adjusts its parameters during training.\n",
    "\n",
    "Let's illustrate the difference with examples:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Example of TensorFlow Constant:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error: 'tensorflow.python.framework.ops.EagerTensor' object has no attribute 'assign'\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "# Creating a constant\n",
    "a = tf.constant(5)\n",
    "\n",
    "# Attempting to assign a new value to a constant will result in an error\n",
    "try:\n",
    "    a.assign(8)  # This will raise an error\n",
    "except Exception as e:\n",
    "    print(\"Error:\", e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Example of TensorFlow Variable:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial 'b': <tf.Variable 'Variable:0' shape=(3, 3) dtype=float32, numpy=\n",
      "array([[-1.029632  , -1.6901337 ,  0.5067218 ],\n",
      "       [-1.0173848 , -0.42827913,  1.861454  ],\n",
      "       [-1.6891412 ,  0.21244563, -1.2182211 ]], dtype=float32)>\n",
      "\n",
      "Updated 'b': <tf.Variable 'Variable:0' shape=(3, 3) dtype=float32, numpy=\n",
      "array([[-1.8598624 , -0.9810076 , -0.89945763],\n",
      "       [-1.2344934 ,  0.39478645,  0.5373711 ],\n",
      "       [-0.48446256, -0.79955995,  1.5248907 ]], dtype=float32)>\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "# Creating a variable with an initial value\n",
    "initial_value = tf.random.normal(shape=(3, 3))\n",
    "b = tf.Variable(initial_value)\n",
    "\n",
    "print(\"Initial 'b':\",b)\n",
    "\n",
    "# Assigning a new value to the variable using the assign() operation\n",
    "new_value = tf.random.normal(shape=(3, 3))\n",
    "b.assign(new_value)\n",
    "\n",
    "# Now 'b' holds the new value assigned to it\n",
    "print(\"\\nUpdated 'b':\", b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the second example, you can see that a TensorFlow variable b is created with an initial value. Unlike constants, variables can be assigned new values using the assign() operation. This capability is crucial during the training process, where model parameters (weights and biases) are updated iteratively to minimize the loss function.\n",
    "\n",
    "In summary, constants are used to provide fixed inputs or values, while variables are used to hold and update mutable state, often representing model parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Q3. Describe the process of matrix addition, multiplication and element wise operations in Tensorflow."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.Matrix Addition:\n",
    "\n",
    "Matrix addition is a basic arithmetic operation where corresponding elements of two matrices are added together to create a new matrix of the same dimensions. In TensorFlow, you can perform matrix addition using the tf.add() function or by using the + operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix Addition Result:\n",
      "[[ 6  8]\n",
      " [10 12]]\n",
      "[[ 6  8]\n",
      " [10 12]]\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "# Define two matrices\n",
    "matrix_a = tf.constant([[1, 2], [3, 4]])\n",
    "matrix_b = tf.constant([[5, 6], [7, 8]])\n",
    "\n",
    "# Perform matrix addition\n",
    "result = tf.add(matrix_a, matrix_b)\n",
    "\n",
    "# Alternatively, you can use the + operator\n",
    "result_alternative = matrix_a + matrix_b\n",
    "\n",
    "print(\"Matrix Addition Result:\")\n",
    "print(result.numpy())\n",
    "print(result_alternative.numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Matrix Multiplication:\n",
    "\n",
    "Matrix multiplication is a more complex operation where the dot product of rows and columns of two matrices results in a new matrix. TensorFlow provides the tf.matmul() function to perform matrix multiplication."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix Multiplication Result:\n",
      "[[19 22]\n",
      " [43 50]]\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "# Define two matrices\n",
    "matrix_a = tf.constant([[1, 2], [3, 4]])\n",
    "matrix_b = tf.constant([[5, 6], [7, 8]])\n",
    "\n",
    "# Perform matrix multiplication\n",
    "result = tf.matmul(matrix_a, matrix_b)\n",
    "\n",
    "print(\"Matrix Multiplication Result:\")\n",
    "print(result.numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Element-wise Operations:\n",
    "Element-wise operations involve applying an operation to each corresponding element of two matrices (or a matrix and a scalar). TensorFlow allows you to perform a variety of element-wise operations, such as addition, subtraction, multiplication, division, and more."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Element-wise Addition Result:\n",
      "[[3 4]\n",
      " [5 6]]\n",
      "Element-wise Multiplication Result:\n",
      "[[2 4]\n",
      " [6 8]]\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "# Define a matrix and a scalar\n",
    "matrix = tf.constant([[1, 2], [3, 4]])\n",
    "scalar = 2\n",
    "\n",
    "# Perform element-wise addition\n",
    "result_add = matrix + scalar\n",
    "\n",
    "# Perform element-wise multiplication\n",
    "result_multiply = matrix * scalar\n",
    "\n",
    "print(\"Element-wise Addition Result:\")\n",
    "print(result_add.numpy())\n",
    "\n",
    "print(\"Element-wise Multiplication Result:\")\n",
    "print(result_multiply.numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In TensorFlow, these operations are efficiently handled using optimized numerical libraries, such as Intel MKL and NVIDIA cuBLAS, for CPU and GPU computation, respectively. These libraries allow TensorFlow to take advantage of hardware acceleration for faster computation.\n",
    "\n",
    "Remember that proper matrix dimensions and compatibility are crucial for matrix multiplication. The number of columns in the first matrix must match the number of rows in the second matrix for successful matrix multiplication. Element-wise operations require matrices or tensors to have the same shape or be broadcastable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `Practical Implementation:`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task 1 : Creating and Manipulating matrices:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Q1. Create a normal matrix A with dimensions 3x3, using Tensorflows random normal function. Display the value of matrix A."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix A:\n",
      "tf.Tensor(\n",
      "[[-0.56494653  0.4778706   1.0803455 ]\n",
      " [-0.38414574 -0.6823217   1.4904094 ]\n",
      " [ 0.37049708  0.2834071   0.6667425 ]], shape=(3, 3), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "# Create a 3x3 matrix with random values from a normal distribution\n",
    "A = tf.random.normal(shape=(3, 3))\n",
    "\n",
    "# Display the value of matrix A\n",
    "print(\"Matrix A:\")\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Q2. Create a Gaussian Matrix B with dimension 4X4, using truncated_normal function. Display the values of Matrix B."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix B:\n",
      "[[ 0.9764213   0.23991165  1.132189   -0.38087982]\n",
      " [ 0.6328638   1.5536203  -0.5070513   0.7273201 ]\n",
      " [-0.09696859  0.61838543  1.1609975  -0.87354904]\n",
      " [ 0.6232404   0.93442154  0.07971581 -0.8555197 ]]\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "# Define the dimensions of the matrix\n",
    "matrix_shape = (4, 4)\n",
    "\n",
    "# Generate a Gaussian matrix using truncated normal distribution\n",
    "mean = 0\n",
    "stddev = 1\n",
    "B = tf.random.truncated_normal(shape=matrix_shape, mean=mean, stddev=stddev)\n",
    "\n",
    "# Display the generated matrix\n",
    "print(\"Matrix B:\")\n",
    "print(B.numpy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Q3. Create a Gaussian Matrix C with dimension 2X2, where values are drawn from normal distribution with a mean of 3 and a standard deviation of 0.5, using Tensorflow's random.normal function Display values of matrix C."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix C:\n",
      "[[2.932866  2.142239 ]\n",
      " [3.2138884 3.5040686]]\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "# Define the dimensions of the matrix\n",
    "matrix_shape = (2, 2)\n",
    "\n",
    "# Generate a Gaussian matrix using normal distribution\n",
    "mean = 3.0\n",
    "stddev = 0.5\n",
    "C = tf.random.normal(shape=matrix_shape, mean=mean, stddev=stddev)\n",
    "\n",
    "# Display the generated matrix\n",
    "print(\"Matrix C:\")\n",
    "print(C.numpy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Q4. Perform matrix addition between matrix A and matrix B and store the results in matrix D."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matrix A has shape (3,3) while matrix B has shape(4,4) it is not possible to add these matrices as shapes are different Below is alternate example to show matrix addition :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix 1 :\n",
      " [[-1.0239973   0.1838543 ]\n",
      " [ 1.442575    0.48152778]]\n",
      "\n",
      "Matrix 2 :\n",
      " [[-0.11979317  0.14419222]\n",
      " [-0.6347519   1.2406929 ]]\n",
      "\n",
      "Matrix D :\n",
      " [[-1.1437905   0.3280465 ]\n",
      " [ 0.80782306  1.7222207 ]]\n"
     ]
    }
   ],
   "source": [
    "matrix1 = tf.random.normal(shape=(2,2))\n",
    "matrix2 = tf.random.normal(shape=(2,2))\n",
    "D = tf.add(matrix1, matrix2)\n",
    "print(f'Matrix 1 :\\n {matrix1.numpy()}')\n",
    "print(f'\\nMatrix 2 :\\n {matrix2.numpy()}')\n",
    "print(f'\\nMatrix D :\\n {D.numpy()}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Q5. Perform matrix multiplication between  matrix C and matrix D and store result in matrix E."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix C :\n",
      "[[2.932866  2.142239 ]\n",
      " [3.2138884 3.5040686]]\n",
      "\n",
      "Matrix D :\n",
      "[[-1.1437905   0.3280465 ]\n",
      " [ 0.80782306  1.7222207 ]]\n",
      "\n",
      "Matrix E = CxD:\n",
      "[[-1.624034   4.651525 ]\n",
      " [-0.8453474  7.0890846]]\n"
     ]
    }
   ],
   "source": [
    "E = tf.matmul(C,D)\n",
    "\n",
    "print(f'Matrix C :\\n{C.numpy()}')\n",
    "print(f'\\nMatrix D :\\n{D.numpy()}')\n",
    "print(f'\\nMatrix E = CxD:\\n{E.numpy()}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task 2: Performing additional matrix operations:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Q1. Create a matrix F with dimensions 3x3, initialized random values using Tensorflows random_uniform function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix F :\n",
      "[[0.6861063  0.57544696 0.754774  ]\n",
      " [0.0196557  0.42421722 0.5185524 ]\n",
      " [0.91495705 0.458243   0.752728  ]]\n"
     ]
    }
   ],
   "source": [
    "# Create a matrix F\n",
    "F = tf.random.uniform(shape=(3,3))\n",
    "print(f'Matrix F :\\n{F.numpy()}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Q2. Calculate Transpose of Matrix F and store in Matrix G."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix G :\n",
      "[[0.6861063  0.0196557  0.91495705]\n",
      " [0.57544696 0.42421722 0.458243  ]\n",
      " [0.754774   0.5185524  0.752728  ]]\n"
     ]
    }
   ],
   "source": [
    "# Transpose the F matrix\n",
    "G = tf.transpose(F)\n",
    "\n",
    "# Print the matrix\n",
    "print(f'Matrix G :\\n{G.numpy()}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Q3. Calculate element wise exponential of Matrix F and store the result in matrix H."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix H :\n",
      "[[1.9859678 1.777925  2.1271307]\n",
      " [1.0198501 1.5283935 1.6795945]\n",
      " [2.496668  1.5812932 2.122783 ]]\n"
     ]
    }
   ],
   "source": [
    "# Element wise exponent\n",
    "H = tf.math.exp(F)\n",
    "\n",
    "# Print matrix H\n",
    "print(f'Matrix H :\\n{H.numpy()}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Q4. Create a matrix I by concatenating Matrix F and matrix G horizontally."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix F:\n",
      "[[0.6861063  0.57544696 0.754774  ]\n",
      " [0.0196557  0.42421722 0.5185524 ]\n",
      " [0.91495705 0.458243   0.752728  ]]\n",
      "\n",
      "Matrix G:\n",
      "[[0.6861063  0.0196557  0.91495705]\n",
      " [0.57544696 0.42421722 0.458243  ]\n",
      " [0.754774   0.5185524  0.752728  ]]\n",
      "\n",
      "Matrix I (Concatenated Horizontally):\n",
      "[[0.6861063  0.57544696 0.754774   0.6861063  0.0196557  0.91495705]\n",
      " [0.0196557  0.42421722 0.5185524  0.57544696 0.42421722 0.458243  ]\n",
      " [0.91495705 0.458243   0.752728   0.754774   0.5185524  0.752728  ]]\n"
     ]
    }
   ],
   "source": [
    "# Concatenate matrices F and G horizontally to create matrix I\n",
    "I = tf.concat([F, G], axis=1)\n",
    "\n",
    "# Display the original matrices and the concatenated matrix\n",
    "print(\"Matrix F:\")\n",
    "print(F.numpy())\n",
    "\n",
    "print(\"\\nMatrix G:\")\n",
    "print(G.numpy())\n",
    "\n",
    "print(\"\\nMatrix I (Concatenated Horizontally):\")\n",
    "print(I.numpy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Q5. Create a matrix J by concatenating matrix F and matrix H vertically."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix F:\n",
      "[[0.6861063  0.57544696 0.754774  ]\n",
      " [0.0196557  0.42421722 0.5185524 ]\n",
      " [0.91495705 0.458243   0.752728  ]]\n",
      "\n",
      "Matrix H:\n",
      "[[1.9859678 1.777925  2.1271307]\n",
      " [1.0198501 1.5283935 1.6795945]\n",
      " [2.496668  1.5812932 2.122783 ]]\n",
      "\n",
      "Matrix J (Concatenated Vertically):\n",
      "[[0.6861063  0.57544696 0.754774  ]\n",
      " [0.0196557  0.42421722 0.5185524 ]\n",
      " [0.91495705 0.458243   0.752728  ]\n",
      " [1.9859678  1.777925   2.1271307 ]\n",
      " [1.0198501  1.5283935  1.6795945 ]\n",
      " [2.496668   1.5812932  2.122783  ]]\n"
     ]
    }
   ],
   "source": [
    "# Concatenate matrices F and H vertically to create matrix J\n",
    "J = tf.concat([F, H], axis=0)\n",
    "\n",
    "# Display the original matrices and the concatenated matrix\n",
    "print(\"Matrix F:\")\n",
    "print(F.numpy())\n",
    "\n",
    "print(\"\\nMatrix H:\")\n",
    "print(H.numpy())\n",
    "\n",
    "print(\"\\nMatrix J (Concatenated Vertically):\")\n",
    "print(J.numpy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.9.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}