Spaces:
Sleeping
Sleeping
| import json | |
| import os | |
| import pickle | |
| import re | |
| import gradio as gr | |
| import matplotlib.pyplot as plt | |
| import networkx as nx | |
| from tqdm import tqdm | |
| def load_json_from_path(path): | |
| with open(path, "r", encoding="utf8") as f: | |
| obj = json.loads(f.read()) | |
| return obj | |
| class Visualizer: | |
| def __init__(self, cache_root="."): | |
| self.iso_codes_to_names = load_json_from_path(os.path.join(cache_root, "iso_to_fullname.json")) | |
| for code in self.iso_codes_to_names: | |
| self.iso_codes_to_names[code] = re.sub("\(.*?\)", "", self.iso_codes_to_names[code]) | |
| tree_lookup_path = os.path.join(cache_root, "lang_1_to_lang_2_to_tree_dist.json") | |
| tree_dist = load_json_from_path(tree_lookup_path) | |
| distances = list() | |
| for lang_1 in tree_dist: | |
| if lang_1 not in self.iso_codes_to_names: | |
| continue | |
| for lang_2 in tree_dist[lang_1]: | |
| if lang_2 not in self.iso_codes_to_names: | |
| continue | |
| if lang_1 != lang_2: | |
| distances.append((self.iso_codes_to_names[lang_1], self.iso_codes_to_names[lang_2], tree_dist[lang_1][lang_2])) | |
| min_dist = min(d for _, _, d in distances) | |
| max_dist = max(d for _, _, d in distances) | |
| self.tree_distances = [(entity1, entity2, (d - min_dist) / (max_dist - min_dist)) for entity1, entity2, d in distances] | |
| map_lookup_path = os.path.join(cache_root, "lang_1_to_lang_2_to_map_dist.json") | |
| map_dist = load_json_from_path(map_lookup_path) | |
| distances = list() | |
| for lang_1 in map_dist: | |
| if lang_1 not in self.iso_codes_to_names: | |
| continue | |
| for lang_2 in map_dist[lang_1]: | |
| if lang_2 not in self.iso_codes_to_names: | |
| continue | |
| if lang_1 != lang_2: | |
| distances.append((self.iso_codes_to_names[lang_1], self.iso_codes_to_names[lang_2], map_dist[lang_1][lang_2])) | |
| min_dist = min(d for _, _, d in distances) | |
| max_dist = max(d for _, _, d in distances) | |
| self.map_distances = [(entity1, entity2, (d - min_dist) / (max_dist - min_dist)) for entity1, entity2, d in distances] | |
| asp_dict_path = os.path.join(cache_root, "asp_dict.pkl") | |
| with open(asp_dict_path, 'rb') as dictfile: | |
| asp_sim = pickle.load(dictfile) | |
| lang_list = list(asp_sim.keys()) | |
| asp_dist = dict() | |
| seen_langs = set() | |
| for lang_1 in lang_list: | |
| if lang_1 not in seen_langs: | |
| seen_langs.add(lang_1) | |
| asp_dist[lang_1] = dict() | |
| for index, lang_2 in enumerate(lang_list): | |
| if lang_2 not in seen_langs: # it's symmetric | |
| asp_dist[lang_1][lang_2] = 1 - asp_sim[lang_1][index] | |
| distances = list() | |
| for lang_1 in asp_dist: | |
| if lang_1 not in self.iso_codes_to_names: | |
| continue | |
| for lang_2 in asp_dist[lang_1]: | |
| if lang_2 not in self.iso_codes_to_names: | |
| continue | |
| if lang_1 != lang_2: | |
| distances.append((self.iso_codes_to_names[lang_1], self.iso_codes_to_names[lang_2], asp_dist[lang_1][lang_2])) | |
| min_dist = min(d for _, _, d in distances) | |
| max_dist = max(d for _, _, d in distances) | |
| self.asp_distances = [(entity1, entity2, (d - min_dist) / (max_dist - min_dist)) for entity1, entity2, d in distances] | |
| def visualize(self, distance_type, neighbor, num_neighbors): | |
| plt.clf() | |
| plt.figure(figsize=(12, 12)) | |
| assert distance_type in ["Physical Distance between Language Centroids on the Globe", | |
| "Distance to the Lowest Common Ancestor in the Language Family Tree", | |
| "Angular Distance between the Frequencies of Phonemes"] | |
| if distance_type == "Distance to the Lowest Common Ancestor in the Language Family Tree": | |
| normalized_distances = self.tree_distances | |
| elif distance_type == "Angular Distance between the Frequencies of Phonemes": | |
| normalized_distances = self.asp_distances | |
| elif distance_type == "Physical Distance between Language Centroids on the Globe": | |
| normalized_distances = self.map_distances | |
| G = nx.Graph() | |
| d_dist = list() | |
| for entity1, entity2, d in tqdm(normalized_distances): | |
| if neighbor == entity2 or neighbor == entity1: | |
| d_dist.append(d) | |
| thresh = sorted(d_dist)[num_neighbors] | |
| neighbors = set() | |
| for entity1, entity2, d in tqdm(normalized_distances): | |
| if d <= thresh and (neighbor == entity2 or neighbor == entity1) and len(neighbors) < num_neighbors + 1: | |
| neighbors.add(entity1) | |
| neighbors.add(entity2) | |
| spring_tension = ((thresh + 0.1) - d) * 100 # for vis purposes | |
| G.add_edge(entity1, entity2, weight=spring_tension) | |
| neighbors.remove(neighbor) | |
| thresh_for_neighbors = max([x for _, _, x in normalized_distances]) | |
| for entity1, entity2, d in tqdm(normalized_distances): | |
| if entity2 in neighbors and entity1 in neighbors: | |
| spring_tension = (thresh_for_neighbors + 0.1) - d | |
| G.add_edge(entity1, entity2, weight=spring_tension) | |
| pos = nx.spring_layout(G, weight="weight", iterations=200, threshold=1e-6) # Positions for all nodes | |
| edges = G.edges(data=True) | |
| nx.draw_networkx_nodes(G, pos, node_size=1, alpha=0.01) | |
| edges_connected_to_specific_node = [(u, v) for u, v in G.edges() if u == neighbor or v == neighbor] | |
| nx.draw_networkx_edges(G, pos, edgelist=edges_connected_to_specific_node, edge_color='orange', alpha=0.4, width=3) | |
| if num_neighbors < 6: | |
| edges_not_connected_to_specific_node = [(u, v) for u, v in G.edges() if u != neighbor and v != neighbor] | |
| nx.draw_networkx_edges(G, pos, edgelist=edges_not_connected_to_specific_node, edge_color='gray', alpha=0.05, width=1) | |
| for u, v, d in edges: | |
| if u == neighbor or v == neighbor: | |
| nx.draw_networkx_edge_labels(G, pos, edge_labels={(u, v): round(((thresh + 0.1) - (d['weight'] / 100)) * 100, 2)}, font_color="red", alpha=0.4) # reverse modifications | |
| nx.draw_networkx_labels(G, pos, font_size=14, font_family='sans-serif', font_color='green') | |
| nx.draw_networkx_labels(G, pos, labels={neighbor: neighbor}, font_size=14, font_family='sans-serif', font_color='red') | |
| plt.title(f'Graph of {distance_type}') | |
| plt.subplots_adjust(left=0, right=1, top=0.9, bottom=0) | |
| plt.tight_layout() | |
| return plt.gcf() | |
| if __name__ == '__main__': | |
| vis = Visualizer(cache_root=".") | |
| text_selection = [f"{vis.iso_codes_to_names[iso_code]}" for iso_code in vis.iso_codes_to_names] | |
| iface = gr.Interface(fn=vis.visualize, | |
| inputs=[gr.Dropdown(["Physical Distance between Language Centroids on the Globe", | |
| "Distance to the Lowest Common Ancestor in the Language Family Tree", | |
| "Angular Distance between the Frequencies of Phonemes"], | |
| type="value", | |
| value='Physical Distance between Language Centroids on the Globe', | |
| label="Select the Type of Distance"), | |
| gr.Dropdown(text_selection, | |
| type="value", | |
| value="German", | |
| label="Select the second Language (type on your keyboard to find it quickly)"), | |
| gr.Slider(minimum=0, maximum=100, step=1, | |
| value=12, | |
| label="How many Nearest Neighbors should be displayed?") | |
| ], | |
| outputs=[gr.Plot(label="", show_label=False, format="png", container=True)], | |
| description="<br><br> This demo allows you to find the nearest neighbors of a language from the ISO 639-3 list according to several distance measurement functions. " | |
| "For more information, check out our paper: https://arxiv.org/abs/2406.06403 and our text-to-speech tool, in which we make use of " | |
| "this technique: https://github.com/DigitalPhonetics/IMS-Toucan <br><br>", | |
| allow_flagging="never") | |
| iface.launch() | |