Update app.py

app.py

@@ -0,0 +1,147 @@
+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()