update manual control to sliders

app.py

@@ -1,6 +1,6 @@
-import nltk
 import spacy
-nltk.download('wordnet')
+import nltk
+nltk.download('wordnet', quiet=True)
 spacy.cli.download('en_core_web_sm')
 
 import torch
@@ -18,13 +18,11 @@ from sklearn.impute import IterativeImputer
 from sklearn.linear_model import Ridge
 
 
-def process_examples(samples, full_names):
+def process_examples(samples):
     processed = []
     for sample in samples:
-        processed.append([
-            sample['sentence1'],
-            pd.DataFrame({'Index': full_names, 'Source': sample['sentence1_ling'], 'Target': sample['sentence2_ling']})
-                    ])
+        example = [sample['sentence1']] + [str(x) for x in sample['sentence1_ling']] + sample['sentence2_ling']
+        processed.append(example)
     return processed
 
 args, args_list, lng_names = parse_args(ckpt='./ckpt/model.pt')
@@ -34,7 +32,9 @@ device = 'cuda' if torch.cuda.is_available() else 'cpu'
 
 lng_names = [name_map[x] for x in lng_names]
 examples = json.load(open('assets/examples.json'))
-examples = process_examples(examples, lng_names)
+example_ids = [44, 148, 86, 96, 98, 62, 114, 138]
+examples = [examples[i] for i in example_ids]
+examples = process_examples(examples)
 
 stats = json.load(open('assets/stats.json'))
 
@@ -86,10 +86,10 @@ def visibility(mode):
             output.append(gr.update(visible=False))
     return output
 
-def generate(sent1, ling):
+def generate(sent1, ling_dict):
     input_ids = tokenizer.encode(sent1, return_tensors='pt').to(device)
-    ling1 = scaler.transform([ling['Source']])
-    ling2 = scaler.transform([ling['Target']])
+    ling1 = scaler.transform([ling_dict['Source']])
+    ling2 = scaler.transform([ling_dict['Target']])
     inputs = {'sentence1_input_ids': input_ids,
             'sentence1_ling': torch.tensor(ling1).float().to(device),
             'sentence2_ling': torch.tensor(ling2).float().to(device),
@@ -102,13 +102,37 @@ def generate(sent1, ling):
 
     return pred
 
-def generate_with_feedback(sent1, ling, approx):
-    if sent1 == '':
-        return ['Please input a source text.', '']
+def impute_targets():
+    target_values = []
+    for i in range(len(shared_state.target)):
+        if i in shared_state.active_indices:
+            target_values.append(shared_state.target[i])
+        else:
+            target_values.append(np.nan)
+    
+    target_values = np.array(target_values)
+    target_values_scaled = scaler.transform([target_values])[0]
+    estimator = Ridge(alpha=1e3, fit_intercept=False)
+    imputer = IterativeImputer(estimator=estimator, imputation_order='random', max_iter=100)
+
+    combined_matrix = np.vstack([ling_collection_scaled, target_values_scaled])
+    interpolated_matrix = imputer.fit_transform(combined_matrix)
+    interpolated_vector = interpolated_matrix[-1]
+    interp_raw = scaler.inverse_transform([interpolated_vector])[0]
+
+    shared_state.target = round_ling(interp_raw).tolist()
+    return shared_state.target
 
+def generate_with_feedback(sent1, approx):
+    if sent1 == '':
+        raise gr.Error('Please input a source text.')
 
+    # First impute any inactive targets
+    if len(shared_state.active_indices) < len(shared_state.target):
+        impute_targets()
+        
     input_ids = tokenizer.encode(sent1, return_tensors='pt').to(device)
-    ling2 = torch.tensor(scaler.transform([ling['Target']])).float().to(device)
+    ling2 = torch.tensor(scaler.transform([shared_state.target])).float().to(device)
     inputs = {
             'sentence1_input_ids': input_ids,
             'sentence2_ling': ling2,
@@ -118,20 +142,23 @@ def generate_with_feedback(sent1, ling, approx):
     pred, (pred_text, interpolations) = model.infer_with_feedback_BP(ling_disc, sem_emb, inputs, tokenizer)
 
     interpolation = '-- ' + '\n-- '.join(interpolations)
-    return [pred_text, interpolation]
+    # Return both the generation results and the updated slider values
+    return [pred_text, interpolation] + [gr.update(value=val) for val in shared_state.target]
 
-def generate_random(sent1, ling, count, approx):
+def generate_random(sent1, count, approx):
+    if sent1 == '':
+        raise gr.Error('Please input a source text.')
     preds, interpolations = [], []
     for c in range(count):
         idx = np.random.randint(0, len(ling_collection))
         ling_ex = ling_collection[idx]
-        ling['Target'] = ling_ex
-        pred, interpolation =  generate_with_feedback(sent1, ling, approx)
+        shared_state.target = ling_ex.copy()
+        pred, interpolation = generate_with_feedback(sent1, approx)
         preds.append(pred)
         interpolations.append(interpolation)
-    return '\n***\n'.join(preds), '\n***\n'.join(interpolations), ling
+    return '\n***\n'.join(preds), '\n***\n'.join(interpolations)
 
-def estimate_gen(sent1, sent2, ling, approx):
+def estimate_gen(sent1, sent2, approx):
     if 'approximate' in approx:
         input_ids = tokenizer.encode(sent2, return_tensors='pt').to(device)
         with torch.no_grad():
@@ -143,13 +170,12 @@ def estimate_gen(sent1, sent2, ling, approx):
         raise ValueError()
 
     ling_pred = round_ling(ling_pred)
-    ling['Target'] = ling_pred
-    gen = generate_with_feedback(sent1, ling, approx)
-    results = gen + [ling]
-
-    return results
+    shared_state.target = ling_pred.copy()
+    
+    gen = generate_with_feedback(sent1, approx)
+    return gen[0], gen[1], [gr.update(value=val) for val in shared_state.target]
 
-def estimate_tgt(sent2, ling, approx):
+def estimate_tgt(sent2, ling_dict, approx):
     if 'approximate' in approx:
         input_ids = tokenizer.encode(sent2, return_tensors='pt').to(device)
         with torch.no_grad():
@@ -161,10 +187,10 @@ def estimate_tgt(sent2, ling, approx):
         raise ValueError()
 
     ling_pred = round_ling(ling_pred)
-    ling['Target'] = ling_pred
-    return ling
+    ling_dict['Target'] = ling_pred
+    return ling_dict
 
-def estimate_src(sent1, ling, approx):
+def estimate_src(sent1, ling_dict, approx):
     if 'approximate' in approx:
         input_ids = tokenizer.encode(sent1, return_tensors='pt').to(device)
         with torch.no_grad():
@@ -175,51 +201,41 @@ def estimate_src(sent1, ling, approx):
     else:
         raise ValueError()
 
-    ling['Source'] = ling_pred
-    return ling
+    ling_dict['Source'] = ling_pred
+    return ling_dict
 
-def rand_target(ling):
-    ling['Target'] = scaler.inverse_transform([np.random.randn(*ling['Target'].shape)])[0]
-    return ling
-
-def rand_ex_target(ling):
+def rand_ex_target():
     idx = np.random.randint(0, len(ling_collection))
     ling_ex = ling_collection[idx]
-    ling['Target'] = ling_ex
-    return ling
-
-def copy(ling):
-    ling['Target'] = ling['Source']
-    return ling
-
-def add(ling):
+    shared_state.target = ling_ex.copy()
+    return [gr.update(value=val) for val in shared_state.target]
+
+def copy_source_to_target():
+    if "" in shared_state.source:
+        raise gr.Error("Source linguistic features not initialized. Please estimate them first.")
+    shared_state.target = shared_state.source.copy()
+    return [gr.update(value=val) for val in shared_state.target]
+
+def add_to_target():
+    if not shared_state.active_indices:
+        raise gr.Error("No features are activated. Please activate features to modify.")
     scale_stepsize = np.random.uniform(1.0, 5.0)
-    x = ling['Target'] + scale_stepsize * scale_ratio
-    x = round_ling(x)
-    ling['Target'] =  x
-    return ling
-
-def sub(ling):
+    new_targets = np.array(shared_state.target)
+    for i in shared_state.active_indices:
+        new_targets[i] += scale_stepsize * scale_ratio[i]
+    shared_state.target = round_ling(new_targets).tolist()
+    return [gr.update(value=val) for val in shared_state.target]
+
+def subtract_from_target():
+    if not shared_state.active_indices:
+        raise gr.Error("No features are activated. Please activate features to modify.")
     scale_stepsize = np.random.uniform(1.0, 5.0)
-    x = ling['Target'] - scale_stepsize * scale_ratio
-    x = round_ling(x)
-    ling['Target'] =  x
-    return ling
-
-def impute(ling):
-    ling['Target'] = ling['Target'].replace("", np.nan)
-    ling['Target'] = scaler.transform([ling['Target']])[0]
-    estimator = Ridge(alpha=1e3, fit_intercept=False)
-    imputer = IterativeImputer(estimator=estimator, imputation_order='random', max_iter=100)
+    new_targets = np.array(shared_state.target)
+    for i in shared_state.active_indices:
+        new_targets[i] -= scale_stepsize * scale_ratio[i]
+    shared_state.target = round_ling(new_targets).tolist()
+    return [gr.update(value=val) for val in shared_state.target]
 
-    combined_matrix = np.vstack([ling_collection, ling['Target']])
-    interpolated_matrix = imputer.fit_transform(combined_matrix)
-    interpolated_vector = interpolated_matrix[-1]
-
-    interp_raw = scaler.inverse_transform([interpolated_vector])[0]
-
-    ling['Target'] = round_ling(interp_raw)
-    return ling
 
 title = """
 <h1 style="text-align: center;">Controlled Paraphrase Generation with Linguistic Feature Control</h1>
@@ -228,46 +244,44 @@ title = """
 The model can generate diverse paraphrases of a given sentence, each adjusted to maintain consistent meaning while varying
 in linguistic complexity according to the desired level.</p>
 <p style="font-size:1.2em;">It is important to note that not all index combinations are feasible (e.g., a sentence of "length" 5 with 10 "unique words").
-To ensure high-quality outputs, our approach iteratively adjusts the generated text to match the closest, yet coherent
+To ensure high-quality outputs, our approach compares the initial generation with the target linguistic indices, and performs iterative refinement to match the closest, yet coherent
 achievable set of indices for the given target.</p>
 """
 
 guide = """
-You may use the system in on of the following ways:
-
-**Randomized Paraphrase Generation**: Select this option to produce multiple paraphrases with a range
-of linguistic complexity. You need to provide a source text, specify the number of paraphrases you want,
-and click "Generate." The linguistic complexity of the paraphrases will be determined randomly.
-
-**Complexity-Matched Paraphrasing**: Select this option to generate a paraphrase of the given source
-sentence that closely mirrors the linguistic complexity of another given sentence. Input your source
-sentence along with another sentence (which will serve only to extract linguistic indices for the
-paraphrase generation). Then, click "Generate."
+1. **Select Operation Mode**: Choose from the available modes:
+   - **Linguistically-diverse Paraphrase Generation**: Generate diverse paraphrases.
+     - **Steps**:
+       1. Enter the source text in the provided textbox.
+       2. Specify the number of paraphrases you want.
+       3. Click "Generate" to produce paraphrases with varying linguistic complexity.
+   - **Complexity-Matched Paraphrasing**: Match the complexity of the input text.
+     - **Steps**:
+       1. Enter the source text in the provided textbox.
+       2. Provide another sentence to extract linguistic indices.
+       3. Click "Generate" to produce a paraphrase matching the complexity of the given sentence.
+   - **Manual Linguistic Control**: Manually adjust linguistic features using sliders.
+     - **Steps**:
+       1. Enter the source text in the provided textbox.
+       2. Activate or deactivate features of interest using the checkboxes.
+       3. Use the sliders to adjust linguistic features.
+       4. **Use Tools**: Access additional tools under "Tools to assist in setting linguistic indices" for advanced control.
+        - **Impute Missing Values**: Automatically fill inactive features.
+        - **Random Target**: Generate a random set of linguistic indices.
+        - **Copy Source to Target**: Copy linguistic indices from the source to the target.
+        - **Add/Subtract Complexity**: Adjust the complexity of the target indices.
+       5. Click "Generate" to produce the output text based on the adjusted features.
 
-**Manual Linguistic Control**: Select this option to manually control the linguistic complexity of the
-generated text. We provided a set of tools for manual adjustments of the desired linguistic complexity of
-the target sentence. These tools enable the user to extract linguistic indices from a given sentence,
-generate a random (yet coherent) set of linguistic indices, and add or subtract to them.
-These tools are designed for experimental use and require the user to possess linguistic expertise for
-effective input of linguistic indices. To use these tools, select "Tools to assist in setting linguistic
-indices." Once indices are entered, click "Generate."
-
-
-Second, you may select to use exact or approximate computation of linguistic indices. Approximate computation is significantly faster.
-
-Third, you may view the intermediate sentences of the quality control process by selecting the checkbox under "Advanced Options".
-
-Fourth, you may try out some examples by clicking on "Examples...". Examples consist of a source sentences
-and a sample set of target linguistic indices.
-
-Please make your choice below.
+"""
 
+# Updated Advanced Options Description
+advanced_options_description = """
+**Advanced Options**:
+- **Approximate vs. Exact Computation**: Choose between faster approximate computation or more precise exact computation of linguistic indices.
+- **View Intermediate Generations**: Enable this option to see the intermediate sentences generated during the quality control process.
 """
 
-sent1 = gr.Textbox(label='Source text')
-ling = gr.Dataframe(value = [[x, 0, 0] for x in lng_names],
-        headers=['Index', 'Source', 'Target'],
-        datatype=['str', 'number', 'number'], visible=False)
+
 css = """
 #guide span.svelte-1w6vloh {font-size: 22px !important; font-weight: 600 !important}
 #mode span.svelte-1gfkn6j {font-size: 18px !important; font-weight: 600 !important}
@@ -300,61 +314,164 @@ body {
   background-color: #000; /* Adjust the color as needed */
   margin-bottom: 20px; /* Adjust the margin as needed */
 }
+
+.features-container {
+    border: 1px solid rgba(0, 0, 0, 0.1);
+    border-radius: 8px;
+    background: white;
+}
+
+/* Style the inner column to be scrollable */
+.features-container > div > .column {
+    max-height: 400px;
+    overflow-y: scroll;
+    padding: 10px;
+}
+
+/* Scrollbar styles now apply to the inner column */
+.features-container > div > .column::-webkit-scrollbar {
+    width: 8px;
+}
+
+.features-container > div > .column::-webkit-scrollbar-track {
+    background: #f1f1f1;
+    border-radius: 4px;
+}
+
+.features-container > div > .column::-webkit-scrollbar-thumb {
+    background: #888;
+    border-radius: 4px;
+}
+
+.features-container > div > .column::-webkit-scrollbar-thumb:hover {
+    background: #555;
+}
+
+.features-container .label-wrap span {
+    font-weight: 600;
+    font-size: 18px;
+}
 """
 
+sent1 = gr.Textbox(label='Source text')
+ling_sliders = []
+ling_dict = {'Source': [""] * len(lng_names), 'Target': [0] * len(lng_names)}
+active_indices = []
+target_sliders = []
+source_values = []
+active_checkboxes = []
+for i in range(len(lng_names)):
+    source_values.append(gr.Textbox(placeholder="Not initialized", 
+                                  lines=1, label="Source", interactive=False, 
+                                  container=False, scale=1))
+    active_checkboxes.append(gr.Checkbox(label="Activate", value=False))
+    target_sliders.append(
+        gr.Slider(
+            minimum=stats['min'][i],
+            maximum=stats['max'][i],
+            value=stats['min'][i],
+            step=0.001 if not stats['is_int'][i] else 1,
+            label=None,
+            interactive=False
+        )
+    )
+
+# Move SharedState class and instance to top
+class SharedState:
+    def __init__(self, n_features):
+        self.source = [""] * n_features
+        self.target = [0] * n_features
+        self.active_indices = set()
+
+    def update_target(self, index, value):
+        self.target[index] = value
+        return self.target.copy()
+
+    def update_source(self, index, value):
+        self.source[index] = value
+        return self.source.copy()
+
+    def toggle_active(self, index, value):
+        if value:
+            self.active_indices.add(index)
+        else:
+            self.active_indices.discard(index)
+        return list(self.active_indices)
+
+    def get_state(self):
+        return {
+            'Source': self.source.copy(),
+            'Target': self.target.copy(),
+            'active_indices': list(self.active_indices)
+        }
+
+shared_state = SharedState(len(lng_names))
+
 with gr.Blocks(
         theme=gr.themes.Default(
             spacing_size=gr.themes.sizes.spacing_md,
             text_size=gr.themes.sizes.text_md,
             ),
         css=css) as demo:
-    gr.Image('assets/logo.png', height=100, container=False, show_download_button=False)
+    # Header
+    gr.Image('assets/logo.png', height=100, container=False, show_download_button=False, show_fullscreen_button=False)
     gr.Markdown(title)
+    
+    # Guide
     with gr.Accordion("🚀 Quick Start Guide", open=False, elem_id='guide'):
         gr.Markdown(guide)
 
     with gr.Group(elem_classes='top-separator'):
         pass
+
+    # Mode Selection
     with gr.Group(elem_id='mode'):
         mode = gr.Radio(
-                value='Randomized Paraphrase Generation',
+                value='Linguistically-diverse Paraphrase Generation',
                 label='Operation Modes',
                 type="index",
-                choices=['🔄 Randomized Paraphrase Generation',
+                choices=['🔄 Linguistically-diverse Paraphrase Generation',
                          '⚖️ Complexity-Matched Paraphrasing',
                          '🎛️ Manual Linguistic Control'],
                         )
     with gr.Accordion("⚙️ Advanced Options", open=False):
+        gr.Markdown(advanced_options_description)
         approx = gr.Radio(value='Use approximate computation of linguistic indices (faster)',
                 choices=['Use approximate computation of linguistic indices (faster)',
                     'Use exact computation of linguistic indices'], container=False, show_label=False)
         control_interpolation = gr.Checkbox(label='View the intermediate sentences in the interpolation of linguistic indices')
 
-    with gr.Accordion("📑 Examples...", open=False):
-        gr.Examples(examples, [sent1, ling], examples_per_page=4, label=None)
 
+    # Main Input/Output
     with gr.Row():
-        sent1.render()
+        with gr.Column():
+            sent1.render()
+
+            count = gr.Number(label='Number of generated sentences', value=3, precision=0, scale=1, visible=True)
+
+            sent_ling_gen = gr.Textbox(label='Copy the style of this sentence', scale=1, visible=False)
+
+
         with gr.Column():
             sent2 = gr.Textbox(label='Generated text')
-    interpolation = gr.Textbox(label='Quality control interpolation', visible=False, lines=5)
-    with gr.Group(elem_classes='bottom-separator'):
-        pass
-    #####################
-    with gr.Row():
-        generate_random_btn = gr.Button("Generate",
-                variant='primary', scale=1, visible=True)
-        count = gr.Number(label='Number of generated sentences', value=3, precision=0, scale=1, visible=True)
-    # generate_fb_btn = gr.Button("Generate with auto-adjust (towards pred)")
-    # generate_fb_s_btn = gr.Button("Generate with auto-adjust (moving s)")
-    #####################
-    with gr.Row():
-        estimate_gen_btn = gr.Button("Generate", 
-                variant='primary',
-                scale=1, visible=False)
-        sent_ling_gen = gr.Textbox(label='Text to estimate linguistic indices', scale=1, visible=False)
-    #####################
-    generate_btn = gr.Button("Generate", variant='primary', visible=False)
+            generate_random_btn = gr.Button("Generate", variant='primary', scale=1, visible=True)
+            estimate_gen_btn = gr.Button("Generate", variant='primary', scale=1, visible=False)
+            generate_btn = gr.Button("Generate", variant='primary', visible=False)
+    # Linguistic Features Container
+    with gr.Accordion("Linguistic Features", elem_classes="features-container", open=True, visible=False) as ling_features:
+        with gr.Row():
+            select_all_btn = gr.Button("Activate All", size='sm')
+            unselect_all_btn = gr.Button("Deactivate All", size='sm')
+        
+        for i, name in enumerate(lng_names):
+            with gr.Row():
+                feature_name = gr.Textbox(name, lines=1, label="Feature", container=False, show_label=False, interactive=False)
+                source_values[i].render()
+                active_checkboxes[i].render()
+                target_sliders[i].interactive = False
+                target_sliders[i].render()
+                ling_sliders.append((feature_name, source_values[i], target_sliders[i], active_checkboxes[i], i))
+    # Tools Accordion
     with gr.Accordion("Tools to assist in the setting of linguistic indices...", open=False, visible=False) as ling_tools:
         rand_ex_btn = gr.Button("Random target", size='lg', visible=False)
         impute_btn = gr.Button("Impute Missing Values", size='lg', visible=False)
@@ -362,33 +479,195 @@ with gr.Blocks(
             estimate_src_btn = gr.Button("Estimate linguistic indices of source sentence", visible=False)
             copy_btn = gr.Button("Copy linguistic indices of source to target", size='lg', visible=False)
         with gr.Row():
-            sub_btn = gr.Button('Subtract \u03B5 from target linguistic indices', visible=False)
-            add_btn = gr.Button('Add \u03B5 to target linguistic indices', visible=False)
+            sub_btn = gr.Button('Decrease target complexity by \u03B5', visible=False)
+            add_btn = gr.Button('Increase target complexity by \u03B5', visible=False)
         with gr.Row():
             estimate_tgt_btn = gr.Button("Estimate linguistic indices of this sentence →", visible=False)
             sent_ling_est = gr.Textbox(label='Text to estimate linguistic indices', scale=2, visible=False, container=False, elem_id='estimate')
-    ling.render()
-    #####################
-
-    estimate_src_btn.click(estimate_src, inputs=[sent1, ling, approx], outputs=[ling])
-    estimate_tgt_btn.click(estimate_tgt, inputs=[sent_ling_est, ling, approx], outputs=[ling])
-    estimate_gen_btn.click(estimate_gen, inputs=[sent1, sent_ling_gen, ling, approx], outputs=[sent2, interpolation, ling])
-    rand_ex_btn.click(rand_ex_target, inputs=[ling], outputs=[ling])
-    impute_btn.click(impute, inputs=[ling], outputs=[ling])
-    copy_btn.click(copy, inputs=[ling], outputs=[ling])
-    generate_btn.click(generate_with_feedback, inputs=[sent1, ling, approx], outputs=[sent2, interpolation])
-    generate_random_btn.click(generate_random, inputs=[sent1, ling, count, approx],
-            outputs=[sent2, interpolation, ling])
-    add_btn.click(add, inputs=[ling], outputs=[ling])
-    sub_btn.click(sub, inputs=[ling], outputs=[ling])
+    interpolation = gr.Textbox(label='Quality control interpolation', visible=False, lines=5)
+    
+    with gr.Group(elem_classes='bottom-separator'):
+        pass
 
+    # Examples
+    def load_example(example_text, *values):
+        # Split values into source, target, and active values
+        n = len(lng_names)
+        source_values = values[:n]
+        target_values = values[n:]
+        
+        # Update shared state
+        shared_state.source = [float(x) for x in source_values]
+        shared_state.target = list(target_values)
+        shared_state.active_indices = set(range(n))  # Activate all indices
+        
+        # Return updates for all components:
+        return [True] * n
+
+    gr.Examples(
+        examples=examples,
+        inputs=[sent1] + source_values + target_sliders,
+        outputs=active_checkboxes,
+        example_labels=[ex[0] for ex in examples],
+        fn=load_example,
+        run_on_click=True,
+    )
+
+
+    # Add select/unselect all handlers
+    def select_all():
+        for i in range(len(lng_names)):
+            shared_state.toggle_active(i, True)
+        return [True] * len(lng_names) + [gr.update(interactive=True)] * len(lng_names)
+
+    def unselect_all():
+        shared_state.active_indices.clear()
+        return [False] * len(lng_names) + [gr.update(interactive=False)] * len(lng_names)
+
+    select_all_btn.click(
+        fn=select_all,
+        outputs=active_checkboxes + [slider for _, _, slider, _, _ in ling_sliders]
+    )
+    
+    unselect_all_btn.click(
+        fn=unselect_all,
+        outputs=active_checkboxes + [slider for _, _, slider, _, _ in ling_sliders]
+    )
+
+    def update_slider(slider_index, new_value):
+        shared_state.target[slider_index] = new_value
+
+    def update_checkbox(checkbox_index, new_value):
+        shared_state.toggle_active(checkbox_index, new_value)
+        return gr.update(interactive=new_value)
+
+    # Update the event bindings
+    for feature_name, source_value, target_slider, active_checkbox, i in ling_sliders:
+        target_slider.change(
+            fn=update_slider,
+            inputs=[gr.Number(i, visible=False), target_slider],
+        )
+        active_checkbox.change(
+            fn=update_checkbox,
+            inputs=[gr.Number(i, visible=False), active_checkbox],
+            outputs=target_slider
+        )
+
+    # Define groups and visibility
     group1 = [generate_random_btn, count]
     group2 = [estimate_gen_btn, sent_ling_gen]
-    group3 = [generate_btn, estimate_src_btn, impute_btn, estimate_tgt_btn, sent_ling_est, rand_ex_btn, copy_btn, add_btn, sub_btn, ling, ling_tools]
+    group3 = [generate_btn, estimate_src_btn, impute_btn, estimate_tgt_btn, sent_ling_est, 
+              rand_ex_btn, copy_btn, add_btn, sub_btn, ling_features, ling_tools]
     components = group1 + group2 + group3
+    
     mode.change(visibility, inputs=[mode], outputs=[sent2, interpolation] + components)
     control_interpolation.change(lambda v: gr.update(visible=v), inputs=[control_interpolation],
             outputs=[interpolation])
 
+    def update_sliders_from_state(ling_state, slider_indices):
+        updates = []
+        for i in slider_indices:
+            updates.append(str(ling_state['Source'][i]))
+            updates.append(ling_state['Target'][i])
+            updates.append(gr.update(value=True))
+        return updates
+
+    def update_sliders_from_estimate(approx, sent_for_estimate):
+        if 'approximate' in approx:
+            input_ids = tokenizer.encode(sent_for_estimate, return_tensors='pt').to(device)
+            with torch.no_grad():
+                ling_pred = ling_disc(input_ids=input_ids).cpu().numpy()
+            ling_pred = scaler.inverse_transform(ling_pred)[0]
+        elif 'exact' in approx:
+            ling_pred = np.array(compute_lng(sent_for_estimate))[used_indices]
+        else:
+            raise ValueError()
+
+        ling_pred = round_ling(ling_pred)
+        shared_state.source = ling_pred.copy()
+        shared_state.target = ling_pred.copy()
+        
+        # Return updates separately for each type of component
+        return ling_pred + [True] * len(lng_names)
+
+    def update_sliders_from_source(approx, source_sent):
+        if 'approximate' in approx:
+            input_ids = tokenizer.encode(source_sent, return_tensors='pt').to(device)
+            with torch.no_grad():
+                ling_pred = ling_disc(input_ids=input_ids).cpu().numpy()
+            ling_pred = scaler.inverse_transform(ling_pred)[0]
+        elif 'exact' in approx:
+            ling_pred = np.array(compute_lng(source_sent))[used_indices]
+        else:
+            raise ValueError()
+
+        ling_pred = round_ling(ling_pred)
+        shared_state.source = ling_pred.copy()
+        
+        return [str(ling_pred[i]) for i in range(len(lng_names))]
+
+    slider_indices = [i for _, _, _, _, i in ling_sliders]
+    slider_updates = [elem for _, source, slider, active, _ in ling_sliders for elem in [source, slider, active]]
+
+    # Bind all the event handlers
+    estimate_src_btn.click(update_sliders_from_source, 
+        inputs=[approx, sent1], 
+        outputs=source_values)
+    estimate_tgt_btn.click(update_sliders_from_estimate, 
+        inputs=[approx, sent_ling_est], 
+        outputs=target_sliders + active_checkboxes)
+    estimate_gen_btn.click(
+        fn=estimate_gen, 
+        inputs=[sent1, sent_ling_gen, approx], 
+        outputs=[sent2, interpolation] + target_sliders
+    )
+    impute_btn.click(
+        fn=lambda: [gr.update(value=val) for val in impute_targets()], 
+        outputs=target_sliders
+    )
+    copy_btn.click(
+        fn=copy_source_to_target, 
+        outputs=target_sliders
+    )
+    generate_btn.click(
+        fn=generate_with_feedback, 
+        inputs=[sent1, approx], 
+        outputs=[sent2, interpolation] + target_sliders
+    )
+    generate_random_btn.click(
+        fn=generate_random, 
+        inputs=[sent1, count, approx],
+        outputs=[sent2, interpolation]
+    )
+    add_btn.click(
+        fn=add_to_target, 
+        outputs=target_sliders
+    )
+    sub_btn.click(
+        fn=subtract_from_target, 
+        outputs=target_sliders
+    )
+
+    # Event handlers for the tools
+    rand_ex_btn.click(
+        fn=rand_ex_target,
+        outputs=target_sliders
+    )
+
+    copy_btn.click(
+        fn=copy_source_to_target,
+        outputs=target_sliders
+    )
+
+    add_btn.click(
+        fn=add_to_target,
+        outputs=target_sliders
+    )
+
+    sub_btn.click(
+        fn=subtract_from_target,
+        outputs=target_sliders
+    )
+
 print('Finished loading')
 demo.launch(share=True)