Spaces:
Sleeping
Sleeping
| """ | |
| Build an editable user profile based recommender. | |
| - Read the users json and read their paper reps and keyphrases into memory. | |
| - Read the candidates document (first stage retrieval) and | |
| sentence embeddings into memory (second stage retrieval). | |
| - Display the keyphrases to users and ask them to check it. | |
| - Use the keyphrases and sentence embeddings to compute keyphrase values. | |
| - Display the keyphrase selection box to users for retrieval. | |
| - Use the selected keyphrases for performing retrieval. | |
| """ | |
| import copy | |
| import json | |
| import pickle | |
| import re | |
| import joblib | |
| import os | |
| import collections | |
| import streamlit as st | |
| import numpy as np | |
| from scipy.spatial import distance | |
| from scipy import special | |
| from sklearn.neighbors import NearestNeighbors | |
| from sentence_transformers import SentenceTransformer, models | |
| import torch | |
| import ot | |
| # import seaborn as sns | |
| # import matplotlib | |
| # matplotlib.use('Agg') | |
| # import matplotlib.pyplot as plt | |
| # plt.rcParams['figure.dpi'] = 400 | |
| # plt.rcParams.update({'axes.labelsize': 'small'}) | |
| in_path = './data' | |
| ######################################## | |
| # BACKEND CODE # | |
| ######################################## | |
| def read_user(seed_json): | |
| """ | |
| Given the seed json for the user read the embedded | |
| documents for the user. | |
| :param seed_json: | |
| :return: | |
| """ | |
| if 'doc_vectors_user' not in st.session_state: | |
| uname = seed_json['username'] | |
| user_kps = seed_json['user_kps'] | |
| # Read document vectors. | |
| doc_vectors_user = np.load(os.path.join(in_path, 'users', uname, f'embeds-{uname}-doc.npy')) | |
| with open(os.path.join(in_path, 'users', uname, f'pid2idx-{uname}-doc.json'), 'r') as fp: | |
| pid2idx_user = json.load(fp) | |
| # Read sentence vectors. | |
| pid2sent_vectors = joblib.load(os.path.join(in_path, 'users', uname, f'embeds-{uname}-sent.pickle')) | |
| pid2sent_vectors_user = collections.OrderedDict() | |
| for pid in sorted(pid2sent_vectors): | |
| pid2sent_vectors_user[pid] = pid2sent_vectors[pid] | |
| st.session_state['doc_vectors_user'] = doc_vectors_user | |
| st.session_state['pid2idx_user'] = pid2idx_user | |
| st.session_state['pid2sent_vectors_user'] = pid2sent_vectors_user | |
| st.session_state['user_kps'] = user_kps | |
| st.session_state['username'] = uname | |
| st.session_state['seed_titles'] = [] | |
| for pd in seed_json['papers']: | |
| norm_title = " ".join(pd['title'].lower().strip().split()) | |
| st.session_state.seed_titles.append(norm_title) | |
| return doc_vectors_user, pid2idx_user, pid2sent_vectors, user_kps | |
| else: | |
| return st.session_state.doc_vectors_user, st.session_state.pid2idx_user, \ | |
| st.session_state.pid2sent_vectors_user, st.session_state.user_kps | |
| def first_stage_ranked_docs(user_doc_queries, per_doc_to_rank, total_to_rank=2000): | |
| """ | |
| Return a list of ranked documents given a set of queries. | |
| :param user_doc_queries: read the cached query embeddings | |
| :return: | |
| """ | |
| if 'first_stage_ret_pids' not in st.session_state: | |
| # read the document vectors | |
| doc_vectors = np.load(os.path.join(in_path, 'cands', 'embeds-mlconfs-18_23.npy')) | |
| with open(os.path.join(in_path, 'cands', 'pid2idx-mlconfs-18_23.pickle'), 'rb') as fp: | |
| pid2idx_cands = pickle.load(fp) | |
| idx2pid_cands = dict([(v, k) for k, v in pid2idx_cands.items()]) | |
| # index the vectors into a nearest neighbors structure | |
| neighbors = NearestNeighbors(n_neighbors=per_doc_to_rank) | |
| neighbors.fit(doc_vectors) | |
| st.session_state['neighbors'] = neighbors | |
| st.session_state['idx2pid_cands'] = idx2pid_cands | |
| # Get the dists for all the query docs. | |
| nearest_dists, nearest_idxs = neighbors.kneighbors(user_doc_queries, return_distance=True) | |
| # Get the docs | |
| top_pids = [] | |
| uniq_top = set() | |
| for ranki in range(per_doc_to_rank): # Save papers by rank position for debugging. | |
| for qi in range(user_doc_queries.shape[0]): | |
| idx = nearest_idxs[qi, ranki] | |
| pid = idx2pid_cands[idx] | |
| if pid not in uniq_top: # Only save the unique papers. (ignore multiple retrievals of the same paper) | |
| top_pids.append(pid) | |
| uniq_top.add(pid) | |
| top_pids = top_pids[:total_to_rank] | |
| st.session_state['first_stage_ret_pids'] = top_pids | |
| return top_pids | |
| else: | |
| return st.session_state.first_stage_ret_pids | |
| def read_kp_encoder(in_path): | |
| """ | |
| Read the kp encoder model from disk. | |
| :param in_path: string; | |
| :return: | |
| """ | |
| if 'kp_enc_model' not in st.session_state: | |
| word_embedding_model = models.Transformer('Sheshera/lace-kp-encoder-compsci', | |
| max_seq_length=512) | |
| # trained_model_fname = os.path.join(in_path, 'models', 'kp_encoder_cur_best.pt') | |
| # if torch.cuda.is_available(): | |
| # saved_model = torch.load(trained_model_fname) | |
| # else: | |
| # saved_model = torch.load(trained_model_fname, map_location=torch.device('cpu')) | |
| # word_embedding_model.auto_model.load_state_dict(saved_model) | |
| pooling_model = models.Pooling(word_embedding_model.get_word_embedding_dimension(), pooling_mode='mean') | |
| kp_enc_model = SentenceTransformer(modules=[word_embedding_model, pooling_model]) | |
| st.session_state['kp_enc_model'] = kp_enc_model | |
| else: | |
| return st.session_state.kp_enc_model | |
| def read_candidates(in_path): | |
| """ | |
| Read candidate papers into pandas dataframe. | |
| :param in_path: | |
| :return: | |
| """ | |
| if 'pid2abstract' not in st.session_state: | |
| with open(os.path.join(in_path, 'cands', 'abstract-mlconfs-18_23.pickle'), 'rb') as fp: | |
| pid2abstract = pickle.load(fp) | |
| # read the sentence vectors | |
| pid2sent_vectors = joblib.load(os.path.join(in_path, 'cands', f'embeds-sent-mlconfs-18_23.pickle')) | |
| st.session_state['pid2sent_vectors_cands'] = pid2sent_vectors | |
| st.session_state['pid2abstract'] = pid2abstract | |
| return pid2abstract, pid2sent_vectors | |
| else: | |
| return st.session_state.pid2abstract, st.session_state.pid2sent_vectors_cands | |
| def get_kp_embeddings(profile_keyphrases): | |
| """ | |
| Embed the passed profike keyphrases | |
| :param profile_keyphrases: list(string) | |
| :return: | |
| """ | |
| kp_enc_model = st.session_state['kp_enc_model'] | |
| if 'kp_vectors_user' not in st.session_state: | |
| kp_embeddings = kp_enc_model.encode(profile_keyphrases) | |
| kp_vectors_user = collections.OrderedDict() | |
| for i, kp in enumerate(profile_keyphrases): | |
| kp_vectors_user[kp] = kp_embeddings[i, :] | |
| st.session_state['kp_vectors_user'] = kp_vectors_user | |
| return kp_vectors_user | |
| else: | |
| uncached_kps = [kp for kp in profile_keyphrases if kp not in st.session_state.kp_vectors_user] | |
| kp_embeddings = kp_enc_model.encode(uncached_kps) | |
| for i, kp in enumerate(uncached_kps): | |
| st.session_state.kp_vectors_user[kp] = kp_embeddings[i, :] | |
| return st.session_state.kp_vectors_user | |
| def generate_profile_values(profile_keyphrases): | |
| """ | |
| - Read sentence embeddings | |
| - Read profile keyphrase embeddings | |
| - Compute alignment from sentences to keyphrases | |
| - Barycenter project the keyphrases to sentences to get kp values | |
| - Return the kp values | |
| :param profile_keyphrases: list(string) | |
| :return: | |
| """ | |
| kp_embeddings = get_kp_embeddings(profile_keyphrases) | |
| # Read sentence embeddings. | |
| user_seed_sentembeds = np.vstack(list(st.session_state.pid2sent_vectors_user.values())) | |
| # Read keyphrase embeddings. | |
| kps_embeds_flat = [] | |
| for kp in profile_keyphrases: | |
| kps_embeds_flat.append(kp_embeddings[kp]) | |
| kps_embeds_flat = np.vstack(kps_embeds_flat) | |
| # Compute transport plan from sentence to keyphrases. | |
| pair_dists = distance.cdist(user_seed_sentembeds, kps_embeds_flat, 'euclidean') | |
| a_distr = [1 / user_seed_sentembeds.shape[0]] * user_seed_sentembeds.shape[0] | |
| b_distr = [1 / kps_embeds_flat.shape[0]] * kps_embeds_flat.shape[0] | |
| # tplan = ot.bregman.sinkhorn_epsilon_scaling(a_distr, b_distr, pair_dists, 0.05, numItermax=2000) | |
| tplan = ot.partial.entropic_partial_wasserstein(a_distr, b_distr, pair_dists, 0.05, m=0.8) | |
| # Barycenter project the keyphrases to the sentences: len(profile_keyphraases) x embedding_dim | |
| proj_kp_vectors = np.matmul(user_seed_sentembeds.T, tplan).T | |
| norm = np.sum(tplan, axis=0) | |
| kp_value_vectors = proj_kp_vectors/norm[:, np.newaxis] | |
| # Return as a dict. | |
| kp2valvectors = {} | |
| for i, kp in enumerate(profile_keyphrases): | |
| kp2valvectors[kp] = kp_value_vectors[i, :] | |
| return kp2valvectors, tplan | |
| def second_stage_ranked_docs(selected_query_kps, first_stage_pids, pid2abstract, pid2sent_reps_cand, to_rank=30): | |
| """ | |
| Return a list of ranked documents given a set of queries. | |
| :param first_stage_pids: list(string) | |
| :param pid2abstract: dict(pid: paperd) | |
| :param query_paper_idxs: list(int); | |
| :return: | |
| """ | |
| if len(selected_query_kps) < 3: | |
| topk = len(selected_query_kps) | |
| else: # Use 20% of keyphrases for scoring or 3 whichever is larger | |
| topk = max(int(len(st.session_state.kp2val_vectors)*0.2), 3) | |
| query_kp_values = np.vstack([st.session_state.kp2val_vectors[kp] for kp in selected_query_kps]) | |
| pid2topkdist = dict() | |
| pid2kp_expls = collections.defaultdict(list) | |
| for i, pid in enumerate(first_stage_pids): | |
| sent_reps = pid2sent_reps_cand[pid] | |
| pair_dists = distance.cdist(query_kp_values, sent_reps) | |
| # Pick the topk unique profile concepts. | |
| kp_ind = np.argsort(pair_dists.min(axis=1))[:topk] | |
| sub_pair_dists = pair_dists[kp_ind, :] | |
| # sub_kp_reps = query_kp_values[kp_ind, :] | |
| # a_distr = special.softmax(-1*np.min(sub_pair_dists, axis=1)) | |
| # b_distr = [1 / sent_reps.shape[0]] * sent_reps.shape[0] | |
| # tplan = ot.bregman.sinkhorn_epsilon_scaling(a_distr, b_distr, sub_pair_dists, 0.05) | |
| # Use attention instead of OT for distance computation | |
| tplan = special.softmax(-1 * sub_pair_dists) | |
| wd = np.sum(sub_pair_dists * tplan) | |
| # topk_dist = 0 | |
| # for k in range(topk): | |
| # topk_dist += pair_dists[kp_ind[k], sent_ind[k]] | |
| # pid2kp_expls[pid].append(selected_query_kps[kp_ind[k]]) | |
| # pid2topkdist[pid] = topk_dist | |
| pid2topkdist[pid] = wd | |
| top_pids = sorted(pid2topkdist, key=pid2topkdist.get) | |
| # Get the docs | |
| retrieved_papers = collections.OrderedDict() | |
| for pid in top_pids: | |
| # Exclude papers from the seed set in the result set. | |
| norm_title = " ".join(pid2abstract[pid]['title'].lower().strip().split()) | |
| # The mlconf pid2abstract has braces in the titles sometimes - remove them | |
| norm_title = re.sub('\{', '', norm_title) | |
| norm_title = re.sub('\}', '', norm_title) | |
| if norm_title in st.session_state.seed_titles: | |
| continue | |
| retrieved_papers[pid2abstract[pid]['title']] = { | |
| 'title': pid2abstract[pid]['title'], | |
| 'kp_explanations': pid2kp_expls[pid], | |
| 'abstract': pid2abstract[pid]['abstract'], | |
| 'author_names': pid2abstract[pid]['author_names'], | |
| 'url': pid2abstract[pid]['url'], | |
| } | |
| if len(retrieved_papers) == to_rank: | |
| break | |
| return retrieved_papers | |
| ######################################## | |
| # HELPER CODE # | |
| ######################################## | |
| def parse_input_kps(unparsed_kps, initial_user_kps): | |
| """ | |
| Function to parse the input keyphrase string. | |
| :return: | |
| """ | |
| if unparsed_kps.strip(): | |
| kps = unparsed_kps.split(',') | |
| parsed_user_kps = [] | |
| uniq_kps = set() | |
| for kp in kps: | |
| kp = kp.strip() | |
| if kp not in uniq_kps: | |
| parsed_user_kps.append(kp) | |
| uniq_kps.add(kp) | |
| else: # If its an empty string use the initial kps | |
| parsed_user_kps = copy.copy(initial_user_kps) | |
| return parsed_user_kps | |
| # def plot_sent_kp_alignment(tplan, kp_labels, sent_labels): | |
| # """ | |
| # Plot the sentence keyphrase alignment. | |
| # :return: | |
| # """ | |
| # fig, ax = plt.subplots() | |
| # h = sns.heatmap(tplan.T, linewidths=.3, xticklabels=sent_labels, | |
| # yticklabels=kp_labels, cmap='Blues') | |
| # h.tick_params('y', labelsize=5) | |
| # h.tick_params('x', labelsize=2) | |
| # plt.tight_layout() | |
| # return fig | |
| def multiselect_title_formatter(title): | |
| """ | |
| Format the multi-select titles. | |
| :param title: string | |
| :return: string: formatted title | |
| """ | |
| ftitle = title.split()[:5] | |
| return ' '.join(ftitle) + '...' | |
| def format_abstract(paperd, to_display=3, markdown=True): | |
| """ | |
| Given a dict with title and abstract return | |
| a formatted text for rendering with markdown. | |
| :param paperd: | |
| :param to_display: | |
| :return: | |
| """ | |
| if len(paperd['abstract']) < to_display: | |
| sents = ' '.join(paperd['abstract']) | |
| else: | |
| sents = ' '.join(paperd['abstract'][:to_display]) + '...' | |
| try: | |
| kp_expl = ', '.join(paperd['kp_explanations']) | |
| except KeyError: | |
| kp_expl = '' | |
| title = re.sub('\{', '', paper['title']) | |
| title = re.sub('\}', '', title) | |
| sents = re.sub('\{', '', sents) | |
| sents = re.sub('\}', '', sents) | |
| if markdown: | |
| try: | |
| url = paperd['url'] | |
| par = '<p><b>Title</b>: <i><a href="{:s}">{:s}</a></i><br><b>Abstract</b>: {:s}<br><i>{:s}</i></p>'. \ | |
| format(url, title, sents, kp_expl) | |
| except KeyError: | |
| par = '<p><b>Title</b>: <i>{:s}</i><br><b>Abstract</b>: {:s}<br><i>{:s}</i></p>'. \ | |
| format(paper['title'], sents, kp_expl) | |
| else: | |
| par = 'Title: {:s}; Abstract: {:s}'.format(paper['title'], sents) | |
| return par | |
| def perp_result_json(): | |
| """ | |
| Create a json with the results retrieved for each | |
| iteration and the papers users choose to save at | |
| each step. | |
| :return: | |
| """ | |
| result_json = {} | |
| # print(len(st.session_state.i_selections)) | |
| # print(len(st.session_state.i_resultps)) | |
| # print(len(st.session_state.i_savedps)) | |
| # print(st.session_state.tuning_i) | |
| assert(len(st.session_state.i_selections) == len(st.session_state.i_resultps) | |
| == len(st.session_state.i_savedps) == st.session_state.tuning_i) | |
| for tuning_i, i_pselects, (_, i_savedps) in zip(range(st.session_state.tuning_i), st.session_state.i_selections, | |
| st.session_state.i_savedps.items()): | |
| iterdict = { | |
| 'iteration': tuning_i, | |
| 'profile_selections': copy.deepcopy(i_pselects), | |
| 'saved_papers': copy.deepcopy(list(i_savedps.items())) | |
| } | |
| result_json[tuning_i] = iterdict | |
| result_json['condition'] = 'maple' | |
| result_json['username'] = st.session_state.username | |
| return json.dumps(result_json) | |
| ######################################## | |
| # APP CODE # | |
| ######################################## | |
| st.title('\U0001F341 Maple Paper Recommender \U0001F341') | |
| st.markdown( | |
| '\U0001F341 Maple \U0001F341 uses a seed set of authored papers to make paper recommendations from ML and NLP conferences: NeurIPS, ICLR, ICML, UAI, AISTATS, ACL*, and EMNLP from years 2018 to 2023.' | |
| '\n1. :white_check_mark: Select your username on the left\n2. :eyes: Verify keyphrases inferred for the papers and click ' | |
| '"\U0001F9D1 Generate profile \U0001F9D1"\n3. :mag: Request recommendations\n4. :repeat: Tune recommendations') | |
| # Load candidate documents and models. | |
| pid2abstract_cands, pid2sent_vectors_cands = read_candidates(in_path) | |
| kp_encoding_model = read_kp_encoder(in_path) | |
| # Initialize the session state: | |
| if 'tuning_i' not in st.session_state: | |
| st.session_state['tuning_i'] = 0 | |
| # Save the profile keyphrases at every run | |
| # (run is every time the script runs, iteration is every time recs are requested) | |
| st.session_state['run_user_kps'] = [] | |
| # Save the profile selections at each iteration | |
| st.session_state['i_selections'] = [] | |
| # dict of dicts: tuning_i: dict(paper_title: paper) | |
| st.session_state['i_resultps'] = {} | |
| # dict of dicts: tuning_i: dict(paper_title: saved or not bool) | |
| st.session_state['i_savedps'] = collections.defaultdict(dict) | |
| # Ask user to upload a set of seed query papers. | |
| with st.sidebar: | |
| available_users = os.listdir(os.path.join(in_path, 'users')) | |
| available_users.sort() | |
| available_users = (None,) + tuple(available_users) | |
| # uploaded_file = st.file_uploader("\U0001F331 Upload seed papers", | |
| # type='json', | |
| # help='Upload a json file with titles and abstracts of the papers to ' | |
| # 'include in your profile.') | |
| # st.markdown(f"<b style='color:red;'>Select your username from the drop-down:</b>", unsafe_allow_html=True) | |
| selected_user = st.selectbox('Select your username from the drop-down', | |
| available_users) | |
| if selected_user is not None: | |
| user_papers = json.load( | |
| open(os.path.join(in_path, 'users', selected_user, f'seedset-{selected_user}-maple.json'))) | |
| # user_papers = json.load(uploaded_file) | |
| # Read user data. | |
| doc_vectors_user, pid2idx_user, pid2sent_vectors_user, user_kps = read_user(user_papers) | |
| st.session_state.run_user_kps.append(copy.copy(user_kps)) | |
| display_profile_kps = ', '.join(user_kps) | |
| # Perform first stage retrieval. | |
| first_stage_ret_pids = first_stage_ranked_docs(user_doc_queries=doc_vectors_user, per_doc_to_rank=500) | |
| with st.expander("Examine seed papers"): | |
| st.markdown(f'**Initial profile keyphrases**:') | |
| st.markdown(display_profile_kps) | |
| st.markdown('**Seed papers**: {:d}'.format(len(user_papers['papers']))) | |
| for paper in user_papers['papers']: | |
| par = format_abstract(paperd=paper, to_display=6) | |
| st.markdown(par, unsafe_allow_html=True) | |
| st.markdown('\u2b50 Saved papers') | |
| if selected_user is not None: | |
| # Create a text box where users can see their profile keyphrases. | |
| st.subheader('\U0001F4DD Seed paper keyphrases') | |
| with st.form('profile_kps'): | |
| input_kps = st.text_area( | |
| 'Add/remove keyphrases to fix redundancy, inaccuracy, incompleteness, or being nonsensical:', | |
| display_profile_kps, | |
| help='Edit the profile keyphrases if they are redundant, incomplete, nonsensical, ' | |
| 'or dont accurately describe the seed papers. You can also add keyphrases to ' | |
| 'capture aspects of the seed papers that the keyphrases dont currently capture.', | |
| placeholder='If left empty initial profile keyphrases will be used...') | |
| input_user_kps = parse_input_kps(unparsed_kps=input_kps, initial_user_kps=user_kps) | |
| col1, col2, col3 = st.columns([1, 1, 1]) | |
| with col2: | |
| generate_profile = st.form_submit_button('\U0001F9D1 Generate profile \U0001F9D1') | |
| if generate_profile: | |
| prev_run_input_kps = st.session_state.run_user_kps[-1] | |
| if set(prev_run_input_kps) == set(input_user_kps): # If there is no change then use | |
| if 'kp2val_vectors' in st.session_state: # This happens all the time except the first run. | |
| kp2val_vectors = st.session_state.kp2val_vectors | |
| user_tplan = st.session_state.user_tplan | |
| else: # This happens on the first run. | |
| with st.spinner(text="Generating profile..."): | |
| kp2val_vectors, user_tplan = generate_profile_values(profile_keyphrases=input_user_kps) | |
| st.session_state['kp2val_vectors'] = kp2val_vectors | |
| st.session_state['user_tplan'] = user_tplan | |
| else: | |
| with st.spinner(text="Generating profile..."): | |
| kp2val_vectors, user_tplan = generate_profile_values(profile_keyphrases=input_user_kps) | |
| st.session_state['kp2val_vectors'] = kp2val_vectors | |
| st.session_state['user_tplan'] = user_tplan | |
| st.session_state.run_user_kps.append(copy.copy(input_user_kps)) | |
| # Create a multiselect dropdown | |
| if 'kp2val_vectors' in st.session_state: | |
| # with st.expander("Examine paper-keyphrase alignment"): | |
| # user_tplan = st.session_state.user_tplan | |
| # fig = plot_sent_kp_alignment(tplan=user_tplan, kp_labels=input_user_kps, | |
| # sent_labels=range(user_tplan.shape[0])) | |
| # st.write(fig) | |
| st.subheader('\U0001F9D1 Profile keyphrases for ranking') | |
| with st.form('profile_input'): | |
| st.markdown(""" | |
| <style> | |
| .stMultiSelect [data-baseweb=select] span{ | |
| max-width: 500px; | |
| } | |
| </style> | |
| """, unsafe_allow_html=True) | |
| profile_selections = st.multiselect(label='Include or exclude profile keyphrases to use for recommendations:', | |
| default=input_user_kps, # Use all the values by default. | |
| options=input_user_kps, | |
| help='Items selected here will be used for creating your ' | |
| 'recommended list') | |
| col1, col2, col3 = st.columns([1, 1, 1]) | |
| with col2: | |
| generate_recs = st.form_submit_button('\U0001F9ED Recommend papers \U0001F9ED') | |
| # Use the uploaded files to create a ranked list of items. | |
| if generate_recs and profile_selections: | |
| # st.write('Generating recs...') | |
| st.session_state.tuning_i += 1 | |
| st.session_state.i_selections.append(copy.deepcopy(profile_selections)) | |
| with st.spinner(text="Recommending papers..."): | |
| top_papers = second_stage_ranked_docs(first_stage_pids=first_stage_ret_pids, | |
| selected_query_kps=profile_selections, | |
| pid2abstract=pid2abstract_cands, | |
| pid2sent_reps_cand=pid2sent_vectors_cands, | |
| to_rank=30) | |
| st.session_state.i_resultps[st.session_state.tuning_i] = copy.deepcopy(top_papers) | |
| # Read off from the result cache and allow users to save some papers. | |
| if st.session_state.tuning_i in st.session_state.i_resultps: | |
| # st.write('Waiting for selections...') | |
| cached_top_papers = st.session_state.i_resultps[st.session_state.tuning_i] | |
| for paper in cached_top_papers.values(): | |
| # This statement ensures correctness for when users unselect a previously selected item. | |
| st.session_state.i_savedps[st.session_state.tuning_i][paper['title']] = False | |
| dcol1, dcol2 = st.columns([1, 16]) | |
| with dcol1: | |
| save_paper = st.checkbox('\u2b50', key=paper['title']) | |
| with dcol2: | |
| plabel = format_abstract(paperd=paper, to_display=2, markdown=True) | |
| st.markdown(plabel, unsafe_allow_html=True) | |
| with st.expander('See more..'): | |
| full_abstract = ' '.join(paper['abstract']) | |
| st.markdown(full_abstract, unsafe_allow_html=True) | |
| if save_paper: | |
| st.session_state.i_savedps[st.session_state.tuning_i].update({paper['title']: True}) | |
| # Print the saved papers across iterations in the sidebar. | |
| with st.sidebar: | |
| with st.expander("Examine saved papers"): | |
| # st.write('Later write..') | |
| # st.write(st.session_state.i_savedps) | |
| for iteration, savedps in st.session_state.i_savedps.items(): | |
| st.markdown('Iteration: {:}'.format(iteration)) | |
| for papert, saved in savedps.items(): | |
| if saved: | |
| fpapert = '<p style=color:Gray; ">- {:}</p>'.format(papert) | |
| st.markdown('{:}'.format(fpapert), unsafe_allow_html=True) | |
| if st.session_state.tuning_i > 0: | |
| st.download_button('Download papers', perp_result_json(), mime='json', | |
| help='Download the papers saved in the session.') | |
| with st.expander("Copy saved papers to clipboard"): | |
| st.write(json.loads(perp_result_json())) | |