Summary  
This chapter introduces tensors as multidimensional numerical arrays in PyTorch—extending scalars, vectors, and matrices—and shows how to create them from Python lists or NumPy arrays.  

General domain of usage  
Deep learning

You are already familiar with some special cases of tensors:
- **Scalar (0D tensor)**: a single number, like `5` or `3.14`;
- **Vector (1D tensor)**: a list of numbers, such as `[1, 2, 3]`;
- **Matrix (2D tensor)**: a 2D grid of numbers, like a table with rows and columns.

**Higher-dimensional tensors** (3D, 4D, etc.) extend the concept of **matrices** into additional dimensions. For example, a 3D tensor can represent an image with height, width, and color channels.

While the terminology may seem complex at first, the key idea is that tensors are simply containers for **numerical data**, much like **NumPy arrays**.

## Tensors in PyTorch vs. NumPy Arrays

PyTorch tensors behave similarly to **NumPy arrays** in many ways. Additionally, **indexing and slicing** in tensors work the same way as in NumPy arrays, so we won't cover these topics in this course.

However, PyTorch tensors offer additional advantages, such as:

- Native support for **GPU acceleration**;
- Integration with PyTorch's deep learning modules;
- Compatibility with autograd, PyTorch's automatic differentiation tool for **backpropagation**.

## Creating Tensors

PyTorch provides several ways to create tensors. One of the most basic approaches is to create a tensor from a **list** or a **NumPy array**. The recommended way to do this is by passing the data to the `torch.tensor()` function:

import torch
data = [[1, 2], [3, 4]]
tensor = torch.tensor(data)
print(tensor)

import unittest
import importlib
import torch


def _dynamic(test, cond, ok, fail):
    if cond:
        test._testMethodName = ok
        test.assertTrue(True)
    else:
        test._testMethodName = fail
        test.fail(fail)


class TestUserCode(unittest.TestCase):

    def test_tensor_exists(self):
        import user_code
        cond = hasattr(user_code, "tensor_3d")

        _dynamic(
            self,
            cond,
            "The `tensor_3d` variable is successfully created.",
            "The `tensor_3d` variable is missing. Make sure you assign your 3D tensor to `tensor_3d`."
        )

    def test_tensor_is_torch_tensor(self):
        import user_code
        try:
            cond = isinstance(user_code.tensor_3d, torch.Tensor)
        except:
            cond = False

        _dynamic(
            self,
            cond,
            "`tensor_3d` is correctly created as a PyTorch tensor.",
            "`tensor_3d` must be a PyTorch tensor. Ensure you create it using `torch.tensor()`."
        )

    def test_tensor_is_3d(self):
        import user_code
        try:
            cond = user_code.tensor_3d.ndim == 3
        except:
            cond = False

        _dynamic(
            self,
            cond,
            "`tensor_3d` has the correct dimensionality (3D).",
            "`tensor_3d` must be a 3-dimensional tensor. Use a 3-level nested Python list inside `torch.tensor()`."
        )

    def test_created_from_literal_list(self):
        with open("user_code.py") as f:
            src = f.read()

        cond = "torch.tensor([" in src or "torch.tensor([[" in src

        _dynamic(
            self,
            cond,
            "`tensor_3d` is created directly from a literal 3D Python list.",
            "Your tensor must be created directly from a literal 3D list. Do not store the list in a separate variable before passing it to `torch.tensor()`."
        )


if __name__ == "__main__":
    unittest.main()


test_code.py

Learn the fundamental and advanced concepts needed to work with PyTorch efficiently. Gain a solid understanding tensors, including creation, operations, and reshaping. Explore the essentials of gradients, backpropagation, and linear regression before moving on to handling datasets. Master the skill needed build, train, and evaluate neural networks.

Introduction to Tensors

What is a Tensor?

Tensors in PyTorch vs. NumPy Arrays

Creating Tensors

Lösung