app.py

import json
import pickle

import gradio as gr
import matplotlib.pyplot as plt
import numpy as np


def plot_scalar_on_scale(scalar_value, distance_type):
 # Ensure the scalar is within bounds
 scalar_value = np.clip(scalar_value, 0.0, 1.0)

 # Create a figure and axis
 fig, ax = plt.subplots(figsize=(8, 2))

 # Create a horizontal gradient (from close to distant)
 gradient = np.linspace(0, 1, 256).reshape(1, -1)
 ax.imshow(gradient, extent=[0, 1, 0, 1], aspect='auto', cmap='viridis_r')

 # Plot the scalar value as a vertical line
 ax.axvline(x=scalar_value, color='white', lw=5)

 # Add a dot at the scalar position
 ax.plot(scalar_value, 0.5, 'o', color='white', markersize=16)

 # Add labels
 ax.text(0, -0.2, 'Close', ha='center', va='center', fontsize=12)
 ax.text(1, -0.2, 'Distant', ha='center', va='center', fontsize=12)

 # Customize the axis
 ax.set_xticks([]) # Remove x-axis ticks
 ax.set_yticks([]) # Remove y-axis ticks
 ax.set_xlim(0, 1)
 ax.set_ylim(0, 1)
 ax.set_title(distance_type)

 # Remove spines for a cleaner look
 ax.spines['top'].set_visible(False)
 ax.spines['right'].set_visible(False)
 ax.spines['bottom'].set_visible(False)
 ax.spines['left'].set_visible(False)

 return fig

 # Show the plot
 # plt.tight_layout()
 # plt.show()


def load_json_from_path(path):
 with open(path, "r", encoding="utf8") as f:
 obj = json.loads(f.read())

 return obj


class Measurer:
 def __init__(self):

 # learned dist
 tree_lookup_path = "lang_1_to_lang_2_to_learned_dist.json"
 self.learned_dist_func = load_json_from_path(tree_lookup_path)

 # tree dist
 tree_lookup_path = "lang_1_to_lang_2_to_tree_dist.json"
 self.tree_dist_func = load_json_from_path(tree_lookup_path)

 # map dist
 map_lookup_path = "lang_1_to_lang_2_to_map_dist.json"
 self.map_dist_func = load_json_from_path(map_lookup_path)
 largest_value_map_dist = 0.0
 for _, values in self.map_dist_func.items():
 for _, value in values.items():
 largest_value_map_dist = max(largest_value_map_dist, value)
 for key1 in self.map_dist_func:
 for key2 in self.map_dist_func[key1]:
 self.map_dist_func[key1][key2] = self.map_dist_func[key1][key2] / largest_value_map_dist

 # ASP
 asp_dict_path = "asp_dict.pkl"
 with open(asp_dict_path, 'rb') as dictfile:
 asp_sim = pickle.load(dictfile)
 lang_list = list(asp_sim.keys())
 self.asp_dist_func = dict()
 seen_langs = set()
 for lang_1 in lang_list:
 if lang_1 not in seen_langs:
 seen_langs.add(lang_1)
 self.asp_dist_func[lang_1] = dict()
 for index, lang_2 in enumerate(lang_list):
 if lang_2 not in seen_langs: # it's symmetric
 self.asp_dist_func[lang_1][lang_2] = 1 - asp_sim[lang_1][index]

 def get_dists(self, l1, l2):
 if l1 in self.tree_dist_func:
 tree_dist = self.tree_dist_func[l1][l2]
 else:
 tree_dist = self.tree_dist_func[l2][l1]
 if l1 in self.map_dist_func:
 map_dist = self.map_dist_func[l1][l2]
 else:
 map_dist = self.map_dist_func[l2][l1]
 if l1 in self.asp_dist_func:
 asp_dist = self.asp_dist_func[l1][l2]
 else:
 asp_dist = self.asp_dist_func[l2][l1]
 if l1 in self.learned_dist_func:
 learned_dist = self.learned_dist_func[l1][l2]
 else:
 learned_dist = self.learned_dist_func[l2][l1]
 return tree_dist, map_dist, asp_dist, learned_dist

 def measure(self, l1, l2):
 if l1 == l2:
 f1 = plot_scalar_on_scale(0.0, "Language Family Tree Distance")
 f2 = plot_scalar_on_scale(0.0, "Distance on the Globe")
 f3 = plot_scalar_on_scale(0.0, "Distance between Phoneme-Sets")
 f4 = plot_scalar_on_scale(0.0, "Learned Distance Function")
 else:
 tree_dist, map_dist, asp_dist, learned_dist = self.get_dists(l1.split(" ")[-1].split("(")[1].split(")")[0],
 l2.split(" ")[-1].split("(")[1].split(")")[0])
 f1 = plot_scalar_on_scale(tree_dist, "Language Family Tree Distance")
 f2 = plot_scalar_on_scale(map_dist, "Distance on the Globe")
 f3 = plot_scalar_on_scale(asp_dist, "Distance between Phoneme-Sets")
 f4 = plot_scalar_on_scale(learned_dist, "Learned Distance Function")

 return f1, f2, f3, f4


if __name__ == '__main__':
 m = Measurer()
 iso_to_name = load_json_from_path("iso_to_fullname.json")
 text_selection = [f"{iso_to_name[iso_code]} ({iso_code})" for iso_code in iso_to_name]
 iface = gr.Interface(fn=m.measure,
 inputs=[gr.Dropdown(text_selection,
 type="value",
 value='English (eng)',
 label="Select the fist Language (type on your keyboard to find it quickly)"),
 gr.Dropdown(text_selection,
 type="value",
 value='German (deu)',
 label="Select the second Language (type on your keyboard to find it quickly)")],
 outputs=[gr.Plot(),
 gr.Plot(),
 gr.Plot(),
 gr.Plot()])
 iface.launch()