Summary
This chapter introduces tensors as multidimensional numeric containers similar to NumPy arrays and shows how to create PyTorch tensors from Python lists or NumPy arrays, highlighting features like GPU acceleration and integration with automatic differentiation.

General domain of usage
Deep learning

En **tensor** er et generalisert matematisk objekt som kan representere data i én eller flere dimensjoner. Tenk på en tensor som et **multidimensjonalt array**.

Definisjon

Du er allerede kjent med noen spesialtilfeller av tensorer:
- **Skalar (0D tensor)**: et enkelt tall, som `5` eller `3.14`;
- **Vektor (1D tensor)**: en liste med tall, for eksempel `[1, 2, 3]`;
- **Matrise (2D tensor)**: et todimensjonalt rutenett av tall, som en tabell med rader og kolonner.

**Tensorkonstruksjoner med høyere dimensjoner** (3D, 4D, osv.) utvider konseptet **matriser** til flere dimensjoner. For eksempel kan en 3D-tensor representere et bilde med høyde, bredde og fargekanaler.

Selv om terminologien kan virke kompleks i starten, er hovedideen at tensorer ganske enkelt er beholdere for **numeriske data**, på samme måte som **NumPy-arrays**.

## Tensorkonstruksjoner i PyTorch vs. NumPy-arrays

PyTorch-tensorkonstruksjoner oppfører seg på mange måter likt som **NumPy-arrays**. I tillegg fungerer **indeksering og slicing** i tensorer på samme måte som i NumPy-arrays, så disse temaene vil ikke bli dekket i dette kurset.

PyTorch-tensorkonstruksjoner gir imidlertid flere fordeler, som:

- Naturlig støtte for **GPU-akselerasjon**;
- Integrasjon med PyTorchs moduler for dyp læring;
- Kompatibilitet med autograd, PyTorchs verktøy for automatisk differensiering for **backpropagation**.

## Opprette Tensors

PyTorch tilbyr flere måter å opprette tensors på. En av de mest grunnleggende metodene er å opprette en tensor fra en **liste** eller et **NumPy-array**. Den anbefalte måten å gjøre dette på er ved å sende dataene til funksjonen `torch.tensor()`:

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

Gå fra høynivå-biblioteker til fleksibiliteten i PyTorch. Behersk byggesteinene i dyp læring ved å arbeide med Tensors, den sentrale datastrukturen i PyTorch. Utforsk automatisk differensiering med gradienter, implementer tilbakepropagering, og bygg komplette nevrale nettverk fra bunnen av. Lær å håndtere datasett fra virkeligheten og administrere hele treningssyklusen – fra vektinitialisering til modelevaluering.

Introduksjon til Tensorer

Hva er en tensor?

Tensorkonstruksjoner i PyTorch vs. NumPy-arrays

Opprette Tensors

Løsning