Upload app.py

app.py

@@ -0,0 +1,243 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Sun Mar 26 21:07:00 2023
+
+@author: Bernd Ebenhoch
+"""
+
+
+import tensorflow as tf
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib import animation
+from matplotlib.animation import FuncAnimation
+import matplotlib as mpl
+import streamlit as st
+
+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
+
+
+# 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]
+
+tab1, tab2, tab3 = st.tabs(["Künstliche Neuronale Netze", "Wörter Maskieren", "Demos"])
+
+
+with tab1:
+    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 einzelnen 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:
+
+    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'):
+        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
+
+            # data = tf.data.Dataset.from_tensor_slices(vectorizer(text),vectorizer(text))
+            # data = data.map(masking_generator)
+            model = tf.keras.models.Sequential()
+
+            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'))
+
+            model.summary()
+
+            model.compile(optimizer='adam', loss='sparse_categorical_crossentropy',
+                          metrics=['accuracy'])
+
+            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)
+
+            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)
+
+            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)
+
+            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)
+
+            st.pyplot(fig)
+
+
+# %%
+with tab3:
+    st.header("An owl")