added most files for entanglement project

.gitignore

@@ -32,6 +32,7 @@ git-large-file
 deta_drive.py
 secret_keys.py
 
+data/old
 # Large files
 # data/preprocessed_image_net/
 # data/activation/*.pkl

Home.py

@@ -7,37 +7,25 @@ st.set_page_config(layout='wide')
 st.title('About')
 
 # INTRO
-intro_text = """Convolutional neural networks (ConvNets) have evolved at a rapid speed from the 2010s. 
-Some of the representative ConvNets models are VGGNet, Inceptions, ResNe(X)t, DenseNet, MobileNet, EfficientNet and RegNet, which focus on various factors of accuracy, efficiency, and scalability. 
-In the year 2020, Vision Transformers (ViT) was introduced as a Transformer model solving the computer vision problems. 
-Larger model and dataset sizes allow ViT to perform significantly better than ResNet, however, ViT still encountered challenges in generic computer vision tasks such as object detection and semantic segmentation. 
-Swin Transformer’ s success made Transformers be adopted as a generic vision backbone and showed outstanding performance in a wide range of computer vision tasks. 
-Nevertheless, rather than the intrinsic inductive biases of convolutions, the success of this approach is still primarily attributed to Transformers’ inherent superiority. 
+intro_text = """This project investigates the nature and nurture of latent spaces, with the aim of formulating a theory of this particular vectorial space. It draws together reflections on the inherent constraints of latent spaces in particular architectures and considers the learning-specific features that emerge.
+The thesis concentrates mostly on the second part, exploring different avenues for understanding the space. Using a multitude of vision generative models, it discusses possibilities for the systematic exploration of space, including disentanglement properties and coverage of various guidance methods.
+It also explores the possibility of comparison across latent spaces and investigates the differences and commonalities across different learning experiments. Furthermore, the thesis investigates the role of stochasticity in newer models.
+As a case study, this thesis adopts art historical data, spanning classic art, photography, and modern and contemporary art.
 
-In 2022, Zhuang Liu et. al. proposed a pure convolutional model dubbed ConvNeXt, discovered from the modernization of a standard ResNet towards the design of Vision Transformers and claimed to outperform them. 
+The project aims to interpret the StyleGAN2 model by several techniques. 
+> “What concepts are disentangled in the latent space of StyleGAN2”\n
+> “Can we quantify the complexity of such concepts?”.
 
-The project aims to interpret the ConvNeXt model by several visualization techniques. 
-After that, a web interface would be built to demonstrate the interpretations, helping us look inside the deep ConvNeXt model and answer the questions:
-> “What patterns maximally activated this filter (channel) in this layer?”\n
-> “Which features are responsible for the current prediction?”.
-
-Due to the limitation in time and resources, the project only used the tiny-sized ConvNeXt model, which was trained on ImageNet-1k at resolution 224x224 and used 50,000 images in validation set of ImageNet-1k for demo purpose.
-
-In this web app, two visualization techniques were implemented and demonstrated, they are **Maximally activating patches** and **SmoothGrad**. 
-Besides, this web app also helps investigate the effect of **adversarial attacks** on ConvNeXt interpretations. 
-Last but not least, there is a last webpage that stores 50,000 images in the **ImageNet-1k** validation set, facilitating the two web pages above in searching and referencing. 
 """
 st.write(intro_text)
 
 # 4 PAGES
-st.subheader('Features')
+st.subheader('Pages')
 sections_text = """Overall, there are 4 features in this web app:
-1) Maximally activating patches: The visualization method in this page answers the question “what patterns maximally activated this filter (channel)?”.
-2) SmoothGrad: This visualization method in this page answers the question “which features are responsible for the current prediction?”.
-3) Adversarial attack: How adversarial attacks affect ConvNeXt interpretation?
-4) ImageNet1k: The storage of 50,000 images in validation set.
+1) Disentanglement visualizer
+...
 """
 st.write(sections_text)
 
 
-add_footer('Developed with ❤ by ', 'Hanna Ta Quynh Nga', 'https://www.linkedin.com/in/ta-quynh-nga-hanna/')
+add_footer('Developed by ', 'Ludovica Schaerf', 'https://www.linkedin.com/in/ludovica-schaerf-59063422b/')

Visual-Explanation-Methods-PyTorch

@@ -1 +0,0 @@
-Subproject commit 5cb88902729af1d9d85259879b47cb238b841881

backend/disentangle_concepts.py

@@ -0,0 +1,47 @@
+import numpy as np
+from sklearn.svm import SVC
+from sklearn.model_selection import train_test_split
+import torch
+import PIL
+
+def get_separation_space(type_bin, annotations):
+    abstracts = np.array([ann[type_bin] for ann in annotations['annotations']])
+    abstract_idxs = list(np.argsort(abstracts))[:200]
+    repr_idxs = list(np.argsort(abstracts))[-200:]
+    X = np.array([annotations['z_vectors'][i] for i in abstract_idxs+repr_idxs])
+    X = X.reshape((400, 512))
+    y = np.array([1]*200 + [0]*200)
+    x_train, x_val, y_train, y_val = train_test_split(X, y, test_size=0.2)
+    svc = SVC(gamma='auto', kernel='linear')
+    svc.fit(x_train, y_train)
+    print(svc.score(x_val, y_val))
+    imp_features = np.count(np.abs(svc.coef_) > 2)
+    return svc.coef_, imp_features
+
+def regenerate_images(model, z, decision_boundary, min_epsilon=-3, max_epsilon=3, count=11):
+    device = torch.device('cpu')
+    G = model.to(device) # type: ignore
+
+    # Labels.
+    label = torch.zeros([1, G.c_dim], device=device)
+    
+    z = torch.from_numpy(z.copy()).to(device)
+    decision_boundary = torch.from_numpy(decision_boundary.copy()).to(device)
+        
+    lambdas = np.linspace(-3, 3, 11)
+    images = []
+    # Generate images.
+    for _, lambda_ in enumerate(lambdas):
+        z_0 = z + lambda_ * decision_boundary
+        # Construct an inverse rotation/translation matrix and pass to the generator.  The
+        # generator expects this matrix as an inverse to avoid potentially failing numerical
+        # operations in the network.
+        #if hasattr(G.synthesis, 'input'):
+            #m = make_transform(translate, rotate)
+            #m = np.linalg.inv(m)
+            #G.synthesis.input.transform.copy_(torch.from_numpy(m))
+
+        img = G(z_0, label, truncation_psi=0.7, noise_mode='random')
+        img = (img.permute(0, 2, 3, 1) * 127.5 + 128).clamp(0, 255).to(torch.uint8)
+        images.append(PIL.Image.fromarray(img[0].cpu().numpy(), 'RGB'))
+    return images

data/annotated_files/annotations_seeds0000-1000.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ffcd38622c48bf91e0e193b846a181e6baee559633e6057df7765fe0ecd422cf
+size 4461349

data/concepts.txt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d2383e924d76b10523b9f7b6800a5653c2cc78777bbd9a071de79bf14ab43078
+size 1407

data/model_files/pytorch_model.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:27d6840c1f9f11a0af97f6f1ff3809f7f3641d1e4ea7bc893ad15d9e4341caed
+size 120944973

pages/{3_Adversarial_attack.py → 1_Disentanglement.py}

@@ -1,4 +1,5 @@
 import streamlit as st
+import pickle
 import pandas as pd
 import numpy as np
 import random
@@ -10,7 +11,7 @@ import torch
 
 from matplotlib.backends.backend_agg import RendererAgg
 
-from backend.adversarial_attack import *
+from backend.disentangle_concepts import *
 
 _lock = RendererAgg.lock
 
@@ -19,18 +20,9 @@ BACKGROUND_COLOR = '#bcd0e7'
 SECONDARY_COLOR = '#bce7db'
 
 
-st.title('Adversarial Attack')
-st.write('> **How adversarial attacks affect ConvNeXt interpretation?**')
-st.write("""Adversarial examples are inputs crafted to confuse neural networks, causing them to misclassify a given input. 
-These examples are not distinguishable by humans but cause the network to fail to recognize the image content. 
-One type of such attack is the fast gradient sign method (FGSM) attack, which is a white box attack that aims to ensure misclassification. 
-A white box attack is where the attacker has full access to the model being attacked.
-
-The FGSM attack is one of the earliest and most popular adversarial attacks. 
-It is described by Goodfellow _et al_ in their work on [Explaining and Harnessing Adversarial Examples](https://arxiv.org/abs/1412.6572). 
-The attack is simple yet powerful, using the gradients that neural networks use to learn. 
-Instead of adjusting the weights based on the backpropagated gradients to minimize loss, the attack adjusts the input data to maximize the loss using the gradient of the loss with respect to the input data.
-""")
+st.title('Disentanglement studies')
+st.write('> **What concepts can be disentangled in the latent spae of a model?**')
+st.write("""Explain more in depth""")
 
 instruction_text = """Instruction to input:
 1. Choosing image: Users can choose a specific image by entering **Image ID** and hit the _Choose the defined image_ button or can generate an image randomly by hitting the _Generate a random image_ button.
@@ -46,12 +38,13 @@ with st.expander("See more instruction", expanded=False):
     st.write(instruction_text)
 
     
-
-imagenet_df = pd.read_csv('./data/ImageNet_metadata.csv')
-image_id = None
-
-if 'image_id' not in st.session_state:
-    st.session_state.image_id = 0
+annotations_file = './data/annotated_files/annotations_seeds0000-1000.pkl'
+with open(annotations_file, 'rb') as f:
+    annotations = pickle.load(f)
+    
+concepts = './data/concepts.txt'
+with open(concepts) as f:
+    labels = [line.strip() for line in f.readlines()]
 
 # def on_change_random_input():
 #     st.session_state.image_id = st.session_state.image_id
@@ -61,30 +54,30 @@ st.header('Input')
 input_col_1, input_col_2, input_col_3 = st.columns(3)
 # --------------------------- INPUT column 1 ---------------------------
 with input_col_1:
-    with st.form('image_form'):
+    with st.form('text_form'):
         
         # image_id = st.number_input('Image ID: ', format='%d', step=1)
-        st.write('**Choose or generate a random image**')
-        chosen_image_id_input = st.empty()
-        image_id = chosen_image_id_input.number_input('Image ID:', format='%d', step=1, value=st.session_state.image_id)
+        st.write('**Choose a concept to disentangle**')
+        chosen_text_id_input = st.empty()
+        concept_id = chosen_text_id_input.text_input('Concept:', format='', value=st.session_state.concept_id)
         
-        choose_image_button = st.form_submit_button('Choose the defined image')
-        random_id = st.form_submit_button('Generate a random image')
+        choose_image_button = st.form_submit_button('Choose the defined concept')
+        random_text = st.form_submit_button('Select a random concept')
 
-        if random_id:
-            image_id = random.randint(0, 50000)
-            st.session_state.image_id = image_id
-            chosen_image_id_input.number_input('Image ID:', format='%d', step=1, value=st.session_state.image_id)
+        if random_text:
+            concept_id = random.choice(labels)
+            st.session_state.concept_id = concept_id
+            chosen_text_id_input.text_input('Concept:', format='', value=st.session_state.concept_id)
             
         if choose_image_button:
-            image_id = int(image_id)
-            st.session_state.image_id = int(image_id)
+            concept_id = str(concept_id)
+            st.session_state.concept_id = concept_id
         # st.write(image_id, st.session_state.image_id)
 
 # ---------------------------- SET UP OUTPUT ------------------------------
 epsilon_container = st.empty()
 st.header('Output')
-st.subheader('Perform attack')
+st.subheader('Concept vector')
 
 # perform attack container
 header_col_1, header_col_2, header_col_3, header_col_4, header_col_5 = st.columns([1,1,1,1,1])
@@ -98,118 +91,123 @@ smoothgrad_header_container = st.empty()
 smooth_head_1, smooth_head_2, smooth_head_3, smooth_head_4, smooth_head_5 = st.columns([1,1,1,1,1])
 smoothgrad_col_1, smoothgrad_col_2, smoothgrad_col_3, smoothgrad_col_4, smoothgrad_col_5 = st.columns([1,1,1,1,1])
 
-original_image_dict = load_image(st.session_state.image_id)
-input_image = original_image_dict['image']
-input_label = original_image_dict['label']
-input_id = original_image_dict['id']
-
 # ---------------------------- DISPLAY COL 1 ROW 1 ------------------------------
 with output_col_1:
-    pred_prob, pred_class_id, pred_class_label = feed_forward(input_image)
+    separation_vector, number_important_features = get_separation_space(concept_id, annotations)
     # st.write(f'Class ID {input_id} - {input_label}: {pred_prob*100:.3f}% confidence')
-    st.image(input_image)
-    header_col_1.write(f'Class ID {input_id} - {input_label}: {pred_prob*100:.1f}% confidence')
+    st.write('Separation vector', separation_vector)
+    header_col_1.write(f'Concept {concept_id} - Number of relevant nodes: {number_important_features}')
 
-
-
-if pred_class_id != (input_id-1):
-    with error_container.container():
-        st.write(f'Predicted output: Class ID {pred_class_id} - {pred_class_label} {pred_prob*100:.1f}% confidence')
-        st.error('ConvNeXt misclassified the chosen image. Please choose or generate another image.',
-            icon = "🚫")
-
-# ----------------------------- INPUT column 2 & 3 ----------------------------
+# ----------------------------- INPUT column 2 & 3 ----------------------------        
 with input_col_2:
-    with st.form('epsilon_form'):
-        st.write('**Set epsilon or find the smallest epsilon automatically**')
-        chosen_epsilon_input = st.empty()
-        epsilon = chosen_epsilon_input.number_input('Epsilon:', min_value=0.001, format='%.3f', step=0.001)
-
-        epsilon_button = st.form_submit_button('Choose the defined epsilon')
-        find_epsilon = st.form_submit_button('Find the smallest epsilon automatically')
+   with st.form('image_form'):
+        
+        # image_id = st.number_input('Image ID: ', format='%d', step=1)
+        st.write('**Choose or generate a random image to test the disentanglement**')
+        chosen_image_id_input = st.empty()
+        image_id = chosen_image_id_input.number_input('Image ID:', format='%d', step=1, value=st.session_state.image_id)
+        
+        choose_image_button = st.form_submit_button('Choose the defined image')
+        random_id = st.form_submit_button('Generate a random image')
 
+        if random_id:
+            image_id = random.randint(0, 50000)
+            st.session_state.image_id = image_id
+            chosen_image_id_input.number_input('Image ID:', format='%d', step=1, value=st.session_state.image_id)
+            
+        if choose_image_button:
+            image_id = int(image_id)
+            st.session_state.image_id = int(image_id)
+        # st.write(image_id, st.session_state.image_id)
 
 with input_col_3:
-    with st.form('iterate_epsilon_form'):
-        max_epsilon = st.number_input('Maximum value of epsilon (Optional setting)', value=0.500, format='%.3f')
-        step_epsilon = st.number_input('Step (Optional setting)', value=0.001, format='%.3f')
-        setting_button = st.form_submit_button('Set iterating mode')
-
+    with st.form('Variate along the disentangled concept'):
+        st.write('**Set range of change**')
+        chosen_epsilon_input = st.empty()
+        epsilon = chosen_epsilon_input.number_input('Epsilon:', min_value=1, format='%.1f')
+        epsilon_button = st.form_submit_button('Choose the defined epsilon')
 
 # ---------------------------- DISPLAY COL 2 ROW 1 ------------------------------
-if pred_class_id == (input_id-1) and (epsilon_button or find_epsilon or setting_button):
-    with output_col_3:
-        if epsilon_button:
-            perturbed_data, new_prob, new_id, new_label = perform_attack(input_image, input_id-1, epsilon)
-        else:
-            epsilons = [i*step_epsilon for i in range(1, 1001) if i*step_epsilon <= max_epsilon]
-            with epsilon_container.container():
-                epsilon_container_text = 'Checking epsilon'
-                st.write(epsilon_container_text)
-                st.progress(0)
+# original_image_dict = load_image(st.session_state.image_id)
+# input_image = original_image_dict['image']
+# input_label = original_image_dict['label']
+# input_id = original_image_dict['id']
+
+
+
+# if pred_class_id == (input_id-1) and (epsilon_button or find_epsilon or setting_button):
+#     with output_col_3:
+#         if epsilon_button:
+#             perturbed_data, new_prob, new_id, new_label = perform_attack(input_image, input_id-1, epsilon)
+#         else:
+#             epsilons = [i*step_epsilon for i in range(1, 1001) if i*step_epsilon <= max_epsilon]
+#             with epsilon_container.container():
+#                 epsilon_container_text = 'Checking epsilon'
+#                 st.write(epsilon_container_text)
+#                 st.progress(0)
         
-            for i, e in enumerate(epsilons):
+#             for i, e in enumerate(epsilons):
                 
-                perturbed_data, new_prob, new_id, new_label = perform_attack(input_image, input_id-1, e)
-                with epsilon_container.container():
-                    epsilon_container_text = f'Checking epsilon={e:.3f}. Confidence={new_prob*100:.1f}%'
-                    st.write(epsilon_container_text)
-                    st.progress(i/len(epsilons))
+#                 perturbed_data, new_prob, new_id, new_label = perform_attack(input_image, input_id-1, e)
+#                 with epsilon_container.container():
+#                     epsilon_container_text = f'Checking epsilon={e:.3f}. Confidence={new_prob*100:.1f}%'
+#                     st.write(epsilon_container_text)
+#                     st.progress(i/len(epsilons))
                 
-                epsilon = e
-
-                if new_id != input_id - 1:
-                    epsilon_container.empty()
-                    st.balloons()
-                    break
-                if i == len(epsilons)-1:
-                    epsilon_container.error(f'FGSM failed to attack on this image at epsilon={e:.3f}. Set higher maximum value of epsilon or choose another image',
-                                            icon = "🚫")
-
-        perturbed_image = deprocess_image(perturbed_data.detach().numpy())[0].astype(np.uint8).transpose(1,2,0)
-        perturbed_amount = perturbed_image - input_image
-        header_col_3.write(f'Pertubed amount - epsilon={epsilon:.3f}')
-        st.image(ShowImage(perturbed_amount))
+#                 epsilon = e
+
+#                 if new_id != input_id - 1:
+#                     epsilon_container.empty()
+#                     st.balloons()
+#                     break
+#                 if i == len(epsilons)-1:
+#                     epsilon_container.error(f'FGSM failed to attack on this image at epsilon={e:.3f}. Set higher maximum value of epsilon or choose another image',
+#                                             icon = "🚫")
+
+#         perturbed_image = deprocess_image(perturbed_data.detach().numpy())[0].astype(np.uint8).transpose(1,2,0)
+#         perturbed_amount = perturbed_image - input_image
+#         header_col_3.write(f'Pertubed amount - epsilon={epsilon:.3f}')
+#         st.image(ShowImage(perturbed_amount))
     
-    with output_col_2:
-        # st.write('plus sign')
-        st.image(LoadImage('frontend/images/plus-sign.png'))
+#     with output_col_2:
+#         # st.write('plus sign')
+#         st.image(LoadImage('frontend/images/plus-sign.png'))
     
-    with output_col_4:
-        # st.write('equal sign')
-        st.image(LoadImage('frontend/images/equal-sign.png'))
-
-    # ---------------------------- DISPLAY COL 5 ROW 1 ------------------------------
-    with output_col_5:
-        # st.write(f'ID {new_id+1} - {new_label}: {new_prob*100:.3f}% confidence')
-        st.image(ShowImage(perturbed_image))
-    header_col_5.write(f'Class ID {new_id+1} - {new_label}: {new_prob*100:.1f}% confidence')
-
-    # -------------------------- DISPLAY SMOOTHGRAD ---------------------------
-    smoothgrad_header_container.subheader('SmoothGrad visualization')
-
-    with smoothgrad_col_1:
-        smooth_head_1.write(f'SmoothGrad before attacked')
-        heatmap_image, masked_image, mask = generate_images(st.session_state.image_id, epsilon=0)
-        st.image(heatmap_image)
-        st.image(masked_image) 
-    with smoothgrad_col_3:
-        smooth_head_3.write('SmoothGrad after attacked')
-        heatmap_image_attacked, masked_image_attacked, attacked_mask= generate_images(st.session_state.image_id, epsilon=epsilon)
-        st.image(heatmap_image_attacked)
-        st.image(masked_image_attacked)
+#     with output_col_4:
+#         # st.write('equal sign')
+#         st.image(LoadImage('frontend/images/equal-sign.png'))
+
+#     # ---------------------------- DISPLAY COL 5 ROW 1 ------------------------------
+#     with output_col_5:
+#         # st.write(f'ID {new_id+1} - {new_label}: {new_prob*100:.3f}% confidence')
+#         st.image(ShowImage(perturbed_image))
+#     header_col_5.write(f'Class ID {new_id+1} - {new_label}: {new_prob*100:.1f}% confidence')
+
+#     # -------------------------- DISPLAY SMOOTHGRAD ---------------------------
+#     smoothgrad_header_container.subheader('SmoothGrad visualization')
+
+#     with smoothgrad_col_1:
+#         smooth_head_1.write(f'SmoothGrad before attacked')
+#         heatmap_image, masked_image, mask = generate_images(st.session_state.image_id, epsilon=0)
+#         st.image(heatmap_image)
+#         st.image(masked_image) 
+#     with smoothgrad_col_3:
+#         smooth_head_3.write('SmoothGrad after attacked')
+#         heatmap_image_attacked, masked_image_attacked, attacked_mask= generate_images(st.session_state.image_id, epsilon=epsilon)
+#         st.image(heatmap_image_attacked)
+#         st.image(masked_image_attacked)
     
-    with smoothgrad_col_2:
-        st.image(LoadImage('frontend/images/minus-sign-5.png'))
-
-    with smoothgrad_col_5:
-        smooth_head_5.write('SmoothGrad difference')
-        difference_mask = abs(attacked_mask-mask)
-        st.image(ShowHeatMap(difference_mask))
-        masked_image = ShowMaskedImage(difference_mask, perturbed_image)
-        st.image(masked_image)
-
-    with smoothgrad_col_4:
-        st.image(LoadImage('frontend/images/equal-sign.png'))
+#     with smoothgrad_col_2:
+#         st.image(LoadImage('frontend/images/minus-sign-5.png'))
+
+#     with smoothgrad_col_5:
+#         smooth_head_5.write('SmoothGrad difference')
+#         difference_mask = abs(attacked_mask-mask)
+#         st.image(ShowHeatMap(difference_mask))
+#         masked_image = ShowMaskedImage(difference_mask, perturbed_image)
+#         st.image(masked_image)
+
+#     with smoothgrad_col_4:
+#         st.image(LoadImage('frontend/images/equal-sign.png'))