Update app.py

app.py

@@ -1,4 +1,3 @@
-import random
 import gradio as gr
 from pathlib import Path
 from reactagent.environment import Environment
@@ -6,72 +5,45 @@ from reactagent.agents.agent_research import ResearchAgent
 from reactagent.runner import create_parser
 from reactagent import llm
 from reactagent.users.user import User
+import json
 
 
 # Global variables to store session state
 env = None
 agent = None
-example_data = {
-    1: {
-        "title": "Dataset and Baseline for Automatic Student Feedback Analysis",
-        "abstract": """
-            This paper presents a student feedback corpus containing 3000 instances of feedback written by university students. 
-            The dataset has been annotated for aspect terms, opinion terms, polarities of the opinion terms towards targeted aspects, 
-            document-level opinion polarities, and sentence separations. A hierarchical taxonomy for aspect categorization 
-            covering all areas of the teaching-learning process was developed. Both implicit and explicit aspects were annotated 
-            using this taxonomy. The paper discusses the annotation methodology, difficulties faced during the annotation, 
-            and details about aspect term categorization. The annotated corpus can be used for Aspect Extraction, 
-            Aspect Level Sentiment Analysis, and Document Level Sentiment Analysis. Baseline results for all three tasks are provided.
-        """,
-        "research_tasks": "The primary research tasks include the creation of a comprehensive student feedback corpus, aspect term annotation, opinion polarity annotation, and the development of a hierarchical taxonomy.",
-        "research_gaps": "Gaps include the lack of detailed aspect-level annotations in existing datasets and the focus on document-level sentiment analysis.",
-        "keywords": "Student Feedback Corpus, Aspect Terms, Opinion Terms, Polarity, Hierarchical Taxonomy, Aspect Extraction, Aspect Level Sentiment Analysis, Document Level Sentiment Analysis",
-        "recent_works": [
-            "Students feedback analysis model using deep learning-based method and linguistic knowledge for intelligent educational systems.",
-            "An Automated Approach for Analysing Students Feedback Using Sentiment Analysis Techniques."
-        ]
-    },
-    2: {
-        "title": "An Empirical Study on the Impact of Code Review on Software Quality",
-        "abstract": """
-            This paper presents an empirical study examining the impact of code reviews on the quality of software projects. 
-            The study involved analyzing over 500,000 code reviews across 20 open-source projects on GitHub. 
-            The analysis was conducted to assess the relationship between code review practices and key software quality metrics, 
-            such as defect density, code churn, and the frequency of post-release defects. The findings suggest that code reviews, 
-            particularly when conducted by experienced reviewers, significantly reduce the number of defects in the codebase. 
-            The paper discusses the methodology used for data collection, the statistical methods employed for analysis, 
-            and the implications of these findings for software development practices.
-        """,
-        "research_tasks": "The primary research tasks include collecting and analyzing data on code reviews from open-source projects, measuring software quality metrics, and assessing the correlation between code review practices and software quality.",
-        "research_gaps": "Gaps include the lack of large-scale empirical studies that quantify the impact of code reviews on software quality and the limited focus on the role of reviewer expertise in existing literature.",
-        "keywords": "Code Reviews, Software Quality, Defect Density, Code Churn, Post-Release Defects, Empirical Study, Open-Source Projects, GitHub",
-        "recent_works": [
-            "The Effectiveness of Code Reviews in Identifying Defects: A Meta-Analysis of Empirical Studies",
-            "A Study on the Impact of Code Review Tools on Developer Productivity and Software Quality"
-        ]
-    }
-}
-
-# # Predefined research paper text (example)
-# predefined_paper_text = """
-#     Title:
-#     Dataset and Baseline for Automatic Student Feedback Analysis
-
-#     Abstract:
-#     This paper presents a student feedback corpus containing 3000 instances of feedback written by university students. The dataset has been annotated for aspect terms, opinion terms, polarities of the opinion terms towards targeted aspects, document-level opinion polarities, and sentence separations. A hierarchical taxonomy for aspect categorization covering all areas of the teaching-learning process was developed. Both implicit and explicit aspects were annotated using this taxonomy. The paper discusses the annotation methodology, difficulties faced during the annotation, and details about aspect term categorization. The annotated corpus can be used for Aspect Extraction, Aspect Level Sentiment Analysis, and Document Level Sentiment Analysis. Baseline results for all three tasks are provided.
-# """
-
-# # Predefined extracted elements based on the paper text
-# predefined_research_tasks = "The primary research tasks include the creation of a comprehensive student feedback corpus, aspect term annotation, opinion polarity annotation, and the development of a hierarchical taxonomy."
-# predefined_research_gaps = "Gaps include the lack of detailed aspect-level annotations in existing datasets and the focus on document-level sentiment analysis."
-# predefined_keywords = "Student Feedback Corpus, Aspect Terms, Opinion Terms, Polarity, Hierarchical Taxonomy, Aspect Extraction, Aspect Level Sentiment Analysis, Document Level Sentiment Analysis"
-# predefined_recent_works = """
-#     1. "Students feedback analysis model using deep learning-based method and linguistic knowledge for intelligent educational systems."
-#     2. "An Automated Approach for Analysing Students Feedback Using Sentiment Analysis Techniques."
-#     """
-
-# Extraction function to simulate the extraction of Research Tasks (t), Research Gaps (g), Keywords (k), and Recent Works (R)
+state_extract = False
+state_generate = False
+state_agent = False
+state_complete = False
+index_ex = "1"
+
+
+# Load example JSON file
+def load_example_data():
+    with open("example/example_data.json", "r") as json_file:
+        return json.load(json_file)
+
+example_data = load_example_data()
+
+with open("example/ex1_init.py", "r") as f:
+    predefined_code = f.read()
+
+with open("example/ex1_final.py", "r") as f:
+    final_code = f.read()
+
+# Function to handle the selection of an example and populate the respective fields
+def load_example(example_id):
+    global index_ex 
+    index_ex = str(example_id)
+    example = example_data[index_ex]
+    paper_text = 'Title:\t' +  example['title'] + '\nAbstract:\t' + example['abstract']
+    return paper_text
+
+########## Phase 1 ##############
+
 def extract_research_elements(paper_text):
+    global state_extract 
+    state_extract = True
     global index_ex
     example = example_data[index_ex]
     tasks = example['research_tasks']
@@ -80,92 +52,52 @@ def extract_research_elements(paper_text):
     recent_works = "\n".join(example['recent_works'])
     return tasks, gaps, keywords, recent_works
 
-# Generation function for Research Hypothesis and Experiment Plan
-def generate_research_idea_and_plan(tasks, gaps, keywords, recent_works):
-    hypothesis = f"""
-    Method: Advanced Aspect-Level Sentiment Analysis of Student Feedback Using a Hybrid Deep Learning Approach
-
-    Step 1: Dataset Enhancement 
-
-    Data Collection and Preprocessing
-    * Collect additional student feedback from multiple universities to expand the existing dataset.
-    * Preprocess the data to ensure uniformity in annotation and eliminate noise, such as redundant information and grammatical errors.
-    Annotation Refinement
-    * Use advanced NLP techniques to further refine the aspect terms, opinion terms, and polarities.
-    * Incorporate semi-supervised learning methods to improve annotation accuracy, utilizing both manual and automated processes.
-
-    Step 2: Model Development
-    Hybrid Model Architecture
-    * Develop a hybrid model that integrates CNN, BiLSTM, and attention mechanisms, similar to the DTLP approach mentioned in the recent work by DTLP (Deep Learning and Teaching Process).
-    * Incorporate a Transformer-based model (like BERT) to capture contextual nuances and improve the understanding of implicit aspects.
-    Feature Integration
-    * Enhance the feature set by combining statistical, linguistic, and sentiment knowledge features with word embeddings.
-    * Include sentiment shifter rules and contextual polarity indicators to address challenges in sentiment analysis.
-
-    Step 3: Training and Validation
-    Model Training
-    * Train the hybrid model using the enhanced dataset.
-    * Use cross-validation techniques to ensure robustness and prevent overfitting.
-    Baseline Comparisons
-    * Compare the model's performance with baseline results provided in the original study and other recent works.
-    * Use metrics such as accuracy, precision, recall, and F1-score to evaluate model performance across different tasks, including Aspect Extraction, Aspect Level Sentiment Analysis, and Document Level Sentiment Analysis.
-
-    Step 4: Iterative Refinement
-    Feedback Loop
-    * Implement an iterative feedback loop where the model's predictions are reviewed and corrected, improving the model iteratively.
-    * Engage domain experts in the review process to ensure the relevance and accuracy of the feedback. Continuous Learning
-    * Utilize active learning techniques to continuously update the model with new data, ensuring it remains up-to-date with current trends in student feedback.
-
-    Step 5: Deployment and Application
-    Integration with Educational Systems
-    * Deploy the model as a part of an intelligent educational system to analyze student feedback in real-time.
-    * Provide actionable insights to educators and administrators to improve teaching methods and curriculum design. User Interface Development
-    * Develop an intuitive user interface that allows educators to interact with the model, view feedback analysis, and generate reports.
-    """
-
-    experiment_plan = f"""
-    Experiment: Validating the Hybrid Deep Learning Approach for Aspect-Level Sentiment Analysis of Student Feedback
-
-    Objective:
-    To validate the effectiveness of the proposed hybrid deep learning approach (combining CNN, BiLSTM, and Transformer models) for aspect-level sentiment analysis of student feedback by comparing its performance with baseline methods and recent works.
-    Research Problem:
-    Current sentiment analysis models for student feedback lack detailed aspect-level annotations and fail to address implicit aspects and contextual nuances in feedback data.
-    Proposed Method:
-    A hybrid deep learning model integrating CNN, BiLSTM, and Transformer-based models (like BERT) to enhance aspect-level sentiment analysis. The method incorporates sentiment shifter rules and contextual polarity indicators to address challenges in sentiment analysis.
-
-    Experiment Design:
-    1. Dataset Preparation:
-        * Existing Dataset: Use the dataset provided by Herath et al. (2022) with 3000 instances of student feedback, annotated for aspect terms, opinion terms, polarities, and document-level sentiments.
-        * Data Augmentation: Expand the dataset by collecting additional feedback from multiple universities, ensuring diversity in feedback data.
-    2. Preprocessing:
-        * Clean the data to remove noise and inconsistencies.
-        * Tokenize the text and apply part-of-speech tagging.
-        * Annotate additional feedback instances using the refined hierarchical taxonomy.
-    3. Model Training:
-        * Baseline Models: Implement and train traditional machine learning models (e.g., SVM, Naive Bayes) and existing deep learning models (e.g., LSTM, BiLSTM) for sentiment analysis.
-        * Proposed Hybrid Model: Train the proposed hybrid model combining CNN, BiLSTM, and Transformer (BERT) layers. Use pre-trained embeddings and fine-tune on the feedback dataset.
-    4. Feature Extraction:
-        * Extract features using word embeddings, sentiment shifter rules, and contextual polarity indicators.
-        * Integrate statistical, linguistic, and sentiment knowledge features with word embeddings to form a comprehensive feature set.
-    5. Evaluation Metrics:
-        * Measure the performance of models using accuracy, precision, recall, and F1-score.
-        * Perform aspect-level evaluation by analyzing the accuracy of aspect term extraction and sentiment classification.
-    6. Experiment Execution:
-        * Training Phase: Train the baseline models and the proposed hybrid model on the training dataset.
-        * Validation Phase: Validate the models using cross-validation techniques to ensure robustness and prevent overfitting.
-        * Testing Phase: Evaluate the models on a held-out test set to compare their performance.
-    7. Comparison and Analysis:
-        * Compare the performance of the proposed hybrid model with baseline models and recent works, such as DTLP and other sentiment analysis techniques.
-        * Analyze the results to identify strengths and weaknesses of the proposed model in handling aspect-level sentiment analysis and implicit aspects.
-    8. Iterative Refinement:
-        * Implement an iterative feedback loop where predictions are reviewed and corrected, improving model performance over iterations.
-        * Engage domain experts to review the model's predictions and provide feedback for further refinement.
-    9. Deployment:
-        * Integrate the validated model into an intelligent educational system for real-time feedback analysis.
-        * Develop a user interface to allow educators to interact with the model, view feedback analysis, and generate reports.
-    """
-
-    return hypothesis, experiment_plan
+
+# Step 2: Generate Research Hypothesis and Experiment Plan
+def generate_and_store(tasks, gaps, keywords, recent_works):
+    if (not state_extract):
+        return "", "", "", ""
+    global state_generate 
+    state_generate = True
+    global index_ex
+    hypothesis = example_data[index_ex]['hypothesis']
+    experiment_plan = example_data[index_ex]['experiment_plan']
+    return hypothesis, experiment_plan, hypothesis, experiment_plan
+
+##########  Phase 2 & 3  ##############
+def start_experiment_agent(hypothesis, plan):
+    if (not state_extract or not  state_generate):
+        return "", ""
+    global state_agent 
+    state_agent = True
+    predefined_message = f"Implement the following hypothesis and experiment plan:\n\nHypothesis:\n{hypothesis}\n\nExperiment Plan:\n{plan}"
+    return predefined_code, predefined_action_log
+
+def submit_feedback(user_feedback, history, previous_response):
+    if (not state_extract or not  state_generate or not state_agent):
+        return "", "", ""
+    global step_index
+    global state_complete
+    step_index += 1
+    msg = history
+    if step_index < len(process_steps):
+        msg += previous_response + "\nUser feedback:" + user_feedback + "\n\n"
+        response_info = process_steps[step_index]
+        response = info_to_message(response_info)  # Convert dictionary to formatted string
+        response += "Please provide feedback based on the history, response entries, and observation, and questions: "
+        step_index += 1
+        msg += response
+    else:
+        state_complete = True
+        response = "Agent Finished."
+        
+
+    return msg, response, predefined_code if state_complete else final_code
+
+def load_phase_2_inputs(hypothesis, plan):
+    return hypothesis, plan, "# Code implementation will be displayed here after Start ExperimentAgent."
+
+
 
 predefined_action_log = """
 [Reasoning]: To understand the initial structure and functionality of train.py for effective improvements.
@@ -177,347 +109,6 @@ Objective: Understand the training script, including data processing, [...]
 """
 
 
-
-
-# Predefined code to display in Phase 2
-predefined_code = """import pandas as pd
-from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error
-import numpy as np
-import random
-import torch
-from sklearn.model_selection import train_test_split
-
-DIMENSIONS = ["cohesion", "syntax", "vocabulary", "phraseology", "grammar", "conventions"]
-SEED = 42
-
-random.seed(SEED)
-torch.manual_seed(SEED)
-np.random.seed(SEED)
-
-def compute_metrics_for_regression(y_test, y_test_pred):
-    metrics = {}
-    for task in DIMENSIONS:
-        targets_task = [t[DIMENSIONS.index(task)] for t in y_test]
-        pred_task = [l[DIMENSIONS.index(task)] for l in y_test_pred]
-        
-        rmse = mean_squared_error(targets_task, pred_task, squared=False)
-
-        metrics[f"rmse_{task}"] = rmse
-    
-    return metrics
-
-def train_model(X_train, y_train, X_valid, y_valid):
-    model = None  # Placeholder for model training
-    return model
-
-def predict(model, X):
-    y_pred = np.random.rand(len(X), len(DIMENSIONS))
-    return y_pred
-
-if __name__ == '__main__':
-
-    ellipse_df = pd.read_csv('train.csv', 
-                            header=0, names=['text_id', 'full_text', 'Cohesion', 'Syntax', 
-                            'Vocabulary', 'Phraseology','Grammar', 'Conventions'], 
-                            index_col='text_id')
-    ellipse_df = ellipse_df.dropna(axis=0)
-
-    data_df = ellipse_df
-    X = list(data_df.full_text.to_numpy())
-    y = np.array([data_df.drop(['full_text'], axis=1).iloc[i] for i in range(len(X))])
-
-    X_train, X_valid, y_train, y_valid = train_test_split(X, y, test_size=0.10, random_state=SEED)
-
-    model = train_model(X_train, y_train, X_valid, y_valid)
-
-    y_valid_pred = predict(model, X_valid)
-    metrics = compute_metrics_for_regression(y_valid, y_valid_pred)
-    print(metrics)
-    print("final MCRMSE on validation set: ", np.mean(list(metrics.values())))
-
-    submission_df = pd.read_csv('test.csv',  header=0, names=['text_id', 'full_text'], index_col='text_id')
-    X_submission = list(submission_df.full_text.to_numpy())
-    y_submission = predict(model, X_submission)
-    submission_df = pd.DataFrame(y_submission, columns=DIMENSIONS)
-    submission_df.index = submission_df.index.rename('text_id')
-    submission_df.to_csv('submission.csv')
-"""
-
-final_code = """
-* Resulting train.py:
-import pandas as pd
-import numpy as np
-import torch
-import torch.nn as nn
-import torch.optim as optim
-from torch.utils.data import DataLoader, Dataset
-from transformers import BertTokenizer, BertModel
-
-# Define constants
-DIMENSIONS = ['cohesion', 'syntax', 'vocabulary', 'phraseology', 'grammar', 'conventions']
-
-class EssayDataset(Dataset):
-    def __init__(self, texts, targets, tokenizer, max_len):
-        self.texts = texts
-        self.targets = targets
-        self.tokenizer = tokenizer
-        self.max_len = max_len
-
-    def __len__(self):
-        return len(self.texts)
-
-    def __getitem__(self, item):
-        text = self.texts[item]
-        target = self.targets[item]
-
-        encoding = self.tokenizer.encode_plus(
-            text,
-            add_special_tokens=True,
-            max_length=self.max_len,
-            return_token_type_ids=False,
-            padding='max_length',
-            return_attention_mask=True,
-            return_tensors='pt',
-            truncation=True
-        )
-
-        return {
-            'text': text,
-            'input_ids': encoding['input_ids'].flatten(),
-            'attention_mask': encoding['attention_mask'].flatten(),
-            'targets': torch.tensor(target, dtype=torch.float)
-        }
-
-class EssayScoreRegressor(nn.Module):
-    def __init__(self, n_outputs):
-        super(EssayScoreRegressor, self).__init__()
-        self.bert = BertModel.from_pretrained('bert-base-uncased')
-        self.drop = nn.Dropout(p=0.3)
-        self.out = nn.Linear(self.bert.config.hidden_size, n_outputs)
-
-    def forward(self, input_ids, attention_mask):
-        pooled_output = self.bert(
-            input_ids=input_ids,
-            attention_mask=attention_mask
-        )['pooler_output']
-        output = self.drop(pooled_output)
-        return self.out(output)
-
-def train_epoch(model, data_loader, loss_fn, optimizer, device, scheduler, n_examples):
-    model = model.train()
-    losses = []
-
-    for d in data_loader:
-        input_ids = d['input_ids'].to(device)
-        attention_mask = d['attention_mask'].to(device)
-        targets = d['targets'].to(device)
-
-        outputs = model(input_ids=input_ids, attention_mask=attention_mask)
-        loss = loss_fn(outputs, targets)
-
-        losses.append(loss.item())
-
-        loss.backward()
-        optimizer.step()
-        scheduler.step()
-        optimizer.zero_grad()
-
-    return np.mean(losses)
-
-def train_model(train_data, val_data, tokenizer, model, optimizer, scheduler, device, epochs, batch_size, max_len):
-    train_dataset = EssayDataset(
-        texts=train_data['full_text'].to_numpy(),
-        targets=train_data[DIMENSIONS].to_numpy(),
-        tokenizer=tokenizer,
-        max_len=max_len
-    )
-
-    val_dataset = EssayDataset(
-        texts=val_data['full_text'].to_numpy(),
-        targets=val_data[DIMENSIONS].to_numpy(),
-        tokenizer=tokenizer,
-        max_len=max_len
-    )
-
-    train_data_loader = DataLoader(
-        train_dataset,
-        batch_size=batch_size,
-        shuffle=True
-    )
-
-    val_data_loader = DataLoader(
-        val_dataset,
-        batch_size=batch_size,
-        shuffle=False
-    )
-
-    loss_fn = nn.MSELoss().to(device)
-
-    for epoch in range(epochs):
-        print(f'Epoch {epoch + 1}/{epochs}')
-        print('-' * 10)
-
-        train_loss = train_epoch(
-            model,
-            train_data_loader,
-            loss_fn,
-            optimizer,
-            device,
-            scheduler,
-            len(train_dataset)
-        )
-
-        print(f'Train loss {train_loss}')
-
-if __name__ == "__main__":
-    df = pd.read_csv('train.csv')
-    tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
-    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-    model = EssayScoreRegressor(n_outputs=len(DIMENSIONS))
-    model = model.to(device)
-
-    optimizer = optim.Adam(model.parameters(), lr=2e-5)
-    total_steps = len(df) // 16 * 5
-    scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=total_steps, gamma=0.1)
-
-    train_data = df.sample(frac=0.8, random_state=42)
-    val_data = df.drop(train_data.index)
-
-    train_model(train_data, val_data, tokenizer, model, optimizer, scheduler, device, epochs=5, batch_size=16, max_len=160)
-
-* eval.py
-import sys
-import os
-import pandas as pd
-import numpy as np
-import torch
-from torch.utils.data import DataLoader
-from transformers import BertTokenizer
-from importlib import reload
-import train
-
-# Constants
-DIMENSIONS = train.DIMENSIONS
-
-class EssayDataset(Dataset):
-    def __init__(self, texts, targets, tokenizer, max_len):
-        self.texts = texts
-        self.targets = targets
-        self.tokenizer = tokenizer
-        self.max_len = max_len
-
-    def __len__(self):
-        return len(self.texts)
-
-    def __getitem__(self, item):
-        text = self.texts[item]
-        target = self.targets[item]
-
-        encoding = self.tokenizer.encode_plus(
-            text,
-            add_special_tokens=True,
-            max_length=self.max_len,
-            return_token_type_ids=False,
-            padding='max_length',
-            return_attention_mask=True,
-            return_tensors='pt',
-            truncation=True
-        )
-
-        return {
-            'text': text,
-            'input_ids': encoding['input_ids'].flatten(),
-            'attention_mask': encoding['attention_mask'].flatten(),
-            'targets': torch.tensor(target, dtype=torch.float)
-        }
-
-def get_score(submission_folder="../env"):
-    submission_path = os.path.join(submission_folder, "submission.csv")
-    solution = pd.read_csv(os.path.join(os.path.dirname(__file__), "answer.csv"))[DIMENSIONS].to_numpy()
-    submission = pd.read_csv(submission_path)[DIMENSIONS].to_numpy()
-
-    metrics = train.compute_metrics_for_regression(solution, submission)
-    return np.mean(list(metrics.values()))
-
-def eval_model(model, data_loader, device, n_examples):
-    model = model.eval()
-    predictions = []
-
-    with torch.no_grad():
-        for d in data_loader:
-            input_ids = d['input_ids'].to(device)
-            attention_mask = d['attention_mask'].to(device)
-
-            outputs = model(input_ids=input_ids, attention_mask=attention_mask)
-            predictions.extend(outputs.cpu().numpy())
-
-    return predictions
-
-if __name__ == "__main__":
-    reload(train)
-    tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
-    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-    model = train.EssayScoreRegressor(n_outputs=len(DIMENSIONS))
-    model.load_state_dict(torch.load('model.bin'))
-    model = model.to(device)
-
-    test_data = pd.read_csv('test.csv')
-    test_dataset = EssayDataset(
-        texts=test_data['full_text'].to_numpy(),
-        targets=np.zeros((len(test_data), len(DIMENSIONS))),  # Dummy targets
-        tokenizer=tokenizer,
-        max_len=160
-    )
-
-    test_data_loader = DataLoader(
-        test_dataset,
-        batch_size=16,
-        shuffle=False
-    )
-
-    predictions = eval_model(
-        model,
-        test_data_loader,
-        device,
-        len(test_dataset)
-    )
-
-    submission = pd.DataFrame(predictions, columns=DIMENSIONS)
-    submission['text_id'] = test_data['text_id']
-    submission.to_csv(os.path.join("../env", 'submission.csv'), index=False)
-
-    print(get_score())
-
-"""
-
-
-# Example data structure
-example_data = {
-    1: {
-        "title": "Dataset and Baseline for Automatic Student Feedback Analysis",
-        "abstract": "This paper presents a student feedback corpus containing 3000 instances of feedback written by university students. The dataset has been annotated for aspect terms, opinion terms, polarities of the opinion terms towards targeted aspects, document-level opinion polarities, and sentence separations. A hierarchical taxonomy for aspect categorization covering all areas of the teaching-learning process was developed. Both implicit and explicit aspects were annotated using this taxonomy. The paper discusses the annotation methodology, difficulties faced during the annotation, and details about aspect term categorization. The annotated corpus can be used for Aspect Extraction, Aspect Level Sentiment Analysis, and Document Level Sentiment Analysis. Baseline results for all three tasks are provided.",
-        "research_tasks": "The primary research tasks include the creation of a comprehensive student feedback corpus, aspect term annotation, opinion polarity annotation, and the development of a hierarchical taxonomy.",
-        "research_gaps": "Gaps include the lack of detailed aspect-level annotations in existing datasets and the focus on document-level sentiment analysis.",
-        "keywords": "Student Feedback Corpus, Aspect Terms, Opinion Terms, Polarity, Hierarchical Taxonomy, Aspect Extraction, Aspect Level Sentiment Analysis, Document Level Sentiment Analysis",
-        "recent_works": [
-            "Students feedback analysis model using deep learning-based method and linguistic knowledge for intelligent educational systems.",
-            "An Automated Approach for Analysing Students Feedback Using Sentiment Analysis Techniques."
-        ]
-    },
-    2: {
-        "title": "An Empirical Study on the Impact of Code Review on Software Quality",
-        "abstract": "This paper presents an empirical study examining the impact of code reviews on the quality of software projects. The study involved analyzing over 500,000 code reviews across 20 open-source projects on GitHub. The analysis was conducted to assess the relationship between code review practices and key software quality metrics, such as defect density, code churn, and the frequency of post-release defects. The findings suggest that code reviews, particularly when conducted by experienced reviewers, significantly reduce the number of defects in the codebase. The paper discusses the methodology used for data collection, the statistical methods employed for analysis, and the implications of these findings for software development practices.",
-        "research_tasks": "The primary research tasks include collecting and analyzing data on code reviews from open-source projects, measuring software quality metrics, and assessing the correlation between code review practices and software quality.",
-        "research_gaps": "Gaps include the lack of large-scale empirical studies that quantify the impact of code reviews on software quality and the limited focus on the role of reviewer expertise in existing literature.",
-        "keywords": "Code Reviews, Software Quality, Defect Density, Code Churn, Post-Release Defects, Empirical Study, Open-Source Projects, GitHub",
-        "recent_works": [
-            "The Effectiveness of Code Reviews in Identifying Defects: A Meta-Analysis of Empirical Studies",
-            "A Study on the Impact of Code Review Tools on Developer Productivity and Software Quality"
-        ]
-    }
-}
-
-
 predefined_observation = """
 Epoch [1/10],
 Train MSE: 0.543,
@@ -585,14 +176,6 @@ def info_to_message(info):
     return msg
 
 
-index_ex = 1
-# Function to handle the selection of an example and populate the respective fields
-def load_example(example_id):
-    global index_ex 
-    index_ex = example_id
-    example = example_data[example_id]
-    paper_text = 'Title:\t' +  example['title'] + '\nAbstract:\t' + example['abstract']
-    return paper_text
 
 # Gradio Interface
 with gr.Blocks() as app:
@@ -604,7 +187,7 @@ with gr.Blocks() as app:
     hypothesis_state = gr.State("")
     experiment_plan_state = gr.State("")
 
-    # Phase 1: Research Idea Generation Tab
+    ########## Phase 1:  Research Idea Generation Tab ##############
     with gr.Tab("Phase 1: Research Idea Generation"):
         gr.Markdown("### Extract Research Elements and Generate Research Ideas")
         
@@ -623,9 +206,24 @@ with gr.Blocks() as app:
                 with gr.Group():
                     gr.Markdown("### Research Idea")
                     with gr.Row():
-                        hypothesis_output = gr.Textbox(label="Generated Hypothesis", lines=45, interactive=False)
-                        experiment_plan_output = gr.Textbox(label="Generated Experiment Plan", lines=45, interactive=False)
+                        hypothesis_output = gr.Textbox(label="Generated Hypothesis", lines=20, interactive=False)
+                        experiment_plan_output = gr.Textbox(label="Generated Experiment Plan", lines=20, interactive=False)
+
+        with gr.Row():
+            example_1_button = gr.Button("Load Example 1: " + example_data["1"]["title"])
+            example_2_button = gr.Button("Load Example 2: " + example_data["2"]["title"])
+       
+        # Pre-step: load example         
+        example_1_button.click(
+            fn=lambda: load_example(1), 
+            outputs=[paper_text_input]
+        )
         
+        example_2_button.click(
+            fn=lambda: load_example(2), 
+            outputs=[paper_text_input]
+        )
+    
         # Step 1: Extract Research Elements
         extract_button.click(
             fn=extract_research_elements, 
@@ -633,34 +231,16 @@ with gr.Blocks() as app:
             outputs=[tasks_output, gaps_output, keywords_output, recent_works_output]
         )
 
-        # Step 2: Generate Research Hypothesis and Experiment Plan
-        def generate_and_store(tasks, gaps, keywords, recent_works):
-            hypothesis, experiment_plan = generate_research_idea_and_plan(tasks, gaps, keywords, recent_works)
-            return hypothesis, experiment_plan, hypothesis, experiment_plan
-
         generate_button.click(
             fn=generate_and_store, 
             inputs=[tasks_output, gaps_output, keywords_output, recent_works_output], 
             outputs=[hypothesis_output, experiment_plan_output, hypothesis_state, experiment_plan_state]
         )
 
-        # Example Buttons
-        with gr.Row():
-            example_1_button = gr.Button("Load Example 1:")
-            example_2_button = gr.Button("Load Example 2:")
-        
-        example_1_button.click(
-            fn=lambda: load_example(1), 
-            outputs=[paper_text_input]
-        )
-        
-        example_2_button.click(
-            fn=lambda: load_example(2), 
-            outputs=[paper_text_input]
-        )
 
-    # Phase 2: Interactive Session Tab
-    with gr.Tab("Phase 2&3: Experiment implementation and execution"):
+
+    ########## Phase 2 & 3:  Experiment implementation and execution ##############
+    with gr.Tab("Phase 2 & Phase 3: Experiment implementation and execution"):
         gr.Markdown("### Interact with the ExperimentAgent")
 
         with gr.Row():
@@ -669,7 +249,7 @@ with gr.Blocks() as app:
                 plan_input = gr.Textbox(label="Experiment Plan", lines=30, interactive=False)
         
             with gr.Column():
-                execute_button = gr.Button("Start ExperimentAgent", elem_classes=["execute-btn"])
+                start_exp_agnet = gr.Button("Start ExperimentAgent", elem_classes=["agent-btn"])
                 with gr.Group():
                     gr.Markdown("### Implementation + Execution Log")    
                     log = gr.Textbox(label="Execution Log", lines=20, interactive=False)
@@ -680,42 +260,15 @@ with gr.Blocks() as app:
                 feedback = gr.Textbox(placeholder="N/A", label="User Feedback", lines=3, interactive=True)
                 submit_button = gr.Button("Submit", elem_classes=["Submit-btn"])
         
-        def submit_feedback(user_feedback, history, previous_response):
-            global step_index
-            if_end = False
-            step_index += 1
-            msg = history
-            if step_index < len(process_steps):
-                msg += previous_response + "\nUser feedback:" + user_feedback + "\n\n"
-                response_info = process_steps[step_index]
-                response = info_to_message(response_info)  # Convert dictionary to formatted string
-                response += "Please provide feedback based on the history, response entries, and observation, and questions: "
-                step_index += 1
-                msg += response
-            else:
-                if_end = True
-                response = "Agent Finished."
-                
-
-            return msg, response, predefined_code if if_end else final_code
-
-        def load_phase_2_inputs(hypothesis, plan):
-            return hypothesis, plan, "# Code implementation will be displayed here after Start ExperimentAgent."
-        
-        # Function to implement and execute with the research agent
-        def implement_and_execute(hypothesis, plan):
-            predefined_message = f"Implement the following hypothesis and experiment plan:\n\nHypothesis:\n{hypothesis}\n\nExperiment Plan:\n{plan}"
-            return predefined_code, predefined_action_log
-
         hypothesis_state.change(
             fn=load_phase_2_inputs, 
             inputs=[hypothesis_state, experiment_plan_state], 
             outputs=[idea_input, plan_input, code_display]
         )
         
-        # Trigger the research agent execution with the predefined hypothesis and plan
-        execute_button.click(
-            fn=implement_and_execute, 
+        # Start research agent
+        start_exp_agnet.click(
+            fn=start_experiment_agent, 
             inputs=[hypothesis_state, experiment_plan_state], 
             outputs=[code_display, log]
         )