Update pages/3_WithExercises.py

pages/3_WithExercises.py

@@ -2,8 +2,6 @@ import streamlit as st
 import torch
 import io
 import sys
-import numpy as np
-import time
 
 # Function to execute the input code and capture print statements
 def execute_code(code):
@@ -29,6 +27,9 @@ exercises = {
     "Exercise 1: Create and Manipulate Tensors": {
         "description": "Tensors are the core data structure in PyTorch, similar to arrays in NumPy but with additional capabilities for GPU acceleration. This exercise introduces how to create tensors from various data sources such as lists and NumPy arrays. It also covers basic tensor operations like addition, subtraction, and element-wise multiplication, which are fundamental for manipulating data in PyTorch.",
         "code": '''
+import torch
+import numpy as np
+
 # Creating tensors from Python lists
 # This creates a 1D tensor from the list [1, 2, 3]
 tensor_from_list = torch.tensor([1, 2, 3])
@@ -60,6 +61,8 @@ print("Element-wise Multiplication:", elementwise_multiplication)
     "Exercise 2: Tensor Indexing and Slicing": {
         "description": "Indexing and slicing allow you to access and manipulate specific elements and sub-tensors. This is crucial for tasks such as data preprocessing and manipulation in machine learning workflows. This exercise demonstrates how to index and slice tensors to extract and modify elements efficiently.",
         "code": '''
+import torch
+
 # Creating a 2D tensor (matrix)
 tensor = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
 
@@ -86,6 +89,8 @@ print("Modified tensor:\n", tensor)
     "Exercise 3: Tensor Reshaping and Transposing": {
         "description": "Reshaping and transposing tensors are common operations when preparing data for neural networks. Reshaping allows you to change the layout of tensor data without altering its data. Transposing changes the orientation of the data, which is useful for operations like matrix multiplication. This exercise covers reshaping using `view()` and `reshape()`, and transposing using `transpose()` and `permute()`.",
         "code": '''
+import torch
+
 # Creating a 2D tensor
 tensor = torch.tensor([[1, 2, 3], [4, 5, 6]])
 
@@ -113,6 +118,8 @@ print("Permuted tensor shape:", permuted_tensor.shape)
     "Exercise 4: Tensor Operations and Broadcasting": {
         "description": "Broadcasting in PyTorch allows you to perform arithmetic operations on tensors of different shapes. This can simplify code and reduce the need for explicit reshaping. This exercise demonstrates matrix multiplication, the concept of broadcasting, and the application of element-wise functions like sine and exponential.",
         "code": '''
+import torch
+
 # Matrix multiplication
 tensor1 = torch.tensor([[1, 2], [3, 4]])
 tensor2 = torch.tensor([[5, 6], [7, 8]])
@@ -146,6 +153,8 @@ print("Square root of tensor3:", sqrt_result)
     "Exercise 5: Tensor Initialization": {
         "description": "Proper initialization of tensors is crucial for neural network training and other machine learning tasks. This exercise explores various methods to initialize tensors, such as filling them with zeros, ones, random values, and specific distributions. Understanding these methods helps in setting up model parameters and test data.",
         "code": '''
+import torch
+
 # Creating tensors filled with zeros and ones
 zeros_tensor = torch.zeros(3, 3)
 print("Zeros tensor:\n", zeros_tensor)
@@ -179,6 +188,8 @@ print("Uniform distribution tensor:\n", uniform_tensor)
     "Exercise 6: Tensor Arithmetic Operations": {
         "description": "Arithmetic operations on tensors are essential for numerous tasks in machine learning, including data preprocessing and neural network computations. This exercise covers basic arithmetic with tensors, in-place operations, and aggregation functions that compute summaries over tensor elements.",
         "code": '''
+import torch
+
 # Creating a 1D tensor
 tensor = torch.tensor([1.0, 2.0, 3.0])
 
@@ -215,6 +226,8 @@ print("Maximum element:", max_all)
     "Exercise 7: Tensor Comparison and Logical Operations": {
         "description": "Comparison and logical operations enable you to make conditional selections and perform logical checks on tensors. This is crucial for tasks such as filtering data and implementing decision-based logic in machine learning workflows. This exercise demonstrates the use of comparison operators and logical functions, which are often used in neural network training and data analysis.",
         "code": '''
+import torch
+
 # Creating two tensors for comparison
 tensor1 = torch.tensor([1, 2, 3])
 tensor2 = torch.tensor([3, 2, 1])
@@ -250,6 +263,8 @@ print("Conditional selection:", selected_tensor)
     "Exercise 8: Tensor Reduction Operations": {
         "description": "Reduction operations aggregate tensor elements along specified dimensions, providing summarized results like sums, means, and indices of maximum or minimum values. This exercise covers essential reduction operations, which are commonly used in loss functions and performance metrics in machine learning.",
         "code": '''
+import torch
+
 # Creating a 2D tensor (matrix)
 tensor = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
 
@@ -279,6 +294,8 @@ print("Indices of minimum elements along dimension 0:", argmin_dim0)
     "Exercise 9: Tensor Cloning and Detachment": {
         "description": "Cloning and detaching tensors are important when working with gradients in neural networks. Cloning creates a copy of a tensor, while detaching removes it from the computation graph to prevent gradient tracking. This exercise demonstrates these operations, which are crucial for managing tensor operations in complex neural networks.",
         "code": '''
+import torch
+
 # Creating a tensor with gradient tracking enabled
 tensor = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)
 
@@ -303,6 +320,9 @@ print("Detached tensor remains unchanged:", detached_tensor)
     "Exercise 10: GPU Operations with Tensors": {
         "description": "Utilizing GPUs can significantly speed up tensor operations, which is crucial for training large neural networks. This exercise covers checking for GPU availability, moving tensors to GPU, and performing operations on GPU to compare performance with CPU operations.",
         "code": '''
+import torch
+import time
+
 # Check for GPU availability
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 print("Using device:", device)