Update app.py

app.py

@@ -6,410 +6,128 @@ Created on Sun Mar 26 21:07:00 2023
 """
 
 
-import tensorflow as tf
 import numpy as np
+import tensorflow as tf
+from tensorflow import keras
 import matplotlib.pyplot as plt
-from matplotlib import animation
-from matplotlib.animation import FuncAnimation
-import matplotlib as mpl
 import streamlit as st
+plt.style.use('mystyle.mplstyle')
 
-from matplotlib import cm
-
-import matplotlib.pyplot as plt
-from sklearn.linear_model import LinearRegression
-import mpl_toolkits.mplot3d as a3
-import matplotlib.colors as colors
-from matplotlib.colors import LightSource
-from tensorflow import keras
-import pandas as pd
-
-from transformers import pipeline
-import transformers
-
-
-# Farben definieren
-cb = [15/255, 25/255, 35/255]
-cf = [25/255*2, 35/255*2, 45/255*2]
-w = [242/255, 242/255, 242/255]
-blue = [68/255, 114/255, 196/255]
-orange = [197/255, 90/255, 17/255]
-
-
-# Pipelines definieren
-#en_de_translator = pipeline("translation_de_to_en", model='google/bert2bert_L-24_wmt_de_en')
-qa_pipeline = pipeline("question-answering", model='deepset/gelectra-base-germanquad')
-sentiment = pipeline("text-classification", model='oliverguhr/german-sentiment-bert')
-
-tab1, tab2, tab3, tab4 = st.tabs(
-    ["Künstliche Neuronale Netze", "Wortvektoren Stimmung", "Wörter Maskieren", "HuggingFace Pipelines"])
-
-
-with tab1:
-    st.markdown(
-        'Definieren Sie ein neuronales Netz und beobachten Sie wie sich die Kurve krümmen kann, um die Daten zu fitten')
-
-    col1, col2 = tab1.columns(2)
-    size = np.array([12., 27., 32., 47., 58., 56., 58., 61.,
-                    64., 67., 70., 80., 84., 88., 108.])
-    price = np.array([88., 135., 178., 216., 220., 246., 241., 275.,
-                     305., 267., 297., 310., 292., 317., 422.])
-    location = np.array([2., 2., 0., 1., 2., 0., 1., 0., 1., 2., 0., 2., 1., 1., 2.])
-    price[location == 1] = price[location == 1]*1+30
-    price[location == 2] = price[location == 2]*1+60
-
-    size_location = np.concatenate((size.reshape(-1, 1), location.reshape(-1, 1)), axis=1)
-
-    data = np.concatenate((size.reshape(-1, 1), location.reshape(-1, 1),
-                          price.reshape(-1, 1)), axis=1)
-    data = pd.DataFrame(data, columns=['Wohnungsgröße (qm)', 'Ort', 'Preis (k€)'])
-
-    col1.dataframe(data.style.format(precision=0))
-    #edited_df = st.experimental_data_editor(data)
-    edited_df = data
-
-    edited_data = edited_df.to_numpy()
-    size_location = edited_data[:, :2]
-    price = edited_data[:, 2]
-
-    string = col2.text_area(
-        'Architektur des neuronalen Netzes. Anzahl der Neuronen in den verdeckten Schichten', value='4', height=275)
-    layers = string.split('\n')
-
-    if st.button('Modell trainieren und Fit-Kurve darstellen'):
-
-        with st.spinner('Der Fit-Prozess kann einige Sekunden dauern ...'):
-
-            model = keras.models.Sequential()
-
-            if len(layers) > 0:
-                for neurons in layers:
-                    model.add(keras.layers.Dense(int(neurons), activation='tanh'))
-            model.add(keras.layers.Dense(1, activation='tanh'))
-
-            model.compile(loss='binary_crossentropy', optimizer='SGD')
-
-            lr_reduction = keras.callbacks.ReduceLROnPlateau(
-                monitor='loss', patience=1000, min_lr=0.00001)
-
-            model.fit(size_location/[120, 2], price/500, epochs=5000,
-                      batch_size=4, callbacks=lr_reduction, verbose=False)
-
-            y_pred = model.predict((size_location)/[120, 2], verbose=False).reshape(-1)*500
-
-            x = np.linspace(0, 125, 400)
-            y = np.linspace(0, 2, 400)
-            X, Y = np.meshgrid(x, y)
-
-            Z = np.concatenate([X.reshape(-1, 1)/120, Y.reshape(-1, 1)/2], axis=1)
-            Z = model.predict(Z, verbose=False)*500
-
-            Z = Z.reshape(len(y), len(x))
-
-            fig = plt.figure(facecolor=cb, figsize=(7, 7))
-            ax = fig.add_subplot(projection='3d')
-            ax.tick_params(color=w, labelcolor=w, labelsize=12)
-            ax.set_facecolor(cb)
-
-            ax.w_xaxis.set_pane_color(cf)
-            ax.w_yaxis.set_pane_color(cf)
-            ax.w_zaxis.set_pane_color(cf)
-
-            ax.set_yticks([0, 1, 2])
-            ax.view_init(25, 50)
-
-            rgb = np.tile(orange, (Z.shape[0], Z.shape[1], 1))
-
-            ls = LightSource(azdeg=315, altdeg=45, hsv_min_val=0.9,
-                             hsv_max_val=1, hsv_min_sat=1, hsv_max_sat=0)
-            illuminated_surface = ls.shade_rgb(rgb, Z)
-
-            below_price = price[price < y_pred]
-            below_location = location[price < y_pred]
-            below_size = size[price < y_pred]
-
-            ax.plot(below_size, below_location, below_price, '.', markersize=20, color=blue)
-
-            ax.plot_surface(X, Y, Z, facecolors=illuminated_surface, edgecolors=[0, 0, 0, 0],
-                            linewidth=0, antialiased=True, rcount=400, ccount=400, alpha=0.8)
-
-            above_price = price[price >= y_pred]
-            above_location = location[price >= y_pred]
-            above_size = size[price >= y_pred]
-
-            ax.plot(above_size, above_location, above_price,
-                    '.', markersize=20, color=blue, zorder=20,)
-
-            ax.set_ylim(2, 0)
-            ax.set_xlim(125, 0)
-            ax.set_zlim(0, 450)
-
-            ax.set_xlabel('Wohnungsgröße (qm)', color=w, fontsize=15, labelpad=10)
-            ax.set_ylabel('Ort', color=w, fontsize=15, labelpad=10)
-            ax.set_zlabel('Preis (k€)', color=w, fontsize=15, rotation=270, labelpad=10)
-
-            st.pyplot(fig)
-
-
-# %%
-with tab2:
-
-    st.markdown(
-        'Definieren Sie Sätze, die positiv oder negativ gestimmt sind und beobachten Sie die resultierenden Wort-Vektoren.')
-
-    text_input_2 = '1: Das schöne Allgäu\n' + \
-        '1: So toll hier im Allgäu\n' + \
-        '1: Uns gefallen die Berge und Seen\n' + \
-        '1: Wir mögen die Landschaft und die Berge\n' + \
-        '1: Ganz toll im Allgäu\n' + \
-        '1: Wir mögen das Allgäu\n' + \
-        '0: Uns gefiel es leider nicht\n' + \
-        '0: Bei Regen ist es total langweilig\n' + \
-        '0: Ganz langweilig!\n' + \
-        '0: So schade, dass es oft Regen gibt\n' + \
-        '0: Sehr schade, wir konnten gar nicht skifahren\n' + \
-        '0: Das gefiel uns überhaupt nicht'
-
-    string_2 = st.text_area('', value=text_input_2, height=275)
-    texts_2 = string_2.split('\n')
-
-    text = []
-    labels = []
-    for element in texts_2:
-        if element != '':
-            label_element, text_element = element.split(':')
-            text.append(text_element)
-            labels.append(float(label_element))
-
-    if st.button('Modell trainieren und Wort-Vektoren darstellen', key=1):
-        with st.spinner('Der Fit-Prozess kann einige Sekunden dauern ...'):
-
-            vectorizer = tf.keras.layers.TextVectorization(
-                max_tokens=1000, output_sequence_length=7)
-
-            vectorizer.adapt(text)
-
-            model = tf.keras.models.Sequential()
-            model.add(vectorizer)
-
-            model.add(tf.keras.layers.Embedding(vectorizer.vocabulary_size(), 2))
-            # model.add(tf.keras.layers.Dropout(0.6))
-            model.add(tf.keras.layers.LSTM(1, return_sequences=False, activation='sigmoid'))
-            # model.add(tf.keras.layers.Flatten())
-            #model.add(tf.keras.layers.Dense(1, activation='sigmoid', use_bias=False, trainable=True))
-
-            model.summary()
-
-            model.compile(optimizer='adam', loss='binary_crossentropy',
-                          metrics=['accuracy'])
-
-            model.fit(text, labels, epochs=2000, verbose=False)
-
-            # Word Vektoren grafisch darstellen
-            cb = [15/255, 25/255, 35/255]
-            cf = [25/255*2, 35/255*2, 45/255*2]
-            w = [242/255, 242/255, 242/255]
-            blue = [68/255, 114/255, 196/255]
-            orange = [197/255, 90/255, 17/255]
-
-            fig = plt.figure(facecolor=cb, figsize=(7, 7))
-            ax = fig.add_subplot()
-            ax.tick_params(color=w, labelcolor=w, labelsize=12)
-            ax.set_facecolor(cb)
-
-            y_pred = model.predict(np.array(vectorizer.get_vocabulary(
-                include_special_tokens=False)).reshape(-1, 1))
-
-            embed_model = tf.keras.models.Model(model.input, model.layers[1].output)
-            X_embed = embed_model(np.array(vectorizer.get_vocabulary(
-                include_special_tokens=False)).reshape(-1, 1))[:, 0, :]
-
-            # 1. Dimension der Wort-Vektoren auf X-Achse,
-            # 2. Dimension auf y-Achse, 3. auf die Z-Achse abbilden
-            ax.scatter(X_embed[:, 0], X_embed[:, 1],
-                       c=y_pred, cmap='coolwarm')
-            for i in range(vectorizer.vocabulary_size()-2):
-                ax.text(X_embed[i, 0], X_embed[i, 1],
-                        vectorizer.get_vocabulary(include_special_tokens=False)[i],
-                        color=w)
-
-            ax.set_ylim(-2, 2)
-            ax.set_xlim(-2, 2)
-
-            ax.set_xticks([-2, -1, 0, 1, 2])
-            ax.set_yticks([-2, -1, 0, 1, 2])
-
-            ax.spines['bottom'].set_color(w)
-            ax.spines['top'].set_color(w)
-            ax.spines['right'].set_color(w)
-            ax.spines['left'].set_color(w)
-
-            ax.set_xlabel('Dimension 1', color=w, fontsize=15, labelpad=10)
-            ax.set_ylabel('Dimension 2', color=w, fontsize=15, labelpad=10)
-
-            # get the mappable, the 1st and the 2nd are the x and y axes
-
-            PCM = ax.get_children()[0]
-            cbar = plt.colorbar(PCM, ax=ax, fraction=0.036, pad=0.090)
-            cbar.set_ticks([])
-
-            cbar.set_label(
-                '<- positiv           Stimmung           negativ ->', fontsize=12, color=w, rotation=270, labelpad=12)
-
-            ax.set_title('Epoche 2000', color=w, fontsize=15)
-            st.pyplot(fig)
-
-
-# %%
-with tab3:
-
-    st.markdown(
-        'Definieren Sie Sätze bei denen beliebige Wörter maskiert werden, um allgemeine Bezüge in Wort-Vektoren abzubilden.')
-
-    text_input = 'Das schöne Allgäu\n' + \
-        'Das wunderbare Allgäu\n' + \
-        'Das grüne Allgäu\n' + \
-        'Radfahren im Allgäu\n' + \
-        'Wandern im Allgäu\n' + \
-        'Radfahren in Oberschwaben\n' + \
-        'Urlaub in Oberschwaben\n' + \
-        'Künstliche Intelligenz für das Allgäu\n' + \
-        'Künstliche Intelligenz für Oberschwaben\n' + \
-        'Data Science für Oberschwaben\n' + \
-        'Data Science und Machine Learning\n' + \
-        'Machine Learning für das Allgäu'
-
-    string = st.text_area('', value=text_input, height=275)
-    text = string.split('\n')
-
-    if st.button('Modell trainieren und Wort-Vektoren darstellen', key=2):
-        with st.spinner('Der Fit-Prozess kann einige Sekunden dauern ...'):
-
-            vectorizer = tf.keras.layers.TextVectorization(
-                max_tokens=1000, output_sequence_length=7)
-
-            vectorizer.adapt(text)
-
-            def generator():
-                while True:
-                    x = vectorizer(text)
-                    mask = tf.reduce_max(x)+1
-
-                    lengths = tf.argmin(x, axis=1)
-                    lengths = tf.cast(lengths, tf.float32)
-
-                    masks = tf.random.uniform(shape=(x.shape[0],), minval=0, maxval=lengths)
-                    masks = tf.cast(masks, tf.int32)
-
-                    masks = tf.one_hot(masks, x.shape[1], dtype=tf.int32)
-                    masks = tf.cast(masks, tf.bool)
-
-                    y = x[masks]
-                    masks = tf.cast(masks, tf.int64)
-                    x = x * (1-masks) + mask * masks
-                    yield x, y
+# Defining the neural network as the agent to chose ad scheme A (0) or B (1)
+model = tf.keras.models.Sequential()
+model.add(tf.keras.layers.Dense(1, activation="sigmoid", input_shape=(1,)))
+model.summary()
 
-            # data = tf.data.Dataset.from_tensor_slices(vectorizer(text),vectorizer(text))
-            # data = data.map(masking_generator)
-            model = tf.keras.models.Sequential()
+information_for_plotting = np.zeros((epochs, 10))
 
-            model.add(tf.keras.layers.Embedding(vectorizer.vocabulary_size()+1, 3))
 
-            model.add(tf.keras.layers.LSTM(100, return_sequences=False, activation='sigmoid'))
-            model.add(tf.keras.layers.Dense(vectorizer.vocabulary_size(), activation='softmax'))
+@tf.function()
+def action_selection(model):
+    # Using GgradientTape to automatically build gradients with TensorFlow
+    with tf.GradientTape() as tape:
 
-            model.summary()
+        # As we have no information about the user viewer the ad,
+        # the input in the neural network is always the same: 0
+        output = model(np.array([[0.0]]))  # [0 ... 1]
 
-            model.compile(optimizer='adam', loss='sparse_categorical_crossentropy',
-                          metrics=['accuracy'])
+        # The output of the neural network is considered as probability for
+        # taking action A (0) or B (1)
+        # We compare the output with a uniform random variable
+        # For example, if the output is 0.8,
+        # we have 80% chance that random variable is smaller, taking action B (1)
+        # and 20% chance that the random variable is larger, taking action A (0)
+        action = (tf.random.uniform((1, 1)) < output)  # [0 oder 1]
 
-            lr_reduce = tf.keras.callbacks.ReduceLROnPlateau(
-                monitor='loss', patience=500, min_lr=1e-6)
-            model.fit(generator(), steps_per_epoch=1,
-                      epochs=3000, callbacks=lr_reduce, verbose=False)
+        # The loss value measures the difference between the output and the action
+        loss = tf.reduce_mean(tf.keras.losses.binary_crossentropy(action, output))
 
-            fig = plt.figure(facecolor=cb, figsize=(7, 7))
-            ax = fig.add_subplot()
-            ax.tick_params(color=w, labelcolor=w, labelsize=12)
-            ax.set_facecolor(cb)
+    # We are creating the gradients [dloss/dw, dloss/db]
+    grads = tape.gradient(loss, model.trainable_variables)
+    return output, action, loss, grads
 
-            embed_model = tf.keras.models.Model(model.input, model.layers[0].output)
-            X_embed = embed_model(vectorizer(vectorizer.get_vocabulary(
-                include_special_tokens=False)))[:, 0, :]
 
-            # 1. Dimension der Wort-Vektoren auf X-Achse,
-            # 2. Dimension auf y-Achse, 3. auf die Z-Achse abbilden
-            ax.scatter(X_embed[:, 0], X_embed[:, 1],
-                       color=blue)
-            for i in range(vectorizer.vocabulary_size()-2):
-                ax.text(X_embed[i, 0], X_embed[i, 1],
-                        vectorizer.get_vocabulary(include_special_tokens=False)[i],
-                        color=w)
+st.markdown(
+    'Simulate A/B optimization with policy gradient reinforcement learning')
 
-            ax.set_ylim(-2, 2)
-            ax.set_xlim(-2, 2)
 
-            ax.set_xticks([-2, -1, 0, 1, 2])
-            ax.set_yticks([-2, -1, 0, 1, 2])
+learning_rate = st.text_area('Learning rate', value=0.1, height=25)
 
-            ax.spines['bottom'].set_color(w)
-            ax.spines['top'].set_color(w)
-            ax.spines['right'].set_color(w)
-            ax.spines['left'].set_color(w)
+prob_A = st.text_area('Click probability of ad A', 0.4, height=75)
 
-            ax.set_xlabel('Dimension 1', color=w, fontsize=15, labelpad=10)
-            ax.set_ylabel('Dimension 2', color=w, fontsize=15, labelpad=10)
+prob_A = st.text_area('Click probability of ad B', 0.5, height=75)
 
-            st.pyplot(fig)
+epochs = st.text_area('Number of ad impressions (epochs)', 2000, height=75)
 
+if st.button('Modell trainieren und Fit-Kurve darstellen'):
 
-# %%
-with tab4:
-    # st.header("Übersetzung: Deutsch --> Englisch")
-    #st.text("Übersetzung: Deutsch --> Englisch")
-    st.markdown('Probieren Sie verschiedene Pipelines der Transformer-Bibliothek von HuggingFace.')
+    with st.spinner('Simulating the ad campaign may take a few seconds ...'):
 
-    text_input_4 = 'Was ist der Schwerpunkt?'
+        for epoch in range(epochs):
 
-    string_4 = st.text_area('Frage zum Kontext beantworten', value=text_input_4, height=25)
+            output, action, loss, grads = action_selection(model)
 
-    text_input_5 = 'Wir unterstützen Unternehmen bei der Datenanalyse durch individuelle Beratung und Projekte mit besonderem Fokus auf maschinelles Lernen und Deep Learning.'
+            # Next we are applying the action by displaying ad A or B
+            # As we do not want to wait if a user clicks the ad,
+            # we are simulating a click rate
+            # Ad A has with 40% click rate a lower chance of being clicked
+            # than Ad B with 50% click rate
+            # We consider the click rate as a measure of the reward for training
+            if action == False:  # Action A
+                reward = float(np.random.random() < 0.4)
 
-    string_5 = st.text_area('Kontext', value=text_input_5, height=75)
+            if action == True:  # Action B
+                reward = float(np.random.random() < 0.5)
 
-    if st.button('Ein fertig trainiertes Transformer-Modell von HuggingFace anwenden', key=4):
-        with st.spinner('Die Beantwortung der Frage kann einige Sekunden dauern ...'):
+            # The gradients obtained above are multiplied with the acquired reward
+            # Gradients for actions that lead to clicks are kept unchanged,
+            # whereas gradients for actions that do not lead to clicks are reversed
+            grads_adjusted = []
+            for var_index in range(len(model.trainable_variables)):
+                grads_adjusted.append((reward-0.5)*2 * grads[var_index])
 
-            a5 = qa_pipeline(question=string_4, context=string_5)
-            st.text(a5)
+            # Using standard backpropagation, we apply the gradients to update the model parameters
+            model.trainable_variables[0].assign(
+                model.trainable_variables[0]-lr*grads_adjusted[0])
+            model.trainable_variables[1].assign(
+                model.trainable_variables[1]-lr*grads_adjusted[1])
 
-    ############################################################
+            information_for_plotting[epoch, 0] = output.numpy()[0]
+            information_for_plotting[epoch, 1] = action.numpy()[0].astype(int)
+            information_for_plotting[epoch, 2] = loss
+            information_for_plotting[epoch, 3] = grads[0]
+            information_for_plotting[epoch, 4] = grads[1]
+            information_for_plotting[epoch, 5] = reward
+            information_for_plotting[epoch, 6] = grads_adjusted[0]
+            information_for_plotting[epoch, 7] = grads_adjusted[1]
+            information_for_plotting[epoch, 8] = copy.deepcopy(model.trainable_variables[0])
+            information_for_plotting[epoch, 9] = copy.deepcopy(model.trainable_variables[1])
 
-    st.text('')
-    st.markdown("""<hr style="height:10px;border:none;color:#333;background-color:#333;" /> """,
-                unsafe_allow_html=True)
-    st.text('')
+        titles = ['Model Output', 'Action', 'Loss', 'Gradients', 'Rewards',
+                  'Adjusted Gradients', 'Model Parameters']
+        plus = [0, 0, 0, 0, 1, 1, 2]
 
-    text_input_7 = 'Wir lieben Data Science!'
+        fig = plt.figure(figsize=(12, 26))
+        fig.subplots(7, 1, sharex=True)
+        for i in range(7):
+            plt.subplot(7, 1, i+1)
+            plt.subplots_adjust(hspace=.0)
 
-    string_7 = st.text_area('Stimmungsanalyse', value=text_input_7, height=25)
+            if i in [0, 1, 2, 4]:
+                plt.plot(information_for_plotting[:, i+plus[i]])
+                plt.gca().yaxis.set_major_formatter(plt.FormatStrFormatter('%.2f'))
 
-    if st.button('Ein fertig trainiertes Transformer-Modell von HuggingFace anwenden', key=5):
-        with st.spinner('Die Beurteilung der Stimmung kann einige Sekunden dauern ...'):
+            else:
+                plt.plot(information_for_plotting[:, i+1+plus[i]], label='Bias')
+                plt.plot(information_for_plotting[:, i+plus[i]], label='Weight')
 
-            a5 = sentiment(string_7)
-            st.text(a5[0]['label'])
+                plt.legend(loc="upper left")
+                plt.gca().yaxis.set_major_formatter(plt.FormatStrFormatter('%.2f'))
+            plt.ylabel(titles[i])
 
-    ############################################################
-    st.text('')
-    st.markdown("""<hr style="height:10px;border:none;color:#333;background-color:#333;" /> """,
-                unsafe_allow_html=True)
-    st.text('')
+        plt.xlabel('Epoch')
+        plt.show()
 
-    references = 'Verwendete Modelle:\n' + \
-        '\n\nFrage beantworten:\n' + \
-        'deepset/gelectra-base-germanquad, Autoren: Timo Möller, Julian Risch, Malte Pietsch' + \
-        '\n\nStimmung:\n' + \
-        'oliverguhr/german-sentiment-bert, Autoren:  Oliver Guhr, Anne-Kathrin Schumann, Frank Bahrmann, Hans Joachim Böhme'
+        st.markdown('Your ad campaign received ' +
+                    str(int(information_for_plotting[:, 5].sum())) + ' clicks in total.')
 
-    st.markdown(references)
+        st.pyplot(fig)