Tensorflow ist eine Bibliothek zum Erstellen und trainieren von [[machine_learning|neuronalen Netzwerken]]. 

=====Arten von Modellen=====

In TensorFlow, einer weit verbreiteten Deep-Learning-Bibliothek, gibt es verschiedene Arten von Modellen, die verwendet werden können, um neuronale Netzwerke aufzubauen.

[[https://www.youtube.com/watch?v=EvGS3VAsG4Y|Sequencial vs functional API]]
====Sequential====

Das Sequential-Modell ist die einfachste Art von Modell in TensorFlow. Es besteht aus einer linearen Stapelung von Schichten, wobei jede Schicht direkt mit der vorherigen verbunden ist. Es eignet sich gut für einfache sequentielle Aufgaben, bei denen keine Rückkopplungsschleifen oder mehrere Eingänge/Ausgänge vorhanden sind. 

<code python>
import tensorflow as tf

model = tf.keras.Sequential([
    tf.keras.layers.Dense(64, activation='relu', input_shape=(input_dim,)),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.Dense(num_classes, activation='softmax')
])
</code>

====Functional====

Das Functional-Modell ermöglicht eine größere Flexibilität als das Sequential-Modell. Es ermöglicht die Erstellung von Modellen mit mehreren Eingängen und Ausgängen sowie komplexeren Architekturen wie verzweigten Schichten und Rückkopplungsschleifen.

<code python>
import tensorflow as tf

inputs = tf.keras.Input(shape=(input_dim,))
x = tf.keras.layers.Dense(64, activation='relu')(inputs)
x = tf.keras.layers.Dense(64, activation='relu')(x)
outputs = tf.keras.layers.Dense(num_classes, activation='softmax')(x)

model = tf.keras.Model(inputs=inputs, outputs=outputs)
</code>

====Subclassing====

Das Subclassing-Modell ermöglicht die ultimative Flexibilität bei der Erstellung von Modellen in TensorFlow. Mit dieser Methode können benutzerdefinierte Schichten und Berechnungen erstellt werden. Das Modell wird erstellt, indem eine Unterklasse der tf.keras.Model Klasse erstellt und die erforderlichen Schichten und Berechnungen definiert werden.

<code python>
import tensorflow as tf

class MyModel(tf.keras.Model):
    def __init__(self):
        super(MyModel, self).__init__()
        self.dense1 = tf.keras.layers.Dense(64, activation='relu')
        self.dense2 = tf.keras.layers.Dense(64, activation='relu')
        self.dense3 = tf.keras.layers.Dense(num_classes, activation='softmax')

    def call(self, inputs):
        x = self.dense1(inputs)
        x = self.dense2(x)
        return self.dense3(x)

model = MyModel()
</code>

====Convolutional====

CNNs sind speziell für die Verarbeitung von Bildern entwickelt worden. Sie bestehen aus speziellen Schichten wie Convolutional-Layern und Pooling-Layern, die Muster in Bildern erkennen können. CNNs haben in der Bilderkennung und im Computersehen beeindruckende Erfolge erzielt.

<code python>
import tensorflow as tf

model = tf.keras.Sequential([
    tf.keras.layers.Conv2D(32, (3, 3), activation='relu', input_shape=(image_height, image_width, channels)),
    tf.keras.layers.MaxPooling2D((2, 2)),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.Dense(num_classes, activation='softmax')
])
</code>

====Recurrent====

RNNs sind darauf spezialisiert, sequenzielle Daten zu verarbeiten, bei denen die vorherigen Schritte den aktuellen beeinflussen. Sie sind besonders nützlich für Aufgaben wie Spracherkennung und maschinelles Übersetzen. TensorFlow bietet verschiedene RNN-Schichttypen wie SimpleRNN, LSTM und GRU.

<code python>
import tensorflow as tf

model = tf.keras.Sequential([
    tf.keras.layers.SimpleRNN(64, input_shape=(sequence_length, input_dim)),
    tf.keras.layers.Dense(num_classes, activation='softmax')
])
</code>

  * Long Short-Term Memory (LSTM): LSTMs sind eine Art von RNN mit einer spezialisierten Speicherzelle, die es ihnen ermöglicht, lange Abhängigkeiten in sequenziellen Daten zu erfassen. Sie eignen sich gut für Aufgaben, die lange Abhängigkeiten involvieren, und werden häufig für verschiedene Sequenz-zu-Sequenz-Aufgaben wie maschinelle Übersetzung und Textgenerierung eingesetzt.
  * Gated Recurrent Unit (GRU): GRUs sind eine andere Variante von RNNs mit einer vereinfachten Struktur im Vergleich zu LSTMs, aber auch mit Gating-Mechanismen zur Steuerung des Informationsflusses. Sie sind rechentechnisch weniger aufwendig als LSTMs und liefern oft ähnliche Ergebnisse, wodurch sie eine beliebte Wahl für Sequenzmodellierungsaufgaben sind.
  * Bidirectional RNN: In einem bidirektionalen RNN wird die Eingabesequenz sowohl in Vorwärts- als auch in Rückwärtsrichtung verarbeitet. Dadurch kann das RNN vergangenen und zukünftigen Kontext bei Vorhersagen berücksichtigen. [[https://en.wikipedia.org/wiki/Named-entity_recognition|Named Entity Recognition]] und [[https://en.wikipedia.org/wiki/Sentiment_analysis|Sentiment analysis]].
  * Attention-based RNN: Attention-Mechanismen werden verwendet, um sich auf bestimmte Teile der Eingabesequenz zu konzentrieren, während Vorhersagen getroffen werden. RNNs mit Attention sind besonders nützlich, wenn verschiedene Teile der Eingabesequenz unterschiedlich zum Ergebnis beitragen.
  * Transformer: Der Transformer ist eine Art von Architektur, die nicht auf rekurrente Verbindungen angewiesen ist, sondern Selbst-Aufmerksamkeitsmechanismen nutzt. Er ist aufgrund seiner Parallelisierungsfähigkeiten und der Fähigkeit, lange Sequenzen effektiv zu verarbeiten, bei verschiedenen Aufgaben der natürlichen Sprachverarbeitung beliebt geworden.
  * Clockwork RNN: Clockwork RNNs haben unterschiedliche Zeitschritte für verschiedene Neuronen in der versteckten Schicht. Dadurch können verschiedene Teile des Netzwerks mit unterschiedlichen Frequenzen arbeiten, was bei Daten mit hierarchischen zeitlichen Mustern hilfreich sein kann.
  * Echo State Network (ESN): ESN ist eine Art von [[https://en.wikipedia.org/wiki/Reservoir_computing|Reservoir-Computing]]-Netzwerk, bei dem die versteckte Schicht spärlich und zufällig verbunden ist. Die rekurrenten Verbindungen sind festgelegt und nur die Ausgabeschicht wird trainiert. ESNs wurden in verschiedenen Aufgaben der Zeitreihenvorhersage eingesetzt.
  * Hierarchical RNN: Hierarchische RNNs stapeln mehrere RNN-Schichten, um hierarchische Repräsentationen sequenzieller Daten zu lernen. Dies kann hilfreich sein, wenn Daten mehrere Ebenen von zeitlichen Abhängigkeiten aufweisen.
  * Dilated RNN: Dilated RNNs verwenden verdünnte (oder spärliche) Faltungen in der rekurrenten Schicht, wodurch das Netzwerk ein größeres [[https://de.wikipedia.org/wiki/Rezeptives_Feld|Rezeptivfeld]] erhält, ohne die Berechnung erheblich zu erhöhen.
====Transfer Learning====

Transfer Learning ermöglicht es, vortrainierte Modelle zu verwenden und sie für neue Aufgaben anzupassen. Anstatt ein Modell von Grund auf neu zu trainieren, können Sie ein bereits trainiertes Modell nehmen und es auf Ihren spezifischen Datensatz feinabstimmen. Dies ist besonders nützlich, wenn Sie über begrenzte Daten verfügen.

<code python>
import tensorflow as tf

base_model = tf.keras.applications.MobileNetV2(input_shape=(image_height, image_width, channels),
                                               include_top=False,
                                               weights='imagenet')

model = tf.keras.Sequential([
    base_model,
    tf.keras.layers.GlobalAveragePooling2D(),
    tf.keras.layers.Dense(num_classes, activation='softmax')
])
</code>

====Transformer====

Transformer-Modelle haben in der natürlichen Sprachverarbeitung große Aufmerksamkeit erlangt, insbesondere durch den Erfolg des Modells "GPT" (Generative Pre-trained Transformer). Diese Modelle verwenden Aufmerksamkeitsmechanismen, um die Beziehungen zwischen den Wörtern in einem Text zu modellieren.

<code python>
import tensorflow as tf

model = tf.keras.Sequential([
    tf.keras.layers.Input(shape=(sequence_length,), dtype=tf.int32),
    tf.keras.layers.Embedding(vocab_size, embedding_dim),
    tf.keras.layers.Transformer(num_layers=2, d_model=128, num_heads=4, 
                                dff=512, input_vocab_size=vocab_size,
                                maximum_position_encoding=1000),
    tf.keras.layers.Dense(vocab_size, activation='softmax')
])
</code>

====GAN====

GANs (Generative Adversarial Networks) sind eine Art von Deep-Learning-Modell, bei dem ein Generator-Modell versucht, Daten zu generieren, die von einem Diskriminator-Modell nicht von echten Daten unterschieden werden können. GANs werden häufig für die Generierung von Bildern, Videos oder Musik verwendet. TensorFlow bietet Möglichkeiten zur Implementierung von GANs, einschließlich der Verwendung von convolutional oder transformativen Modellen für den Generator und des Diskriminators.

<code python>
import tensorflow as tf

# Generator-Modell
generator = tf.keras.Sequential([
    tf.keras.layers.Dense(256, input_dim=100, activation='relu'),
    tf.keras.layers.Dense(512, activation='relu'),
    tf.keras.layers.Dense(28*28, activation='sigmoid'),
    tf.keras.layers.Reshape((28, 28))
])

# Diskriminator-Modell
discriminator = tf.keras.Sequential([
    tf.keras.layers.Flatten(input_shape=(28, 28)),
    tf.keras.layers.Dense(512, activation='relu'),
    tf.keras.layers.Dense(256, activation='relu'),
    tf.keras.layers.Dense(1, activation='sigmoid')
])

# GAN-Modell
gan = tf.keras.Sequential([generator, discriminator])
</code>

====Autoencoder====

Autoencoder-Modelle werden für die Dimensionalitätsreduktion, Datenkompression oder die Generierung von ähnlichen Daten verwendet. Sie bestehen aus einem Encoder, der die Eingangsdaten in einen latenten Vektor komprimiert, und einem Decoder, der den latenten Vektor in die ursprünglichen Daten rekonstruiert. TensorFlow ermöglicht die Erstellung von Autoencodern mit verschiedenen Architekturen wie den klassischen Fully Connected Autoencodern oder Convolutional Autoencodern.

<code python>
import tensorflow as tf

# Fully Connected Autoencoder
input_dim = 784
encoding_dim = 32

input_layer = tf.keras.layers.Input(shape=(input_dim,))
encoder = tf.keras.layers.Dense(encoding_dim, activation='relu')(input_layer)
decoder = tf.keras.layers.Dense(input_dim, activation='sigmoid')(encoder)

autoencoder = tf.keras.Model(inputs=input_layer, outputs=decoder)

# Convolutional Autoencoder
input_shape = (28, 28, 1)
latent_dim = 16

input_layer = tf.keras.layers.Input(shape=input_shape)
encoder = tf.keras.layers.Conv2D(latent_dim, (3, 3), activation='relu', padding='same')(input_layer)
decoder = tf.keras.layers.Conv2DTranspose(1, (3, 3), activation='sigmoid', padding='same')(encoder)

autoencoder = tf.keras.Model(inputs=input_layer, outputs=decoder)
</code>

====Siamese====

Siamese Networks sind spezielle Modelle, die verwendet werden, um Ähnlichkeiten oder Vergleiche zwischen Eingangsdaten zu bewerten. Sie werden oft in Anwendungen wie Bildvergleich, Gesichtserkennung oder Textmatching eingesetzt. TensorFlow ermöglicht die Erstellung von Siamese Networks mit geteilten Gewichten, um Paare von Eingangsdaten zu vergleichen und eine Ähnlichkeitsbewertung zu generieren.

<code python>
import tensorflow as tf

# Siamese Network
input_shape = (64, 64, 3)
embedding_dim = 128

input_a = tf.keras.layers.Input(shape=input_shape)
input_b = tf.keras.layers.Input(shape=input_shape)

base_model = tf.keras.applications.ResNet50(include_top=False, weights='imagenet', pooling='avg')
base_model.trainable = False

embedding_a = base_model(input_a)
embedding_b = base_model(input_b)

distance = tf.keras.layers.DistanceMetric()(embedding_a, embedding_b)

siamese_model = tf.keras.Model(inputs=[input_a, input_b], outputs=distance)
</code>

====Reinforcement====

Reinforcement Learning (Verstärkungslernen) verwendet eine Agenten-Umgebung-Interaktion, um ein Ziel zu erreichen. TensorFlow unterstützt die Implementierung von Reinforcement Learning-Algorithmen wie Q-Learning, Deep Q-Networks (DQN) oder Proximal Policy Optimization (PPO). Diese Modelle werden in Aufgaben wie Spielagenten, Robotiksteuerung oder Portfoliooptimierung eingesetzt.

<code python>
import tensorflow as tf

# Q-Learning
num_actions = 4
state_shape = (84, 84, 4)

model = tf.keras.Sequential([
    tf.keras.layers.Conv2D(32, (8, 8), strides=(4, 4), activation='relu', input_shape=state_shape),
    tf.keras.layers.Conv2D(64, (4, 4), strides=(2, 2), activation='relu'),
    tf.keras.layers.Conv2D(64, (3, 3), strides=(1, 1), activation='relu'),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(512, activation='relu'),
    tf.keras.layers.Dense(num_actions)
])

# Deep Q-Network (DQN)
num_actions = 4
state_shape = (84, 84, 4)

input_layer = tf.keras.layers.Input(shape=state_shape)
conv1 = tf.keras.layers.Conv2D(32, (8, 8), strides=(4, 4), activation='relu')(input_layer)
conv2 = tf.keras.layers.Conv2D(64, (4, 4), strides=(2, 2), activation='relu')(conv1)
conv3 = tf.keras.layers.Conv2D(64, (3, 3), strides=(1, 1), activation='relu')(conv2)
flatten = tf.keras.layers.Flatten()(conv3)
dense1 = tf.keras.layers.Dense(512, activation='relu')(flatten)
output_layer = tf.keras.layers.Dense(num_actions)(dense1)

model = tf.keras.Model(inputs=input_layer, outputs=output_layer)

# Proximal Policy Optimization (PPO)
num_actions = 4
state_shape = (84, 84, 4)

input_layer = tf.keras.layers.Input(shape=state_shape)
conv1 = tf.keras.layers.Conv2D(32, (8, 8), strides=(4, 4), activation='relu')(input_layer)
conv2 = tf.keras.layers.Conv2D(64, (4, 4), strides=(2, 2), activation='relu')(conv1)
conv3 = tf.keras.layers.Conv2D(64, (3, 3), strides=(1, 1), activation='relu')(conv2)
flatten = tf.keras.layers.Flatten()(conv3)
dense1 = tf.keras.layers.Dense(512, activation='relu')(flatten)

action_logits = tf.keras.layers.Dense(num_actions)(dense1)
value = tf.keras.layers.Dense(1)(dense1)

model = tf.keras.Model(inputs=input_layer, outputs=[action_logits, value])
</code>
=====Pattern Recognition Example=====

<code python>
import numpy as np
from tensorflow.keras.models import Sequential, model_from_json, load_model
from tensorflow.keras.layers import LSTM, Dense, SimpleRNN

original_data = np.array([
    [1, 0, 1, 1, 1, 0, 1, 1],
    [1, 1, 0, 0, 1, 1, 0, 0],
    [0, 1, 0, 1, 1, 1, 0, 1],
    [1, 1, 1, 0, 0, 0, 1, 0],
    [1, 0, 0, 1, 1, 1, 0, 0],
    [1, 0, 1, 1, 1, 0, 0, 1],
    [0, 0, 1, 1, 0, 1, 0, 0],
    [1, 0, 1, 1, 0, 1, 1, 0],
    [1, 0, 1, 1, 1, 1, 1, 0],
    [1, 0, 1, 0, 1, 1, 1, 0]
])

original_labels = np.array([1, 0, 1, 0, 1, 1, 0, 0, 1, 0])

data_with_labels = np.column_stack((original_data, original_labels))
np.savetxt('training_data.csv', data_with_labels, delimiter=', ', fmt='%d')


loaded_data_with_labels = np.loadtxt('training_data.csv', delimiter=',')
data = loaded_data_with_labels[:, :-1]
labels = loaded_data_with_labels[:, -1]

# fit the input layer
#data = data.reshape(data.shape[0], data.shape[1], 1)

model = Sequential()

model.add(LSTM(16, input_shape=(data.shape[1], 1)))
# model.add(SimpleRNN(16, input_shape=(data.shape[1], 1)))

model.add(Dense(1, activation='sigmoid'))

model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

model.fit(data, labels, epochs = 100, batch_size = 1, verbose = True)

model.summary()

# native keras format (includes model and weights)
model.save('my_model.keras')

# separate model and weights in hdf5 format
#model.save('my_model')
#model.save_weights('my_model\\weights.h5')

# only a description of the model in json format and the weights in hdf5 format
#open("my_model.json", "w").write(model.to_json())
#model.save_weights('my_model_weights.h5')

del model

# native keras format (includes model and weights)
model = load_model('my_model.keras')

# separate model and weights in hdf5 format
#model = load_model('my_model')
#model.load_weights('my_model\\weights.h5')

# only a description of the model in json format and the weights in hdf5 format
#model = model_from_json( open("my_model.json", "r").read() )
#model.load_weights('my_model_weights.h5')

seed = np.array([[1, 0, 1, 1, 0, 1, 1, 0]])
seed = seed.reshape(seed.shape[0], seed.shape[1], 1)

prediction = model.predict(seed)

prediction = (prediction >= 0.5).astype(int)

print(prediction)
</code>

=====Mnist Image Example=====

Taken from several tutorials

  * [[https://machinelearningmastery.com/how-to-develop-a-generative-adversarial-network-for-an-mnist-handwritten-digits-from-scratch-in-keras/]]
  * [[https://github.com/kroosen/GAN-in-keras-on-mnist/blob/master/GAN-keras-mnist-DCGAN.ipynb]]
====Train images====
<code python>
import numpy as np
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Reshape, Flatten
from tensorflow.keras.layers import Conv2DTranspose, Conv2D
from tensorflow.keras.datasets import mnist


# Load the MNIST dataset
(x_train, _), (_, _) = mnist.load_data()

# Normalize and reshape data
x_train = (x_train.astype('float32') - 127.5) / 127.5
x_train = np.expand_dims(x_train, axis=-1)

# Build the Generator
generator = Sequential()
generator.add(Dense(128 * 7 * 7, input_shape=(100,), activation='relu'))
generator.add(Reshape((7, 7, 128)))
generator.add(Conv2DTranspose(64, kernel_size=4, strides=2, padding='same', activation='relu'))
generator.add(Conv2DTranspose(1, kernel_size=4, strides=2, padding='same', activation='tanh'))

# Build the Discriminator
discriminator = Sequential()
discriminator.add(Conv2D(64, kernel_size=4, strides=2, padding='same', input_shape=(28, 28, 1), activation='relu'))
discriminator.add(Conv2D(128, kernel_size=4, strides=2, padding='same', activation='relu'))
discriminator.add(Flatten())
discriminator.add(Dense(1, activation='sigmoid'))

# Compile the Discriminator
discriminator.compile(loss='binary_crossentropy', optimizer='adam')

# Build the GAN
gan = Sequential([generator, discriminator])

# Compile the GAN
discriminator.trainable = False  # So we only train the generator in the GAN
gan.compile(loss='binary_crossentropy', optimizer='adam')

# Training loop to train GAN
epochs = 100
batch_size = 128

for epoch in range(epochs):
    # Train the Discriminator
    idx = np.random.randint(0, x_train.shape[0], batch_size)
    real_images = x_train[idx]

    noise = np.random.normal(0, 1, (batch_size, 100))
    generated_images = generator.predict(noise)

    real_labels = np.ones((batch_size, 1))
    fake_labels = np.zeros((batch_size, 1))

    d_loss_real = discriminator.train_on_batch(real_images, real_labels)
    d_loss_fake = discriminator.train_on_batch(generated_images, fake_labels)
    d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)

    # Train the Generator
    noise = np.random.normal(0, 1, (batch_size, 100))
    valid_labels = np.ones((batch_size, 1))

    g_loss = gan.train_on_batch(noise, valid_labels)

    # Print progress
    print(f"Epoch {epoch}/{epochs} | D Loss: {d_loss} | G Loss: {g_loss}")


generator.save_weights('trained_generator_model.keras')
discriminator.save_weights('trained_discriminator_model.keras')
gan.save_weights('trained_gan_model.keras')
</code>

====Generate images====
<code python>
import numpy as np    
import matplotlib.pyplot as plt
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Reshape, Flatten
from tensorflow.keras.layers import Conv2DTranspose, Conv2D
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import load_model

# Build the Generator
generator = Sequential()
generator.add(Dense(128 * 7 * 7, input_shape=(100,), activation='relu'))
generator.add(Reshape((7, 7, 128)))
generator.add(Conv2DTranspose(64, kernel_size=4, strides=2, padding='same', activation='relu'))
generator.add(Conv2DTranspose(1, kernel_size=4, strides=2, padding='same', activation='tanh'))

# Load the saved weights
generator.load_weights('trained_generator_model.keras')

# Generate new images
num_images_to_generate = 10
noise = np.random.normal(0, 1, (num_images_to_generate, 100))
generated_images = generator.predict(noise)

# Denormalize the images (if they were normalized during training)
generated_images = 0.5 * generated_images + 0.5

# Display the generated images with labels
fig, axs = plt.subplots(1, num_images_to_generate, figsize=(15, 15))
for i in range(num_images_to_generate):
    img = generated_images[i].squeeze()

    axs[i].imshow(img, cmap='gray')
    axs[i].axis('off')

plt.show()
</code>

====Generate and classify images====

<code python>
import numpy as np    
import matplotlib.pyplot as plt
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Reshape, Flatten
from tensorflow.keras.layers import Conv2DTranspose, Conv2D
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import load_model

# Build the Generator
generator = Sequential()
generator.add(Dense(128 * 7 * 7, input_shape=(100,), activation='relu'))
generator.add(Reshape((7, 7, 128)))
generator.add(Conv2DTranspose(64, kernel_size=4, strides=2, padding='same', activation='relu'))
generator.add(Conv2DTranspose(1, kernel_size=4, strides=2, padding='same', activation='tanh'))

# Build the Discriminator
discriminator = Sequential()
discriminator.add(Conv2D(64, kernel_size=4, strides=2, padding='same', input_shape=(28, 28, 1), activation='relu'))
discriminator.add(Conv2D(128, kernel_size=4, strides=2, padding='same', activation='relu'))
discriminator.add(Flatten())
discriminator.add(Dense(1, activation='sigmoid'))

# Load the saved weights
generator.load_weights('trained_generator_model.keras')
discriminator.load_weights('trained_discriminator_model.keras')


# Generate new images
num_images_to_generate = 10
noise = np.random.normal(0, 1, (num_images_to_generate, 100))
generated_images = generator.predict(noise)

# Denormalize the images (if they were normalized during training)
generated_images = 0.5 * generated_images + 0.5

import matplotlib.pyplot as plt

# Display the generated images with labels
fig, axs = plt.subplots(1, num_images_to_generate, figsize=(15, 15))
for i in range(num_images_to_generate):
    img = generated_images[i].squeeze()
    label = np.argmax(discriminator.predict(np.expand_dims(img, axis=0)))

    axs[i].imshow(img, cmap='gray')
    axs[i].set_title(f"{label}", fontsize=12)
    axs[i].axis('off')

plt.show()
</code>
=====Text Generation Example=====

<code python>
# Text generation

import tensorflow as tf
from tensorflow.keras.layers import Embedding, LSTM, Dense
from tensorflow.keras.models import Sequential
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences

# Step 1: Prepare the training data
training_data = []
with open("D:\\gpt\\test.txt", "r", encoding="utf-8") as file:
    for line in file:
        training_data.append(line.strip())

# Prepare the Tokenizer
tokenizer = Tokenizer()
tokenizer.fit_on_texts(training_data)
total_words = len(tokenizer.word_index) + 1

# Convert text to sequences
input_sequences = []
for line in training_data:
    token_list = tokenizer.texts_to_sequences([line])[0]
    for i in range(1, len(token_list)):
        n_gram_sequence = token_list[:i+1]
        input_sequences.append(n_gram_sequence)

# Pad sequences for equal length
max_sequence_len = max([len(x) for x in input_sequences])
input_sequences = pad_sequences(input_sequences, maxlen=max_sequence_len, padding='pre')

# Create predictors and labels
predictors, labels = input_sequences[:, :-1], input_sequences[:, -1]
labels = tf.keras.utils.to_categorical(labels, num_classes=total_words)

model = False

# Build the model
def build_model():
    model = Sequential()
    model.add(Embedding(total_words, 10, input_length=max_sequence_len-1))
    model.add(LSTM(150))
    model.add(Dense(total_words, activation='softmax'))
    model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
    return model

# Train the model
def train_model(model):
    model.fit(predictors, labels, epochs=100, verbose=1)
    return model

# Load a pre trained model
def load_model():
    model = tf.keras.models.load_model("_my_model")
    return model

# Save the model
def save_model(model): 
    model.save("_my_model")

model = build_model()
#model = load_model()
model = train_model(model)
save_model(model)
model = load_model()

# Generate text using the trained model
seed_text = "How to wash "
next_words = 128

for _ in range(next_words):
    token_list = tokenizer.texts_to_sequences([seed_text])[0]
    token_list = pad_sequences([token_list], maxlen=max_sequence_len-1, padding='pre')
    predicted_probs = model.predict(token_list, verbose=0)[0]
    predicted = tf.argmax(predicted_probs, axis=-1)
    output_word = ""
    for word, index in tokenizer.word_index.items():
        if index == predicted:
            output_word = word
            break
    seed_text += " " + output_word

print(seed_text)
</code>

=====Text classification example=====

<code python>
import tensorflow as tf
from tensorflow import keras
import numpy as np

positive_sentences = ["Dieses Buch ist grossartig", "Ich liebe diesen Film", "Das Essen war koestlich", "Kann ich nur empfehlen", 
"Wirklich ein Erlebnis", "Gerne kommen wir wieder", "Das war super", "Das ist toll gewesen", "Das war toll", "Das hat richtig Spass gemacht",
"So muss das sein", "Ein wirklich perfekter Abend", "Immer gutes Essen", "Immer gute Musik"]

negative_sentences = ["Der Film war schrecklich", "Das Buch war langweilig", "Also das war wirklich nicht gut", "Das muss echt besser sein", 
"Das Essen war schlecht", "Die sehen mich nie wieder", "Das ist ein Witz", "hier komme ich nicht mehr hin", "Das haette ich mir sparen koennen", "So ein Unsinn",
"Besser zu hause bleiben", "Nicht zu empfehlen", "Davon rate ich ab", "Das hat nicht funktioniert", "Das war ein Fehler", "Das ist ein Reinfall"]

# Labels for positive and negative sentences
positive_labels = np.ones(len(positive_sentences))
negative_labels = np.zeros(len(negative_sentences))

# merge data
sentences = positive_sentences + negative_sentences
labels = np.concatenate([positive_labels, negative_labels])

# create tokens and vectorize data
tokenizer = keras.preprocessing.text.Tokenizer()
tokenizer.fit_on_texts(sentences)
word_index = tokenizer.word_index
sequences = tokenizer.texts_to_sequences(sentences)
padded_sequences = keras.preprocessing.sequence.pad_sequences(sequences)

# create model
model = keras.models.Sequential([
    keras.layers.Embedding(len(word_index) + 1, 16, input_length=padded_sequences.shape[1]),
    keras.layers.GlobalAveragePooling1D(),
    keras.layers.Dense(16, activation='relu'),
    keras.layers.Dense(1, activation='sigmoid')
])

model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

# train model
model.fit(padded_sequences, labels, epochs=100)

# prediction
def evaluate_sentence(sentence):
    sequence = tokenizer.texts_to_sequences([sentence])
    padded_sequence = keras.preprocessing.sequence.pad_sequences(sequence, maxlen=padded_sequences.shape[1])
    prediction = model.predict(padded_sequence)[0][0]
    if prediction >= 0.5:
        return "positiv"
    else:
        return "negativ"

# examples
test_sentence_1 = "Da komme ich nicht mehr hin"
test_sentence_2 = "Da habe ich schon bessere gesehen, das war nichts"
test_sentence_3 = "Mir hat es gefallen"

print(evaluate_sentence(test_sentence_1))  
print(evaluate_sentence(test_sentence_2))  
print(evaluate_sentence(test_sentence_3)) 
</code>

=====Mini GPT=====

Hier wird das Model überschrieben!
<code python>
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers

def train_model(text):
    tokenizer = keras.preprocessing.text.Tokenizer()
    tokenizer.fit_on_texts([text])
    total_words = len(tokenizer.word_index) + 1

    input_sequences = []
    for line in text.split("\n"):
        token_list = tokenizer.texts_to_sequences([line])[0]
        for i in range(1, len(token_list)):
            n_gram_sequence = token_list[:i+1]
            input_sequences.append(n_gram_sequence)

    max_sequence_len = max([len(x) for x in input_sequences])
    input_sequences = keras.preprocessing.sequence.pad_sequences(input_sequences, maxlen=max_sequence_len, padding='pre')

    xs = input_sequences[:, :-1]
    labels = input_sequences[:, -1]

    ys = tf.keras.utils.to_categorical(labels, num_classes=total_words)

    model = keras.models.Sequential()
    model.add(layers.Embedding(total_words, 100, input_length=max_sequence_len-1))
    model.add(layers.Bidirectional(layers.LSTM(150, return_sequences=True)))
    model.add(layers.Dropout(0.2))
    model.add(layers.LSTM(100))
    model.add(layers.Dense(total_words, activation='softmax'))

    model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])

    history = model.fit(xs, ys, epochs=20, verbose=1)

    return model, tokenizer, max_sequence_len

def generate_text(model, tokenizer, max_sequence_len, seed_text, next_words):
    for _ in range(next_words):
        token_list = tokenizer.texts_to_sequences([seed_text])[0]
        token_list = keras.preprocessing.sequence.pad_sequences([token_list], maxlen=max_sequence_len-1, padding='pre')
        predicted = model.predict(token_list, verbose=0)
        predicted_word_index = tf.argmax(predicted, axis=-1).numpy()[0]
        output_word = ""
        for word, index in tokenizer.word_index.items():
            if index == predicted_word_index:
                output_word = word
                break
        seed_text += " " + output_word

    return seed_text

def save_model(model, filename):
    model.save(filename)

def load_model(filename):
    return keras.models.load_model(filename)

def train_with_new_text(model, tokenizer, max_sequence_len, new_text):
    new_tokenizer = keras.preprocessing.text.Tokenizer()
    new_tokenizer.fit_on_texts([new_text])
    new_total_words = len(new_tokenizer.word_index) + 1

    new_input_sequences = []
    for line in new_text.split("\n"):
        new_token_list = new_tokenizer.texts_to_sequences([line])[0]
        for i in range(1, len(new_token_list)):
            new_n_gram_sequence = new_token_list[:i+1]
            new_input_sequences.append(new_n_gram_sequence)

    new_max_sequence_len = max_sequence_len
    new_input_sequences = keras.preprocessing.sequence.pad_sequences(new_input_sequences, maxlen=new_max_sequence_len, padding='pre')

    new_xs = new_input_sequences[:, :-1]
    new_labels = new_input_sequences[:, -1]

    new_ys = tf.keras.utils.to_categorical(new_labels, num_classes=new_total_words)

    new_model = keras.models.Sequential()
    new_model.add(layers.Embedding(new_total_words, 100, input_length=max_sequence_len-1))
    new_model.add(layers.Bidirectional(layers.LSTM(150, return_sequences=True)))
    new_model.add(layers.Dropout(0.2))
    new_model.add(layers.LSTM(100))
    new_model.add(layers.Dense(new_total_words, activation='softmax'))

    new_model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
    new_model.fit(new_xs, new_ys, epochs=20, verbose=1)

# Beispiel-Aufruf

# Training
text = ""
with open("training_data.txt", "r", encoding="utf-8") as file:
    for line in file:
        text += line.strip() + "\n"
model, tokenizer, max_sequence_len = train_model(text)

# Generieren
seed_text = "Custom prompt"
next_words = 20
generated_text = generate_text(model, tokenizer, max_sequence_len, seed_text, next_words)
print(generated_text)

# Speichern
save_model(model, "text_generator_model.h5")

# Laden und Trainieren mit neuem Text
new_text = ""
with open("new_training_data.txt", "r", encoding="utf-8") as file:
    for line in file:
        new_text += line.strip() + "\n"
loaded_model = load_model("text_generator_model.h5")
train_with_new_text(loaded_model, tokenizer, max_sequence_len, new_text)

seed_text = "Another custom prompt"
next_words = 20
generated_text = generate_text(model, tokenizer, max_sequence_len, seed_text, next_words)
print(generated_text)
</code>

Fine tuning mit ModelCheckpoint

<code python>
import os 
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'

import numpy as np
from numpy.testing import assert_allclose
from keras.models import Sequential, load_model
from keras.layers import LSTM, Dropout, Dense
from keras.callbacks import ModelCheckpoint

vec_size = 100
n_units = 10

x_train = np.random.rand(500, 10, vec_size)
y_train = np.random.rand(500, vec_size)

model = Sequential()
model.add(LSTM(n_units, input_shape=(None, vec_size), return_sequences=True))
model.add(Dropout(0.2))
model.add(LSTM(n_units, return_sequences=True))
model.add(Dropout(0.2))
model.add(LSTM(n_units))
model.add(Dropout(0.2))
model.add(Dense(vec_size, activation='linear'))
model.compile(loss='mean_squared_error', optimizer='adam')

# define the checkpoint
filepath = "model.h5"
checkpoint = ModelCheckpoint(filepath, monitor='loss', verbose=0, save_best_only=True, mode='min')
callbacks_list = [checkpoint]

# fit the model
model.fit(x_train, y_train, epochs=5, batch_size=50, verbose=0, callbacks=callbacks_list)

# load the model 
new_model = load_model(filepath)

model.predict(x_train)
new_model.predict(x_train)

# fit the model
checkpoint = ModelCheckpoint(filepath, monitor='loss', verbose=0, save_best_only=True, mode='min')
callbacks_list = [checkpoint]
new_model.fit(x_train, y_train, epochs=5, batch_size=50, verbose=0, callbacks=callbacks_list)

try:
    assert_allclose(model.predict(x_train), new_model.predict(x_train), 1e-5)
except Exception as e:
    print("Message2: " + str(e))
    
print("The end")
print(model.predict(x_train))
print(new_model.predict(x_train))

new_model.fit(x_train, y_train, epochs=5, batch_size=50, verbose=0, callbacks=callbacks_list)

try:
    assert_allclose(model.predict(x_train), new_model.predict(x_train), 1e-5)
except Exception as e:
    print("Message3: " + str(e))
    
print(new_model.predict(x_train))
</code>
=====GPT2=====

<code python>
import os 
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'

import tensorflow as tf
from transformers import GPT2Tokenizer, TFGPT2LMHeadModel
import sys
    
model_name = "gpt2"
cache_dir = "gpt2-cache"
tokenizer = GPT2Tokenizer.from_pretrained(model_name, cache_dir=cache_dir)
model = TFGPT2LMHeadModel.from_pretrained(model_name, cache_dir=cache_dir, pad_token_id=tokenizer.eos_token_id)

def generate_text(model, tokenizer, start_text, num_tokens):
    input_ids = tokenizer.encode(start_text, return_tensors='tf')
    output = model.generate(input_ids, max_length=num_tokens, num_return_sequences=1, pad_token_id=tokenizer.eos_token_id, num_beams = 5,no_repeat_ngram_size = 2,early_stopping = True)
    generated_text = tokenizer.decode(output[0], skip_special_tokens=True)
    return generated_text
  
start_text = sys.argv[1]
num_tokens = 100  # Anzahl der gewnschten Tokens im generierten Text
generated_text = generate_text(model, tokenizer, start_text, num_tokens)

print(generated_text)
</code>

====Fine tuning====

<code python>
import os 
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'

import pandas as pd
import numpy as np
import re
import os

def read_txt(filepath):
    with open(filepath, "r", encoding="utf-8") as file:
        text = file.read()
    return text
    
def read_dir(path):
    text = ""
    for filename in os.listdir(path):
        file_path = os.path.join(path, filename)
        text += read_txt(file_path)
    return text
    
#train_file = "shakespeare.txt"
#text_data = read_txt(train_file)
#text_data = re.sub(r'\n+', '\n', text_data).strip()

from transformers import TextDataset, DataCollatorForLanguageModeling
from transformers import GPT2Tokenizer, GPT2LMHeadModel
from transformers import Trainer, TrainingArguments

def load_dataset(file_path, tokenizer, block_size=128):
    dataset = TextDataset(
        tokenizer = tokenizer,
        file_path = file_path,
        block_size = block_size
    )
    return dataset
    
def load_data_collator(tokenizer, mlm=False):
    data_collator = DataCollatorForLanguageModeling(
        tokenizer = tokenizer,
        mlm = mlm
    )
    return data_collator

def train(train_file_path, model_name, output_dir, overwrite_output_dir, per_device_train_batch_size, num_train_epochs, save_steps, cache_dir):
    tokenizer = GPT2Tokenizer.from_pretrained(model_name)
    train_dataset = load_dataset(train_file_path, tokenizer)
    data_collator = load_data_collator(tokenizer)

    tokenizer.save_pretrained(output_dir)      
    model = GPT2LMHeadModel.from_pretrained(model_name, cache_dir = cache_dir)
    model.save_pretrained(output_dir)
    training_args = TrainingArguments(
        output_dir=output_dir,
        overwrite_output_dir=overwrite_output_dir,
        per_device_train_batch_size=per_device_train_batch_size,
        num_train_epochs=num_train_epochs
    )
    trainer = Trainer(
        model=model,
        args=training_args,
        data_collator=data_collator,
        train_dataset=train_dataset
    )
    trainer.train()
    trainer.save_model()
    
train_file_path = "shakespeare.txt"
model_name = "gpt2-medium"
output_dir = "gpt-medium-finetuned"
overwrite_output_dir = False
per_device_train_batch_size = 8
num_train_epochs = 10.0
save_steps = 50000
cache_dir = "gpt-medium-cache"

train(
    train_file_path=train_file_path,
    model_name=model_name,
    output_dir=output_dir,
    overwrite_output_dir=overwrite_output_dir,
    per_device_train_batch_size=per_device_train_batch_size,
    num_train_epochs=num_train_epochs,
    save_steps=save_steps,
    cache_dir=cache_dir
)
</code>

<code python>
import os 
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'

from transformers import PreTrainedTokenizerFast, GPT2LMHeadModel, GPT2TokenizerFast, GPT2Tokenizer
import sys

def load_model(model_path):
    model = GPT2LMHeadModel.from_pretrained(model_path)
    return model


def load_tokenizer(tokenizer_path):
    tokenizer = GPT2Tokenizer.from_pretrained(tokenizer_path)
    return tokenizer

def generate_text(model_path, sequence, max_length):
    
    model = load_model(model_path)
    tokenizer = load_tokenizer(model_path)
    ids = tokenizer.encode(f'{sequence}', return_tensors='pt')
    final_outputs = model.generate(
        ids,
        do_sample=True,
        max_length=max_length,
        pad_token_id=model.config.eos_token_id,
        top_k=50,
        top_p=0.95,
        num_beams = 5, 
        no_repeat_ngram_size = 2, 
        early_stopping = True
    )
    
    print(tokenizer.decode(final_outputs[0], skip_special_tokens=True))
     
model1_path = "gpt-medium-finetuned"
sequence1 = sys.argv[1]
max_len = int(sys.argv[2])
generate_text(model1_path, sequence1, max_len) 
</code>


=====Links=====

  * [[http://jrmeyer.github.io/machinelearning/2016/02/01/TensorFlow-Tutorial.html|Tensorflow Email Classification]]