Lassen Sie uns nun alle wichtigen Themen zusammenfassen, die wir in diesem Kurs besprochen haben. Fühlen Sie sich frei, das **Übersichtsmaterial am Ende dieser Seite herunterzuladen**.

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

# Einfache Tensor-Erstellung

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

# Tensor-Eigenschaften

- **Rang**: Er gibt die *Anzahl der Dimensionen* an, die im Tensor vorhanden sind. Zum Beispiel hat eine *Matrix* einen Rang von *2*. Sie können den Rang des Tensors mit dem Attribut `.ndim` erhalten:

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

- **Form**: Diese beschreibt, wie viele Werte in jeder Dimension existieren. Eine 2x3-Matrix hat eine Form von `(2, 3)`. Die Länge des Formparameters entspricht dem Rang des Tensors *(seiner Anzahl an Dimensionen)*. Sie können die Form des Tensors mit dem Attribut `.shape` erhalten:
  
```python
print(f'Shape of a tensor: {tensor.shape}')
```

- **Typen**: Tensors gibt es in verschiedenen Datentypen. Während es viele gibt, sind einige gängige `float32`, `int32` und `string`. Sie können den Datentyp des Tensors mit dem Attribut `.dtype` erhalten:

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

# Anwendungen von Tensoren

- **Tabellendaten**

# Tensor-Erstellungsmethoden

```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)
```

# Konvertierungen


- NumPy zu 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 zu 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)
```

- Konstanter Tensor zu einem Variablen-Tensor
```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)
```

# Arithmetik

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

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

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

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

- Elementweise Multiplikation
```python
c1 = tf.multiply(a, b)  
c2 = a * b
```

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

# Lineare Algebra

- Matrixmultiplikation
```python
product1 = tf.matmul(matrix1, matrix2)
product2 = matrix1 @ matrix2
```

- Matrixinversion
```python
inverse_mat = tf.linalg.inv(matrix)
```

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

- Skalarprodukt
```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()}")
```

Welche Rolle spielt eine Verlustfunktion in einem neuronalen Netzwerk?

Tauchen Sie tief in die Welt von TensorFlow ein mit unserem Kurs, der Ihnen ein solides Verständnis seiner Kernkomponenten vermittelt. Beginnen Sie mit einer Erkundung von Tensors und den Grundlagen des TensorFlow-Frameworks. Am Ende des Kurses werden Sie die Fähigkeiten entwickelt haben, tensorbasierte Systeme zu erstellen, einschließlich der Entwicklung eines einfachen neuronalen Netzwerks. Rüsten Sie sich mit dem Wissen aus, um das volle Potenzial von TensorFlow zu nutzen und die Grundlage für fortgeschrittene Deep-Learning-Bestrebungen zu legen.

Sie werden ein grundlegendes Verständnis der primären Komponenten von TensorFlow - Tensors - erlangen. Sie werden sich mit der Natur und den Anwendungen von Tensors befassen, sich mit den Eigenschaften von Tensors vertraut machen und Kenntnisse in wesentlichen mathematischen Operationen erwerben.

Sie lernen, wie TensorFlow funktioniert und wie Sie seine Leistung verbessern können. Am Ende dieses Moduls sind Sie gut gerüstet, um grundlegende neuronale Netzwerke oder andere Tensorberechnungen zu implementieren, indem Sie nur die TensorFlow-Bibliothek ohne Extras verwenden.

Einführung in TensorFlow

Zusammenfassung

Tensorflow Einrichtung

Installation

Importieren

Tensorarten

Einfache Tensor-Erstellung

Tensor-Eigenschaften

Tensorachsen

Anwendungen von Tensoren

Batches

Tensor-Erstellungsmethoden

Konvertierungen

Datentypen

Arithmetik

Broadcasting

Lineare Algebra

Umformen

Slicing

Modifizieren mit Slicing

Verkettung

Reduktionsoperationen

Gradientband

@tf.function