Summary  
This chapter explains the programming concept of Tensors as N-dimensional arrays used to organize and store data, covering their various dimensional types (scalars, vectors, matrices, higher dimensions) and how to create them from Python lists using TensorFlow constants.  

General domain of usage  
Deep learning

# Introduktion til tensorer

Dette afsnit giver en dybdegående gennemgang af **tensorer**, de grundlæggende elementer i TensorFlow. Tensorer er centrale for arbejdsprocesser inden for maskinlæring og dyb læring. Dette kapitel undersøger deres betydning og anvendelser.

### Hvad er tensorer?

Tensorer kan betragtes som **multidimensionelle arrays**. Forestil dig dem som **databeholdere**, der indeholder værdier i et **struktureret, N-dimensionelt format**. De kan sammenlignes med byggesten: hver for sig virker de enkle, men sammen kan de danne komplekse strukturer.

### Typer af Tensors

Du har faktisk allerede mødt tensors før, især hvis du har arbejdet med **NumPy** og **Pandas** bibliotekerne:

- **Skalærer**: blot et enkelt tal. Dette er en 0-dimensionel tensor. Eksempel: `5`;
- **Vektorer**: et array af tal. Dette er en 1-dimensionel tensor. Eksempel: `[1, 2, 3]`;
- **Matrixer**: en 2-dimensionel tensor. Tænk på det som et gitter af tal. Eksempel: 

```python
[[1, 2]
 [3, 4]
 [5, 6]]
```

- **3D Tensors**: hvis du stabler matrixer, får du 3D tensors;

Den 3D Tensor, der vises i animationen ovenfor, kan repræsenteres som:
```python
[[[6, 9, 6], [1, 1, 2], [9, 7, 3]],
 [[1, 2, 3], [4, 5, 6], [7, 8, 9]],
 [[5, 6, 3], [5, 3, 5], [8, 8, 2]]]
```
Hver linje svarer til en individuel matrix (2D Tensor).

Bemærk

- **Højere dimensioner**: og du kan fortsætte med at stable for endnu højere dimensioner.

Overgangen fra lavere-dimensionelle til højere-dimensionelle tensorer **kan virke som et spring**, men det er en naturlig udvikling, når man arbejder med **datastrukturer**. Jo dybere du går ind i neurale netværksarkitekturer, især convolutional neural networks (CNN'er) eller recurrent neural networks (RNN'er), desto oftere vil du støde på disse. Kompleksiteten stiger, men husk, i deres kerne er de blot **databeholdere**.

### Betydning i dyb læring

Fokus på tensorer i dyb læring skyldes deres **ensartethed og effektivitet**. De giver en ensartet struktur, som muliggør matematiske operationer uden problemer, **især på GPU'er**. Ved håndtering af forskellige dataformer i neurale netværk, såsom billeder eller lyd, forenkler tensorer datarepræsentationen og sikrer, at form, hierarki og rækkefølge bevares.

### Grundlæggende tensoroprettelse

Der findes mange måder at **oprette en tensor** i TensorFlow på, lige fra generering af tilfældige eller strukturerede data til import af data fra et foruddefineret datasæt eller endda en fil. For nu fokuseres der dog på den mest enkle metode – oprettelse af en tensor **fra en Python-liste**.

import tensorflow as tf

# Create a 1D tensor
tensor_1D = tf.constant([1, 2, 3])

# Create a 2D tensor
tensor_2D = tf.constant([[1, 2, 3], [4, 5, 6]])

# Display tensor info
print(tensor_1D)
print('-' * 50)
print(tensor_2D)

import unittest
import numpy as np
import tensorflow as tf


# Helper for dynamic test messages
def _dynamic_test(test_case, condition, ok_msg, fail_msg):
    if condition:
        test_case._testMethodName = ok_msg
        test_case.assertTrue(True)
    else:
        test_case._testMethodName = fail_msg
        test_case.fail(fail_msg)


class TestUserCode(unittest.TestCase):

    def test_tensor_1D_exists(self):
        import user_code

        condition = hasattr(user_code, "tensor_1D") and isinstance(user_code.tensor_1D, tf.Tensor)

        _dynamic_test(
            self,
            condition,
            "The 1D tensor is created.",
            "Expected `tensor_1D` to be created as a TensorFlow tensor."
        )

    def test_tensor_1D_is_1D(self):
        import user_code

        condition = len(user_code.tensor_1D.shape) == 1

        _dynamic_test(
            self,
            condition,
            "The 1D tensor has rank 1.",
            "Expected `tensor_1D` to have rank 1."
        )

    def test_tensor_2D_exists(self):
        import user_code

        condition = hasattr(user_code, "tensor_2D") and isinstance(user_code.tensor_2D, tf.Tensor)

        _dynamic_test(
            self,
            condition,
            "The 2D tensor is created.",
            "Expected `tensor_2D` to be created as a TensorFlow tensor."
        )

    def test_tensor_2D_is_2D(self):
        import user_code

        condition = len(user_code.tensor_2D.shape) == 2

        _dynamic_test(
            self,
            condition,
            "The 2D tensor has rank 2.",
            "Expected `tensor_2D` to have rank 2."
        )

    def test_tensor_3D_exists(self):
        import user_code

        condition = hasattr(user_code, "tensor_3D") and isinstance(user_code.tensor_3D, tf.Tensor)

        _dynamic_test(
            self,
            condition,
            "The 3D tensor is created.",
            "Expected `tensor_3D` to be created as a TensorFlow tensor."
        )

    def test_tensor_3D_is_3D(self):
        import user_code

        condition = len(user_code.tensor_3D.shape) == 3

        _dynamic_test(
            self,
            condition,
            "The 3D tensor has rank 3.",
            "Expected `tensor_3D` to have rank 3."
        )

    def test_tensor_internal_shapes_valid(self):
        """
        Ensures that shapes are consistent (e.g., 2D tensor has rectangular shape).
        TensorFlow already enforces this, but we validate shape is fully defined.
        """
        import user_code

        t2 = user_code.tensor_2D
        t3 = user_code.tensor_3D

        condition = (
            None not in t2.shape and
            None not in t3.shape and
            len(t2.shape) == 2 and
            len(t3.shape) == 3
        )

        _dynamic_test(
            self,
            condition,
            "All tensors have consistent shapes.",
            "Expected tensors to have fully defined and consistent shapes."
        )


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


test_code.py

Dyk ned i TensorFlows verden med vores kursus, der er designet til at give dig en solid forståelse af dets kernekomponenter. Start med en udforskning af tensorer og grundlæggende elementer i TensorFlow-rammeværket. Ved kursets afslutning vil du have udviklet færdigheder til at opbygge tensorbaserede systemer, herunder at konstruere et grundlæggende neuralt netværk. Udrust dig selv med viden til at udnytte TensorFlows fulde potentiale og læg fundamentet for avancerede deep learning-studier.

Du vil opnå en grundlæggende forståelse af TensorFlows primære komponenter – tensorer. Du vil fordybe dig i tensorers natur og anvendelser, blive fortrolig med tensorers egenskaber og tilegne dig viden om væsentlige matematiske operationer.

Du vil lære, hvordan TensorFlow fungerer, samt måder at forbedre dets ydeevne på. Ved afslutningen af dette modul vil du være godt rustet til at implementere grundlæggende neurale netværk eller andre tensorberegninger ved kun at bruge TensorFlow-biblioteket uden ekstra tilføjelser.

Introduktion til Tensorer

Introduktion til tensorer

Hvad er tensorer?

Typer af Tensors

Betydning i dyb læring

Grundlæggende tensoroprettelse

Løsning