important bug fix for image selection

Archive/optimization.py

@@ -0,0 +1,37 @@
+import numpy as np
+from scipy.optimize import minimize, differential_evolution
+
+
+# Define the function y = x_1*w_1 + x_2*w_2 + x_3*w_3
+def objective_function(w_indices):
+    x_1 = x_1_values[int(w_indices[0])]
+    x_2 = x_2_values[int(w_indices[1])]
+    x_3 = x_3_values[int(w_indices[2])]
+    return - (x_1 * w_indices[3] + x_2 * w_indices[4] + x_3 * w_indices[5])  # Use w_indices to get w_1, w_2, w_3
+
+
+if __name__ == '__main__':
+    # Given sets of discrete values for x_1, x_2, and x_3
+    x_1_values = [1, 2, 3, 5, 6]
+    x_2_values = [0, 5, 7, 2, 1]
+    x_3_values = [3, 7, 4, 5, 2]
+
+    # Perform differential evolution optimization with integer variables
+    # bounds = [(0, len(x_1_values) - 2), (0, len(x_2_values) - 1), (0, len(x_3_values) - 1), (-1, 1), (-1, 1), (-1, 1)]
+    bounds = [(3, 4), (3, 4), (3, 4), (-1, 1), (-1, 1), (-1, 1)]
+    result = differential_evolution(objective_function, bounds)
+
+    # Get the optimal indices of x_1, x_2, and x_3
+    x_1_index, x_2_index, x_3_index, w_1_opt, w_2_opt, w_3_opt = result.x
+
+    # Calculate the peak point (x_1, x_2, x_3) corresponding to the optimal indices
+    x_1_peak = x_1_values[int(x_1_index)]
+    x_2_peak = x_2_values[int(x_2_index)]
+    x_3_peak = x_3_values[int(x_3_index)]
+
+    # Print the results
+    print("Optimal w_1:", w_1_opt)
+    print("Optimal w_2:", w_2_opt)
+    print("Optimal w_3:", w_3_opt)
+    print("Peak Point (x_1, x_2, x_3):", (x_1_peak, x_2_peak, x_3_peak))
+    print("Maximum Value of y:", -result.fun)  # Use negative sign as we previously used to maximize

Archive/optimization2.py

@@ -0,0 +1,40 @@
+import numpy as np
+from scipy.optimize import minimize
+
+if __name__ == '__main__':
+
+    # Given subset of m values for x_1, x_2, and x_3
+    x1_subset = [2, 3, 4]
+    x2_subset = [0, 1]
+    x3_subset = [5, 6, 7]
+
+    # Full set of possible values for x_1, x_2, and x_3
+    x1_full = [1, 2, 3, 4, 5]
+    x2_full = [0, 1, 2, 3, 4, 5]
+    x3_full = [3, 5, 7]
+
+    # Define the objective function for quantile-based ranking
+    def objective_function(w):
+        y_subset = [x1 * w[0] + x2 * w[1] + x3 * w[2] for x1, x2, x3 in zip(x1_subset, x2_subset, x3_subset)]
+        y_full_set = [x1 * w[0] + x2 * w[1] + x3 * w[2] for x1 in x1_full for x2 in x2_full for x3 in x3_full]
+
+        # Calculate the 90th percentile of y values for the full set
+        y_full_set_90th_percentile = np.percentile(y_full_set, 90)
+
+        # Maximize the difference between the 90th percentile of the subset and the 90th percentile of the full set
+        return - min(y_subset) + y_full_set_90th_percentile
+
+
+    # Bounds for w_1, w_2, and w_3 (-1 to 1)
+    bounds = [(-1, 1), (-1, 1), (-1, 1)]
+
+    # Perform bounded optimization to find the values of w_1, w_2, and w_3 that maximize the objective function
+    result = minimize(objective_function, np.zeros(3), method='TNC', bounds=bounds)
+
+    # Get the optimal values of w_1, w_2, and w_3
+    w_1_opt, w_2_opt, w_3_opt = result.x
+
+    # Print the results
+    print("Optimal w_1:", w_1_opt)
+    print("Optimal w_2:", w_2_opt)
+    print("Optimal w_3:", w_3_opt)

Archive/test_form.py

@@ -0,0 +1,39 @@
+import streamlit as st
+
+
+def grid(col=3, row=4, name='grid1'):
+    cols = st.columns(col)
+    for i in range(row):
+        for j in range(col):
+            with cols[j]:
+                value = st.session_state.checked_dic[name].get(f"{name}_{i*col+j}", False)
+
+                check = st.checkbox(f"{i*col+j}", key=f"{name}_{i*col+j}", value=value)
+                if check:
+                    st.session_state.checked_dic[name][f"{name}_{i*col+j}"] = True
+                else:
+                    st.session_state.checked_dic[name][f"{name}_{i*col+j}"] = False
+
+
+def on_click():
+    for key in st.session_state:
+        if st.session_state[key] and key[-1].isdigit():
+            st.write(key)
+    # for key in st.session_state.checked_dic[name]:
+    #     if st.session_state.checked_dic[name][key]:
+    #         st.write(key)
+
+
+
+if __name__ == "__main__":
+    if 'checked_dic' not in st.session_state:
+        st.session_state.checked_dic = {'grid1': {}, 'grid2': {}}
+
+    name = st.selectbox('Select a grid', ['grid1', 'grid2'])
+
+    with st.form(f"{name}_form"):
+        grid(name=name)
+        submit_button = st.form_submit_button("Submit", on_click=on_click)
+
+
+

Home.py

@@ -38,6 +38,8 @@ def logout():
 
 
 if __name__ == '__main__':
+    # print(st.source_util.get_pages('Home.py'))
+
     st.set_page_config(page_title="Login", page_icon="🏠", layout="wide")
     st.write('A Research by MAPS Lab, NYU Shanghai')
     st.title("Personalized Model Coffer")

pages/Gallery.py

@@ -1,14 +1,16 @@
-import streamlit as st
+import os
+import requests
+
+import altair as alt
 import numpy as np
 import pandas as pd
-import glob
+import streamlit as st
+
+from bs4 import BeautifulSoup
 from datasets import load_dataset, Dataset, load_from_disk
 from huggingface_hub import login
-import os
-import requests
-from bs4 import BeautifulSoup
-import altair as alt
 from streamlit_extras.switch_page_button import switch_page
+from sklearn.svm import LinearSVC
 
 SCORE_NAME_MAPPING = {'clip': 'clip_score', 'rank': 'msq_score', 'pop': 'model_download_count'}
 
@@ -62,20 +64,25 @@ class GalleryApp:
                             # handel checkbox information
                             prompt_id = items.iloc[idx + j]['prompt_id']
                             modelVersion_id = items.iloc[idx + j]['modelVersion_id']
+
                             check_init = True if modelVersion_id in st.session_state.selected_dict.get(prompt_id, []) else False
 
+                            st.write("Position: ", idx + j)
+
                             # show checkbox
-                            checked = st.checkbox('Select', key=f'select_{idx + j}', value=check_init)
-                            if checked:
-                                if prompt_id not in st.session_state.selected_dict:
-                                    st.session_state.selected_dict[prompt_id] = []
-                                if modelVersion_id not in st.session_state.selected_dict[prompt_id]:
-                                    st.session_state.selected_dict[prompt_id].append(modelVersion_id)
-                            else:
-                                try:
-                                    st.session_state.selected_dict[prompt_id].remove(modelVersion_id)
-                                except:
-                                    pass
+                            checked = st.checkbox('Select', key=f'select_{prompt_id}_{modelVersion_id}', value=check_init)
+
+                            #
+                            # if checked:
+                            #     if prompt_id not in st.session_state.selected_dict:
+                            #         st.session_state.selected_dict[prompt_id] = []
+                            #     if modelVersion_id not in st.session_state.selected_dict[prompt_id]:
+                            #         st.session_state.selected_dict[prompt_id].append(modelVersion_id)
+                            # else:
+                            #     try:
+                            #         st.session_state.selected_dict[prompt_id].remove(modelVersion_id)
+                            #     except:
+                            #         pass
 
                             # show selected info
                             for key in info:
@@ -186,7 +193,7 @@ class GalleryApp:
         # select number of columns
         col_num = st.slider('Number of columns', min_value=1, max_value=9, value=4, step=1, key='col_num')
 
-        return items, info, col_num
+        return items, info, col_num, preprocessor
 
     def sidebar(self):
         with st.sidebar:
@@ -244,7 +251,7 @@ class GalleryApp:
         st.title('Model Visualization and Retrieval')
         st.write('This is a gallery of images generated by the models')
 
-        prompt_tags, tag, prompt_id, items = self.sidebar()
+        prompt_tags, tag, prompt_id, items= self.sidebar()
 
         # add safety check for some prompts
         safety_check = True
@@ -263,8 +270,23 @@ class GalleryApp:
             safety_check = st.checkbox('I understand that this prompt may contain unsafe content. Show these images anyway.', key=f'{prompt_id}')
 
         if safety_check:
-            items, info, col_num = self.selection_panel(items)
-            # self.gallery_standard(items, col_num, info)
+            items, info, col_num, preprocessor = self.selection_panel(items)
+
+            # method = st.radio('Select a method to set dynamic weight', ['Grid Search', 'SVM', 'Greedy', 'Disable dynamic weight'], index=0, horizontal=True)
+            #
+            # if method != 'Disable dynamic weight':
+            #     if len(st.session_state.selected_dict[prompt_id]) > 0:
+            #         selected = items[
+            #             items['modelVersion_id'].isin(st.session_state.selected_dict[prompt_id])].reset_index(
+            #             drop=True)
+            #         st.session_state.score_weights[0: 3] = self.dynamic_weight(selected, items, preprocessor,
+            #                                                                    method=method)
+            #         # st.experimental_rerun()
+            #
+            #     else:
+            #         print('no selected models')
+            #
+            # st.write(st.session_state.selected_dict.get(prompt_id, []))
 
             with st.form(key=f'{prompt_id}'):
                 # buttons = st.columns([1, 1, 1])
@@ -293,20 +315,97 @@ class GalleryApp:
                     with st.spinner('Loading images...'):
                         self.gallery_standard(items, col_num, info)
 
+                with st.sidebar:
+                    st.write(str(st.session_state.selected_dict[prompt_id]))
+
     def submit_actions(self, status, prompt_id):
         if status == 'Select':
             modelVersions = self.promptBook[self.promptBook['prompt_id'] == prompt_id]['modelVersion_id'].unique()
             st.session_state.selected_dict[prompt_id] = modelVersions.tolist()
             print(st.session_state.selected_dict, 'select')
+            st.experimental_rerun()
         elif status == 'Deselect':
             st.session_state.selected_dict[prompt_id] = []
             print(st.session_state.selected_dict, 'deselect')
+            st.experimental_rerun()
             # self.promptBook.loc[self.promptBook['prompt_id'] == prompt_id, 'checked'] = False
             pass
         elif status == 'Continue':
+            st.session_state.selected_dict[prompt_id] = []
+            for key in st.session_state:
+                keys = key.split('_')
+                if keys[0] == 'select' and keys[1] == str(prompt_id):
+                    if st.session_state[key]:
+                        st.session_state.selected_dict[prompt_id].append(int(keys[2]))
             # switch_page("ranking")
+            print(st.session_state.selected_dict, 'continue')
             pass
 
+    def dynamic_weight(self, selected, items, preprocessor='crop', method='Grid Search'):
+        optimal_weight = [0, 0, 0]
+        if method == 'Grid Search':
+            # grid search method
+            top_ranking = len(items) * len(selected)
+
+            for clip_weight in np.arange(-1, 1, 0.1):
+                for mcos_weight in np.arange(-1, 1, 0.1):
+                    for pop_weight in np.arange(-1, 1, 0.1):
+                        weight_all = clip_weight*items[f'norm_clip_{preprocessor}'] + mcos_weight*items[f'norm_mcos_{preprocessor}'] + pop_weight*items['norm_pop']
+                        weight_all_sorted = weight_all.sort_values(ascending=False)
+
+                        weight_selected = clip_weight*selected[f'norm_clip_{preprocessor}'] + mcos_weight*selected[f'norm_mcos_{preprocessor}'] + pop_weight*selected['norm_pop']
+
+                        # get the index of values of weight_selected in weight_all_sorted
+                        rankings = []
+                        for weight in weight_selected:
+                            rankings.append(weight_all_sorted.index[weight_all_sorted == weight].tolist()[0])
+                        if sum(rankings) <= top_ranking:
+                            top_ranking = sum(rankings)
+                            optimal_weight = [clip_weight, mcos_weight, pop_weight]
+            print('optimal weight:', optimal_weight)
+
+        elif method == 'SVM':
+            # svm method
+            print('start svm method')
+            # get residual dataframe that contains models not selected
+            residual = items[~items['modelVersion_id'].isin(selected['modelVersion_id'])].reset_index(drop=True)
+            residual = residual[['norm_clip_crop', 'norm_mcos_crop', 'norm_pop']]
+            residual = residual.to_numpy()
+            selected = selected[['norm_clip_crop', 'norm_mcos_crop', 'norm_pop']]
+            selected = selected.to_numpy()
+
+            y = np.concatenate((np.full((len(selected), 1), -1), np.full((len(residual), 1), 1)), axis=0).ravel()
+            X = np.concatenate((selected, residual), axis=0)
+
+            # fit svm model, and get parameters for the hyperplane
+            clf = LinearSVC(random_state=0, C=1.0, fit_intercept=False, dual='auto')
+            clf.fit(X, y)
+            optimal_weight = clf.coef_[0].tolist()
+            print('optimal weight:', optimal_weight)
+            pass
+
+        elif method == 'Greedy':
+            for idx in selected.index:
+                # find which score is the highest, clip, mcos, or pop
+                clip_score = selected.loc[idx, 'norm_clip_crop']
+                mcos_score = selected.loc[idx, 'norm_mcos_crop']
+                pop_score = selected.loc[idx, 'norm_pop']
+                if clip_score >= mcos_score and clip_score >= pop_score:
+                    optimal_weight[0] += 1
+                elif mcos_score >= clip_score and mcos_score >= pop_score:
+                    optimal_weight[1] += 1
+                elif pop_score >= clip_score and pop_score >= mcos_score:
+                    optimal_weight[2] += 1
+
+            # normalize optimal_weight
+            optimal_weight = [round(weight/len(selected), 2) for weight in optimal_weight]
+            print('optimal weight:', optimal_weight)
+
+        return optimal_weight
+
+
+
+
 
 @st.cache_data
 def load_hf_dataset():
@@ -342,6 +441,7 @@ def load_hf_dataset():
 
 if __name__ == "__main__":
     st.set_page_config(page_title="Model Coffer Gallery", page_icon="🖼️", layout="wide")
+
     if 'user_id' not in st.session_state:
         st.warning('Please log in first.')
         home_btn = st.button('Go to Home Page')