fix: cleanup build config again, reverting reverted changes

Dockerfile

@@ -3,8 +3,8 @@
 # complete build based on clean python (slower)
 #FROM python:3.11.6
 
-# build based on python with dependencies (quicker) - for dev
-FROM thesis:0.2.0-base
+# build based on thesis base with dependencies (quicker) - for dev
+FROM thesis-base:0.1.1
 
 # install dependencies and copy files into image folder
 COPY requirements.txt .
@@ -16,8 +16,8 @@ COPY . .
 RUN ls --recursive .
 
 # setting config and run command
-CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8080"]
 
 # build and run commands:
-## docker build -t thesis:0.2.0-full -f Dockerfile .
-## docker run -d --name thesis -p 8080:8080 thesis:0.2.0
+## docker build -t thesis:0.1.4 -f Dockerfile .
+## docker run -d --name thesis -p 8080:8080 thesis:0.1.4

Dockerfile-Base

@@ -2,11 +2,11 @@
 # because all dependencies are already installed, the next webapp build using this base image is much quicker
 
 # using newest python as a base image
-FROM python:3.11.6
+FROM thesis-base:0.1.1
 
 # install dependencies based on requirements
 COPY requirements.txt ./
 RUN pip install --no-cache-dir --upgrade -r requirements.txt
 
 # build and run commands
-## docker build -t thesis:0.1.6-base -f Dockerfile-Base .
+## docker build -t thesis-base:1.0.1 -f Dockerfile-Base .

README.md

@@ -3,12 +3,12 @@ title: Thesis
 emoji: 🎓
 colorFrom: red
 colorTo: yellow
-sdk: docker
+sdk: gradio
 sdk_version: 4.7.1
 app_file: main.py
 pinned: true
 license: mit
-app_port: 7860
+app_port: 8080
 ---
 
 # Bachelor Thesis

backend/controller.py

@@ -10,7 +10,6 @@ from explanation import interpret, visualize
 
 
 # main interference function that that calls chat functions depending on selections
-# TODO: Limit maximum tokens/model input
 def interference(
     prompt: str,
     history: list,

entrypoint.sh

@@ -1,8 +0,0 @@
-#!/bin/bash
-# entrypoint script for the docker container to run at start
-
-# installing all the dependencies
-pip install --no-cache-dir --upgrade -r requirements.txt
-
-# running the fastapi app
-uvicorn main:app --host 0.0.0.0 --port 8080

explanation/interpret.py

@@ -62,35 +62,29 @@ def create_graphic(shap_values):
     return str(graphic_html)
 
 
-# plotting function that creates a heatmap style explanation plot
+# creating an attention heatmap plot using matplotlib/seaborn
+# CREDIT: adopted from official Matplotlib documentation
+## see https://matplotlib.org/stable/
 def create_plot(shap_values):
     values = shap_values.values[0]
     output_names = shap_values.output_names
     input_names = shap_values.data[0]
 
-    # Transpose the values for horizontal input names
-    transposed_values = np.transpose(values)
-
     # Set seaborn style to dark
-    sns.set(style="dark")
-
+    sns.set(style="white")
     fig, ax = plt.subplots()
 
-    # Making background transparent
-    ax.set_alpha(0)
-    fig.patch.set_alpha(0)
-
     # Setting figure size
     fig.set_size_inches(
-        max(transposed_values.shape[1] * 2, 10),
-        max(transposed_values.shape[0] / 1.5, 5),
+        max(values.shape[1] * 2, 10),
+        max(values.shape[0] * 1, 5),
     )
 
     # Plotting the heatmap with Seaborn's color palette
     im = ax.imshow(
-        transposed_values,
-        vmax=transposed_values.max(),
-        vmin=-transposed_values.min(),
+        values,
+        vmax=values.max(),
+        vmin=values.min(),
         cmap=sns.color_palette("vlag_r", as_cmap=True),
         aspect="auto",
     )
@@ -98,25 +92,25 @@ def create_plot(shap_values):
     # Creating colorbar
     cbar = ax.figure.colorbar(im, ax=ax)
     cbar.ax.set_ylabel("Token Attribution", rotation=-90, va="bottom")
-    cbar.ax.yaxis.set_tick_params(color="white")
-    plt.setp(plt.getp(cbar.ax.axes, "yticklabels"), color="white")
+    cbar.ax.yaxis.set_tick_params(color="black")
+    plt.setp(plt.getp(cbar.ax.axes, "yticklabels"), color="black")
 
     # Setting ticks and labels with white color for visibility
-    ax.set_xticks(np.arange(len(input_names)), labels=input_names)
-    ax.set_yticks(np.arange(len(output_names)), labels=output_names)
-    plt.setp(ax.get_xticklabels(), color="white", rotation=45, ha="right")
-    plt.setp(ax.get_yticklabels(), color="white")
+    ax.set_yticks(np.arange(len(input_names)), labels=input_names)
+    ax.set_xticks(np.arange(len(output_names)), labels=output_names)
+    plt.setp(ax.get_xticklabels(), color="black", rotation=45, ha="right")
+    plt.setp(ax.get_yticklabels(), color="black")
 
     # Adjusting tick labels
     ax.tick_params(
         top=True, bottom=False, labeltop=False, labelbottom=True, color="white"
     )
 
-    # Adding text annotations - not used for readability
-    # for i in range(transposed_values.shape[0]):
-    #    for j in range(transposed_values.shape[1]):
-    #        val = transposed_values[i, j]
-    #        color = "black" if 0.2 < im.norm(val) < 0.8 else "white"
-    #        ax.text(j, i, f"{val:.4f}", ha="center", va="center", color=color)
+    # Adding text annotations with appropriate contrast
+    for i in range(values.shape[0]):
+        for j in range(values.shape[1]):
+            val = values[i, j]
+            color = "white" if im.norm(values.max()) / 2 > im.norm(val) else "black"
+            ax.text(j, i, f"{val:.4f}", ha="center", va="center", color=color)
 
     return plt

explanation/visualize.py

@@ -57,28 +57,27 @@ def create_graphic(attention_output, enc_dec_texts: tuple):
     return str(hview.data)
 
 
-# creating an attention heatmap plot using seaborn
+# creating an attention heatmap plot using matplotlib/seaborn
+# CREDIT: adopted from official Matplotlib documentation
+## see https://matplotlib.org/stable/
 def create_plot(attention_output, enc_dec_texts: tuple):
     # get the averaged attention weights
     attention = attention_output.cross_attentions[0][0].detach().numpy()
     averaged_attention_weights = np.mean(attention, axis=0)
+    averaged_attention_weights = np.transpose(averaged_attention_weights)
 
-    # get the encoder and decoder tokens
+    # get the encoder and decoder tokens in text form
     encoder_tokens = enc_dec_texts[0]
     decoder_tokens = enc_dec_texts[1]
 
     # set seaborn style to dark and initialize figure and axis
-    sns.set(style="dark")
+    sns.set(style="white")
     fig, ax = plt.subplots()
 
-    # Making background transparent
-    ax.set_alpha(0)
-    fig.patch.set_alpha(0)
-
     # Setting figure size
     fig.set_size_inches(
         max(averaged_attention_weights.shape[1] * 2, 10),
-        max(averaged_attention_weights.shape[0] / 1.5, 5),
+        max(averaged_attention_weights.shape[0] * 1, 5),
     )
 
     # Plotting the heatmap with seaborn's color palette
@@ -92,19 +91,27 @@ def create_plot(attention_output, enc_dec_texts: tuple):
 
     # Creating colorbar
     cbar = ax.figure.colorbar(im, ax=ax)
-    cbar.ax.set_ylabel("Token Attribution", rotation=-90, va="bottom")
-    cbar.ax.yaxis.set_tick_params(color="white")
-    plt.setp(plt.getp(cbar.ax.axes, "yticklabels"), color="white")
-
-    # Setting ticks and labels with white color for visibility
-    ax.set_xticks(np.arange(len(encoder_tokens)), labels=encoder_tokens)
-    ax.set_yticks(np.arange(len(decoder_tokens)), labels=decoder_tokens)
-    plt.setp(ax.get_xticklabels(), color="white", rotation=45, ha="right")
-    plt.setp(ax.get_yticklabels(), color="white")
-
-    # Adjusting tick labels
-    ax.tick_params(
-        top=True, bottom=False, labeltop=False, labelbottom=True, color="white"
-    )
-
+    cbar.ax.set_ylabel("Attention Weight Scale", rotation=-90, va="bottom")
+    cbar.ax.yaxis.set_tick_params(color="black")
+    plt.setp(plt.getp(cbar.ax.axes, "yticklabels"), color="black")
+
+    # Setting ticks and labels with black color for visibility
+    ax.set_yticks(np.arange(len(encoder_tokens)), labels=encoder_tokens)
+    ax.set_xticks(np.arange(len(decoder_tokens)), labels=decoder_tokens)
+    ax.set_title("Attention Weights by Token")
+    plt.setp(ax.get_xticklabels(), color="black", rotation=45, ha="right")
+    plt.setp(ax.get_yticklabels(), color="black")
+
+    # Adding text annotations with appropriate contrast
+    for i in range(averaged_attention_weights.shape[0]):
+        for j in range(averaged_attention_weights.shape[1]):
+            val = averaged_attention_weights[i, j]
+            color = (
+                "white"
+                if im.norm(averaged_attention_weights.max()) / 2 > im.norm(val)
+                else "black"
+            )
+            ax.text(j, i, f"{val:.4f}", ha="center", va="center", color=color)
+
+    # return the plot
     return plt

main.py

@@ -1,12 +1,19 @@
 # main application file initializing the gradio based ui and calling other
+
+# standard imports
+import os
+
 # external imports
 from fastapi import FastAPI
 import markdown
 import gradio as gr
+from uvicorn import run
+
 
 # internal imports
 from backend.controller import interference
 
+
 # Global Variables and css
 app = FastAPI()
 css = "body {text-align: start !important;}"
@@ -187,7 +194,7 @@ with gr.Blocks(
                 Values have been excluded for readability. See colorbar for value indication.
                 """)
                 # plot component that takes a matplotlib figure as input
-                xai_plot = gr.Plot(label="Token Level Explanation", scale=3)
+                xai_plot = gr.Plot(label="Token Level Explanation")
 
     # functions to trigger the controller
     ## takes information for the chat and the xai selection
@@ -207,16 +214,21 @@ with gr.Blocks(
 
     # final row to show legal information
     ## - credits, data protection and link to the License
-    with gr.Tab(label="Credits, Data Protection and License"):
-        gr.Markdown(value=load_md("public/credits_dataprotection_license.md"))
+    with gr.Tab(label="About"):
+        gr.Markdown(value=load_md("public/about.md"))
+        with gr.Accordion(label="Credits, Data Protection, License"):
+            gr.Markdown(value=load_md("public/credits_dataprotection_license.md"))
 
 # mount function for fastAPI Application
 app = gr.mount_gradio_app(app, ui, path="/")
 
 # launch function using uvicorn to launch the fastAPI application
 if __name__ == "__main__":
-    from uvicorn import run
 
-    # run the application on port 8080 in reload mode
+    # use standard gradio launch option for hgf spaces
+    if os.environ["HOSTING"].lower() == "spaces":
+        ui.launch(auth=("htw", "berlin@123"))
+
+    # otherwise run the application on port 8080 in reload mode
     ## for local development, uses Docker for Prod deployment
     run("main:app", port=8080, reload=True)