Résumons maintenant tous les sujets clés que nous avons abordés dans ce cours. N'hésitez pas à **télécharger le matériel récapitulatif** à la fin de cette page.

### Installation
```
pip install tensorflow
```
### Importation
```python
# Import the TensorFlow library with the alias tf
import tensorflow as tf
```

# Création Simple de Tenseur

```python
# 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]])

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

# Propriétés des Tenseurs

- **Rang** : Il vous indique le *nombre de dimensions* présentes dans le tenseur. Par exemple, une *matrice* a un rang de *2*. Vous pouvez obtenir le rang du tenseur en utilisant l'attribut `.ndim` :

```python
print(f'Rank of a tensor: {tensor.ndim}')
```

- **Forme** : Cela décrit combien de valeurs existent dans chaque dimension. Une matrice 2x3 a une forme de `(2, 3)`. La longueur du paramètre de forme correspond au rang du tenseur *(son nombre de dimensions)*. Vous pouvez obtenir la forme du tenseur par l'attribut `.shape` :
  
```python
print(f'Shape of a tensor: {tensor.shape}')
```

- **Types** : Les tenseurs existent en divers types de données. Bien qu'il y en ait beaucoup, certains des plus courants incluent `float32`, `int32`, et `string`. Vous pouvez obtenir le type de données du tenseur par l'attribut `.dtype` :

```python
print(f'Data type of a tensor: {tensor.dtype}')
```

# Applications des Tenseurs

- **Données Tabulaires**

# Méthodes de Création de Tenseur

```python
# Create a 2x2 constant tensor
tensor_const = tf.constant([[1, 2], [3, 4]])

# Create a variable tensor
tensor_var = tf.Variable([[1, 2], [3, 4]])

# Zero tensor of shape (3, 3)
tensor_zeros = tf.zeros((3, 3))

# Ones tensor of shape (2, 2)
tensor_ones = tf.ones((2, 2))

# Tensor of shape (2, 2) filled with 6
tensor_fill = tf.fill((2, 2), 6)

# Generate a sequence of numbers starting from 0, ending at 9
tensor_range = tf.range(10)

# Create 5 equally spaced values between 0 and 10
tensor_linspace = tf.linspace(0, 10, 5)

# Tensor of shape (2, 2) with random values normally distributed 
tensor_random = tf.random.normal((2, 2), mean=4, stddev=0.5)

# Tensor of shape (2, 2) with random values uniformly distributed 
tensor_random = tf.random.uniform((2, 2), minval=-2, maxval=2)
```

# Conversions


- NumPy à Tensor
```python
# Create a NumPy array based on a Python list
numpy_array = np.array([[1, 2], [3, 4]])

# Convert a NumPy array to a tensor
tensor_from_np = tf.convert_to_tensor(numpy_array)
```

- Pandas à Tensor
```python
# Create a DataFrame based on dictionary
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})

# Convert a DataFrame to a tensor
tensor_from_df = tf.convert_to_tensor(df.values)
```

- Tenseur Constant à un Tenseur Variable
```python
# Create a variable from a tensor
tensor = tf.random.normal((2, 3))
variable_1 = tf.Variable(tensor)

# Create a variable based on other generator
variable_2 = tf.Variable(tf.zeros((2, 2)))
```

```python
# Creating a tensor of type float16
tensor_float = tf.constant([1.2, 2.3, 3.4], dtype=tf.float16)

# Convert tensor_float from float32 to int32
tensor_int = tf.cast(tensor_float, dtype=tf.int32)
```

# Arithmétique

- Addition
```python
c1 = tf.add(a, b)  
c2 = a + b

# Changes the object inplace without creating a new one
a.assign_add(b)
```

- Soustraction
```python
c1 = tf.subtract(a, b)  
c2 = a - b 

# Inplace substraction
a.assign_sub(b)
```

- Multiplication élément par élément
```python
c1 = tf.multiply(a, b)  
c2 = a * b
```

- Division
```python
c1 = tf.divide(a, b)  
c2 = a / b 
```

# Algèbre Linéaire

- Multiplication de Matrices
```python
product1 = tf.matmul(matrix1, matrix2)
product2 = matrix1 @ matrix2
```

- Inversion de Matrice
```python
inverse_mat = tf.linalg.inv(matrix)
```

- Transposition
```python
transposed = tf.transpose(matrix)
```

- Produit Scalaire
```python
# Dot product along axes
dot_product_axes1 = tf.tensordot(matrix1, matrix2, axes=1)
dot_product_axes0 = tf.tensordot(matrix1, matrix2, axes=0)
```

```python
# Create a tensor with shape (3, 2)
tensor = tf.constant([[1, 2], [3, 4], [5, 6]])

# Reshape the tensor to shape (2, 3)
reshaped_tensor = tf.reshape(tensor, (2, 3))
```

```python
# Create a tensor
tensor = tf.constant([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# Slice tensor to extract sub-tensor from index (0, 1) of size (1, 2)
sliced_tensor = tf.slice(tensor, begin=(0, 1), size=(1, 2))

# Slice tensor to extract sub-tensor from index (1, 0) of size (2, 2)
sliced_tensor = tf.slice(tensor, (1, 0), (2, 2))
```

```python
# Create a tensor
tensor = tf.Variable([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# Change the entire first row 
tensor[0, :].assign([0, 0, 0])

# Modify the second and the third columns 
tensor[:, 1:3].assign(tf.fill((3,2), 1))
```

```python
# Create two tensors
tensor1 = tf.constant([[1, 2, 3], [4, 5, 6]])
tensor2 = tf.constant([[7, 8, 9]])

# Concatenate tensors vertically (along rows)
concatenated_tensor = tf.concat([tensor1, tensor2], axis=0)

# Concatenate tensors horizontally (along columns)
concatenated_tensor = tf.concat([tensor3, tensor4], axis=1)
```

```python
# Calculate sum of all elements
total_sum = tf.reduce_sum(tensor)

# Calculate mean of all elements
mean_val = tf.reduce_mean(tensor)

# Determine the maximum value
max_val = tf.reduce_max(tensor)

# Find the minimum value
min_val = tf.reduce_min(tensor)
```

```python
# Define input variables
x = tf.Variable(tf.fill((2, 3), 3.0))
z = tf.Variable(5.0)

# Start recording the operations
with tf.GradientTape() as tape:
    # Define the calculations
    y = tf.reduce_sum(x * x + 2 * z)
    
# Extract the gradient for the specific inputs (x and z)
grad = tape.gradient(y, [x, z])

print(f"The gradient of y with respect to x is:\n{grad[0].numpy()}")
print(f"The gradient of y with respect to z is: {grad[1].numpy()}")
```

# @tf.function

```python
@tf.function
def compute_gradient_conditional(x):
    with tf.GradientTape() as tape:
        if tf.reduce_sum(x) > 0:
            y = x * x
        else:
            y = x * x * x
    return tape.gradient(y, x)

x = tf.constant([-2.0, 2.0])
grad = compute_gradient_conditional(x)
print(f"The gradient at x = {x.numpy()} is {grad.numpy()}")
```

Quel rôle joue une fonction de perte dans un réseau de neurones ?

Plongez dans le monde de TensorFlow avec notre cours, conçu pour vous donner une compréhension solide de ses composants principaux. Commencez par une exploration des tenseurs et des bases du framework TensorFlow. À la fin du cours, vous aurez perfectionné les compétences nécessaires pour construire des systèmes basés sur les tenseurs, y compris la création d'un réseau neuronal de base. Équipez-vous des connaissances pour exploiter tout le potentiel de TensorFlow et posez les bases pour des poursuites avancées en apprentissage profond.

Vous acquerrez une compréhension fondamentale des principaux composants de TensorFlow - les Tensors. Vous explorerez la nature et les applications des Tensors, vous vous familiariserez avec les propriétés des Tensors et vous acquerrez des connaissances sur les opérations mathématiques essentielles.

Vous apprendrez comment fonctionne TensorFlow et les moyens d'améliorer ses performances. À la fin de ce module, vous serez bien équipé pour implémenter des réseaux neuronaux de base ou d'autres calculs de tensors, en utilisant uniquement la bibliothèque TensorFlow sans aucun ajout.

Introduction à TensorFlow

Résumé

Configuration de TensorFlow

Installation

Importation

Types de Tenseurs

Création Simple de Tenseur

Propriétés des Tenseurs

Axes de Tenseur

Applications des Tenseurs

Lots

Méthodes de Création de Tenseur

Conversions

Types de données

Arithmétique

Diffusion

Algèbre Linéaire

Remodeler

Découpage

Modification avec Slicing

Concatenation

Opérations de Réduction

Bande de Gradient

@tf.function