Summary  
The chapter introduces tensors as multi-dimensional array containers, explains their dimensional types (scalars through higher-order arrays), and demonstrates how to create and print them in code.  

General domain of usage  
Deep learning

### Cosa sono i Tensori?

I tensori possono essere considerati come **array multidimensionali**. Immaginali come **contenitori di dati**, che ospitano valori in un **formato strutturato e N-dimensionale**. Puoi pensarli come i mattoni fondamentali: presi singolarmente possono sembrare semplici, ma insieme possono creare strutture complesse.

### Tipi di Tensori

Hai già incontrato i tensori, specialmente se hai utilizzato le librerie **NumPy** e **Pandas**:

- **Scalari**: semplicemente un <u>singolo numero</u>. Questo è un tensore a 0 dimensioni. Esempio: `5`;
- **Vettori**: un <u>array di numeri</u>. Questo è un tensore a 1 dimensione. Esempio: `[1, 2, 3]`;
- **Matrici**: un tensore a 2 dimensioni. Pensalo come una <u>griglia di numeri</u>. Esempio: 

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

- **Tensori 3D**: se <u>impili matrici</u>, ottieni tensori 3D;

Il tensore 3D mostrato nell'animazione sopra può essere rappresentato come:
```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]]]
```
Ogni riga corrisponde a una singola matrice (Tensore 2D).

Nota

- **Dimensioni superiori**: e puoi continuare ad aggiungere livelli per ottenere <u>dimensioni ancora maggiori</u>.

Il passaggio da tensori a bassa dimensione a tensori a dimensione superiore **può sembrare un salto**, ma rappresenta una progressione naturale quando si lavora con **strutture dati**. Più si approfondiscono le architetture delle reti neurali, in particolare le <u>reti neurali convoluzionali</u> (CNN) o le <u>reti neurali ricorrenti</u> (RNN), più spesso si incontrano questi casi. La complessità aumenta, ma ricorda che, alla base, sono semplicemente **contenitori di dati**.

### Significato nel Deep Learning

L'importanza dei tensori nel deep learning deriva dalla loro **uniformità ed efficienza**. Forniscono una struttura coerente, consentendo l'esecuzione fluida delle operazioni matematiche, **soprattutto sulle GPU**. Quando si gestiscono diverse forme di dati nelle reti neurali, come immagini o suoni, i tensori semplificano la rappresentazione dei dati, garantendo il mantenimento di forma, gerarchia e ordine.

### Creazione di tensori di base

Esistono numerosi modi per **creare un tensore** in TensorFlow, che vanno dalla generazione di dati casuali o strutturati all'importazione di dati da un dataset predefinito o persino da un file. Tuttavia, per ora, concentriamoci sul metodo più semplice: la creazione di un tensore **da una lista Python**.

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

Apprendere la costruzione, l'addestramento e la valutazione di reti neurali utilizzando TensorFlow e Keras. Questo corso copre la creazione di modelli, i cicli di addestramento personalizzati e le migliori pratiche per flussi di lavoro di deep learning efficaci. Attraverso progetti pratici e scenari reali, si acquisirà esperienza concreta con strumenti e tecniche standard del settore essenziali per l'ingegneria avanzata del deep learning.

Introduzione ai Tensori

Cosa sono i Tensori?

Tipi di Tensori

Significato nel Deep Learning

Creazione di tensori di base

Soluzione