| import streamlit as st | |
| import matplotlib.pyplot as plt | |
| import numpy as np | |
| from mpl_toolkits.mplot3d import Axes3D | |
| import umap | |
| import pandas as pd | |
| from word2vec import * | |
| from sklearn.preprocessing import StandardScaler | |
| import plotly.express as px | |
| # def make_3d_plot(new_3d_vectors): | |
| # """ | |
| # Turn DataFrame of 3D vectors into a 3D plot | |
| # DataFrame structure: ['word', 'cosine_sim', '3d_vector'] | |
| # """ | |
| # fig = plt.figure() | |
| # ax = fig.add_subplot(projection='3d') | |
| # plt.ion() | |
| # # Unpack vectors and labels from DataFrame | |
| # labels = new_3d_vectors['word'] | |
| # x = new_3d_vectors['3d_vector'].apply(lambda v: v[0]) | |
| # y = new_3d_vectors['3d_vector'].apply(lambda v: v[1]) | |
| # z = new_3d_vectors['3d_vector'].apply(lambda v: v[2]) | |
| # # Plot points | |
| # ax.scatter(x, y, z) | |
| # # Add labels | |
| # for i, label in enumerate(labels): | |
| # ax.text(x[i], y[i], z[i], label) | |
| # # Set labels and title | |
| # ax.set_xlabel('X') | |
| # ax.set_ylabel('Y') | |
| # ax.set_zlabel('Z') | |
| # ax.set_title('3D plot of word vectors') | |
| # return fig | |
| # def make_3d_plot2(df): | |
| # """ | |
| # Turn DataFrame of 3D vectors into a 3D plot using plotly | |
| # DataFrame structure: ['word', 'cosine_sim', '3d_vector'] | |
| # """ | |
| # vectors = df['3d_vector'].tolist() | |
| # fig = px.scatter_3d(df, x=[v[0] for v in vectors], y=[v[1] for v in vectors], z=[v[2] for v in vectors], text=df['word']) | |
| # return fig | |
| # def make_3d_plot3(vectors_list, word, time_slice_model): | |
| # """ | |
| # Turn list of 100D vectors into a 3D plot using UMAP and Plotly. | |
| # List structure: [(word, model_name, vector, cosine_sim)] | |
| # """ | |
| # # Load model | |
| # model = load_word2vec_model(f'models/{time_slice_model}.model') | |
| # # Make UMAP model and fit it to the vectors | |
| # umap_model = umap.UMAP(n_components=3) | |
| # umap_model.fit(model.wv.vectors) | |
| # # Transform the vectors to 3D | |
| # transformed_vectors = umap_model.transform(model.wv.vectors) | |
| # # Create DataFrame from the transformed vectors | |
| # df = pd.DataFrame(transformed_vectors, columns=['x', 'y', 'z']) | |
| # # Add word and cosine similarity to DataFrame | |
| # df['word'] = model.wv.index_to_key | |
| # # Filter the DataFrame for words in vectors_list and add cosine similarity | |
| # word_list = [v[0] for v in vectors_list] | |
| # cosine_sim_list = [v[3] for v in vectors_list] | |
| # # Ensure that the word list and cosine similarity list are aligned properly | |
| # df = df[df['word'].isin(word_list)] | |
| # df['cosine_sim'] = cosine_sim_list | |
| # # Create plot | |
| # fig = px.scatter_3d(df, x='x', y='y', z='z', text='word', color='cosine_sim', color_continuous_scale='Reds') | |
| # fig.update_traces(marker=dict(size=5)) | |
| # fig.update_layout(title=f'3D plot of nearest neighbours to {word}') | |
| # return fig, df | |
| def make_3d_plot4(vectors_list, word, time_slice_model): | |
| """ | |
| Turn list of 100D vectors into a 3D plot using UMAP and Plotly. | |
| List structure: [(word, model_name, vector, cosine_sim)] | |
| """ | |
| # Load model | |
| model = load_word2vec_model(f'models/{time_slice_model}.model') | |
| model_dict = model_dictionary(model) | |
| # Extract vectors and names from model_dict | |
| all_vector_names = list(model_dict.keys()) | |
| all_vectors = list(model_dict.values()) | |
| # Scale the vectors | |
| scaler = StandardScaler() | |
| vectors_scaled = scaler.fit_transform(all_vectors) | |
| # Make UMAP model and fit it to the scaled vectors | |
| umap_model = umap.UMAP(n_components=3) | |
| umap_result = umap_model.fit_transform(vectors_scaled) | |
| # Now umap_result contains the 3D representations of the vectors | |
| # Associate the names with the 3D representations | |
| result_with_names = [(all_vector_names[i], umap_result[i]) for i in range(len(all_vector_names))] | |
| # Only keep the vectors that are in vectors_list and their cosine similarities | |
| result_with_names = [r for r in result_with_names if r[0] in [v[0] for v in vectors_list]] | |
| result_with_names = [(r[0], r[1], [v[3] for v in vectors_list if v[0] == r[0]][0]) for r in result_with_names] | |
| # Create DataFrame from the transformed vectors | |
| df = pd.DataFrame(result_with_names, columns=['word', '3d_vector', 'cosine_sim']) | |
| # Sort dataframe by cosine_sim | |
| df = df.sort_values(by='cosine_sim', ascending=False) | |
| x = df['3d_vector'].apply(lambda v: v[0]) | |
| y = df['3d_vector'].apply(lambda v: v[1]) | |
| z = df['3d_vector'].apply(lambda v: v[2]) | |
| # Create plot | |
| fig = px.scatter_3d(df, x=x, y=y, z=z, text='word', color='cosine_sim', color_continuous_scale='Reds') | |
| fig.update_traces(marker=dict(size=5)) | |
| fig.update_layout(title=f'3D plot of nearest neighbours to {word}') | |
| return fig, df | |