obj_long_eval.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Objective Evaluations - Scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from scipy.stats import f_oneway"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>strategy</th>\n",
       "      <th>topic</th>\n",
       "      <th>corpus</th>\n",
       "      <th>method</th>\n",
       "      <th>participant</th>\n",
       "      <th>score</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>AN</td>\n",
       "      <td>AN_O</td>\n",
       "      <td>O</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>AN</td>\n",
       "      <td>AN_O</td>\n",
       "      <td>O</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>AN</td>\n",
       "      <td>AN_O</td>\n",
       "      <td>O</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>AN</td>\n",
       "      <td>AN_O</td>\n",
       "      <td>O</td>\n",
       "      <td>0</td>\n",
       "      <td>7</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>AN</td>\n",
       "      <td>AN_O</td>\n",
       "      <td>O</td>\n",
       "      <td>1</td>\n",
       "      <td>8</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  strategy topic corpus  method  participant  score\n",
       "0       AN  AN_O      O       0            3      4\n",
       "1       AN  AN_O      O       1            2      3\n",
       "2       AN  AN_O      O       0            1      3\n",
       "3       AN  AN_O      O       0            7      4\n",
       "4       AN  AN_O      O       1            8      3"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "resp_data = pd.read_csv('questionnaire\\\\long_term\\\\response_summary_long.csv')\n",
    "resp_data.head(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mix-up"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean and Standard Deviation of 'score' by 'method':\n",
      "            mean       std\n",
      "method                    \n",
      "0       2.688889  1.077288\n",
      "1       2.477778  1.072933\n",
      "\n",
      "ANOVA Test Result:\n",
      "F-value: 1.7351082788788674\n",
      "p-value: 0.18945295658338845\n"
     ]
    }
   ],
   "source": [
    "# Group by 'method' and compute mean and std of 'score'\n",
    "grouped_data = resp_data.groupby('method')['score'].agg(['mean', 'std'])\n",
    "\n",
    "# Perform ANOVA test\n",
    "anova_result = f_oneway(*[group['score'] for name, group in resp_data.groupby('method')])\n",
    "\n",
    "# Print the mean and std of 'score' for each 'method'\n",
    "print(\"Mean and Standard Deviation of 'score' by 'method':\")\n",
    "print(grouped_data)\n",
    "\n",
    "# Print the ANOVA test result\n",
    "print(\"\\nANOVA Test Result:\")\n",
    "print(\"F-value:\", anova_result.statistic)\n",
    "print(\"p-value:\", anova_result.pvalue)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Add strategy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import scipy.stats as stats\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plotting\n",
    "plt.figure(figsize=(10, 6))\n",
    "sns.barplot(x='strategy', y='score', hue='method', data=resp_data, palette='viridis')\n",
    "\n",
    "# Set plot title and labels\n",
    "plt.title('Scores by Strategy and Method')\n",
    "plt.xlabel('Strategy')\n",
    "plt.ylabel('Score')\n",
    "\n",
    "# Display the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Shirley's Method\n",
    "\n",
    "for each participant {\n",
    "    baseline_score_g = mean(method==0, G);\n",
    "    baseline_score_o = mean(method==0, O);\n",
    "    for each passage whose method == 1 {\n",
    "        do pair t-test between the score (compare the score and the corresponding baseline, decided by G or O)\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Add overall recall and theme recall\n",
    "\n",
    "recall: overall recall\n",
    "\n",
    "theme: the question 6\n",
    "\n",
    "overall: the total score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from scipy.stats import ttest_rel\n",
    "\n",
    "# Step 1: Load the data and split by method\n",
    "df = pd.read_csv('/Users/fukexue/film_learning_study3/final score with all data.csv')\n",
    "\n",
    "# Split into two dataframes based on method\n",
    "df_method_0 = df[df['method'] == 0]\n",
    "df_method_1 = df[df['method'] == 1]\n",
    "\n",
    "# Function to compute baseline scores\n",
    "def compute_baseline(df_method_0, column_name):\n",
    "    baseline_scores = df_method_0.groupby(['participant', 'corpus'])[column_name].mean().reset_index()\n",
    "    baseline_scores.rename(columns={column_name: f'baseline_{column_name}'}, inplace=True)\n",
    "    return baseline_scores\n",
    "\n",
    "# Compute baseline scores for 'score', 'recall', and 'theme'\n",
    "baseline_withcues = compute_baseline(df_method_0, 'withcues')\n",
    "baseline_withoutcues = compute_baseline(df_method_0, 'withoutcues')\n",
    "\n",
    "\n",
    "# Merge the baseline scores with method==1 dataframe\n",
    "df_method_1_merged = pd.merge(df_method_1, baseline_withcues, on=['participant', 'corpus'])\n",
    "df_method_1_merged = pd.merge(df_method_1_merged, baseline_withoutcues, on=['participant', 'corpus'])\n",
    "\n",
    "\n",
    "# Function to perform t-test and print results\n",
    "def perform_t_test(df_method_1_merged, column_name):\n",
    "    t_stat, p_value = ttest_rel(df_method_1_merged[column_name], df_method_1_merged[f'baseline_{column_name}'])\n",
    "    average_score_method_0 = df_method_0[column_name].mean()\n",
    "    average_score_method_1 = df_method_1_merged[column_name].mean()\n",
    "    print(f\"Average {column_name} for method 0:\", average_score_method_0)\n",
    "    print(f\"Average {column_name} for method 1:\", average_score_method_1)\n",
    "    print(f\"T-statistic for {column_name}:\", t_stat)\n",
    "    print(f\"P-value for {column_name}:\", p_value)\n",
    "    print('\\n')\n",
    "\n",
    "# Perform t-tests for 'score', 'recall', and 'theme'\n",
    "for column in ['withcues', 'withoutcues']:\n",
    "    perform_t_test(df_method_1_merged, column)\n",
    "\n",
    "# Save the merged dataframe with baseline columns to a single CSV file\n",
    "df_method_1_merged.to_csv('questionnaire/long_term/t-test_results.csv', index=False)\n",
    "\n",
    "\n",
    "\n",
    "# Initialize a list to store the results\n",
    "results = []\n",
    "\n",
    "# Function to perform t-test and store results\n",
    "def perform_t_test_by_corpus(df_method_1_merged, column_name):\n",
    "    grouped = df_method_1_merged.groupby('corpus')\n",
    "    for corpus_name, group in grouped:\n",
    "        t_stat, p_value = ttest_rel(group[column_name], group[f'baseline_{column_name}'])\n",
    "        average_score_method_0 = df_method_0[df_method_0['corpus'] == corpus_name][column_name].mean()\n",
    "        average_score_method_1 = group[column_name].mean()\n",
    "        \n",
    "        # Store the results in the list\n",
    "        results.append({\n",
    "            'corpus': corpus_name,\n",
    "            'metric': column_name,\n",
    "            'average_method_0': average_score_method_0,\n",
    "            'average_method_1': average_score_method_1,\n",
    "            't_statistic': t_stat,\n",
    "            'p_value': p_value\n",
    "        })\n",
    "\n",
    "# Perform t-tests for 'score', 'recall', 'theme', and 'overall' grouped by corpus\n",
    "for column in ['withcues', ' withoutcues']:\n",
    "    perform_t_test_by_corpus(df_method_1_merged, column)\n",
    "\n",
    "# Convert the results list to a DataFrame\n",
    "results_df = pd.DataFrame(results)\n",
    "\n",
    "# Output the results DataFrame\n",
    "print(results_df)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualization and P value calculation for each strategy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy.stats as stats\n",
    "import json\n",
    "\n",
    "# Load the uploaded CSV data\n",
    "file_path = 'questionnaire/long_term/response_summary_long.csv'\n",
    "data = pd.read_csv(file_path)\n",
    "\n",
    "# Extract unique strategies\n",
    "strategies = data['strategy'].unique()\n",
    "\n",
    "# Initialize dictionary to store results\n",
    "results = {}\n",
    "\n",
    "# Iterate over each strategy and column of interest\n",
    "for strategy in strategies:\n",
    "    strategy_data = data[data['strategy'] == strategy]\n",
    "    results[strategy] = {}\n",
    "    \n",
    "    for column in ['score', 'recall', 'theme', 'overall']:\n",
    "        results[strategy][column] = {}\n",
    "        \n",
    "        # Prepare data for ANOVA\n",
    "        method_groups = [strategy_data[strategy_data['method'] == method][column].values for method in strategy_data['method'].unique()]\n",
    "        \n",
    "        # Perform one-way ANOVA\n",
    "        f_stat, p_value = stats.f_oneway(*method_groups)\n",
    "        \n",
    "        # Store results in dictionary\n",
    "        results[strategy][column] = {\n",
    "            'f_stat': f_stat,\n",
    "            'p_value': p_value\n",
    "        }\n",
    "        \n",
    "        # Plotting for each column\n",
    "        fig, ax = plt.subplots(figsize=(12, 6))\n",
    "        boxplot_data = method_groups\n",
    "        labels = [f'Method {method}' for method in strategy_data['method'].unique()]\n",
    "        \n",
    "        ax.boxplot(boxplot_data, labels=labels, patch_artist=True)\n",
    "        plt.xlabel('Method')\n",
    "        plt.ylabel(column.capitalize())\n",
    "        plt.title(f'{column.capitalize()} Comparison within {strategy} (ANOVA)')\n",
    "        plt.xticks(rotation=45)\n",
    "        plt.tight_layout()\n",
    "        plt.show()\n",
    "\n",
    "# Optionally, save the results to a JSON file\n",
    "output_file = '../questionnaire/long_term/strategy_comparison_anova_results.json'\n",
    "with open(output_file, 'w') as json_file:\n",
    "    json.dump(results, json_file, indent=4)\n",
    "\n",
    "# Print the results dictionary for review\n",
    "print(json.dumps(results, indent=4))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Final data： To test repeated measure anova with strategy "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x1200 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\n",
      "    \"withoutcues\": {\n",
      "        \"AN\": {\n",
      "            \"anova_table\": \"               Anova\\n====================================\\n       F Value Num DF  Den DF Pr > F\\n------------------------------------\\nmethod  0.7742 1.0000 15.0000 0.3928\\n====================================\\n\"\n",
      "        },\n",
      "        \"EE\": {\n",
      "            \"anova_table\": \"               Anova\\n====================================\\n       F Value Num DF  Den DF Pr > F\\n------------------------------------\\nmethod  1.2058 1.0000 15.0000 0.2895\\n====================================\\n\"\n",
      "        },\n",
      "        \"IL\": {\n",
      "            \"anova_table\": \"               Anova\\n====================================\\n       F Value Num DF  Den DF Pr > F\\n------------------------------------\\nmethod  0.3750 1.0000 15.0000 0.5495\\n====================================\\n\"\n",
      "        },\n",
      "        \"LC\": {\n",
      "            \"anova_table\": \"               Anova\\n====================================\\n       F Value Num DF  Den DF Pr > F\\n------------------------------------\\nmethod  9.7758 1.0000 15.0000 0.0069\\n====================================\\n\"\n",
      "        },\n",
      "        \"RQ\": {\n",
      "            \"anova_table\": \"               Anova\\n====================================\\n       F Value Num DF  Den DF Pr > F\\n------------------------------------\\nmethod  0.2582 1.0000 15.0000 0.6188\\n====================================\\n\"\n",
      "        },\n",
      "        \"TP\": {\n",
      "            \"anova_table\": \"               Anova\\n====================================\\n       F Value Num DF  Den DF Pr > F\\n------------------------------------\\nmethod  6.4819 1.0000 15.0000 0.0224\\n====================================\\n\"\n",
      "        }\n",
      "    },\n",
      "    \"withcues\": {\n",
      "        \"AN\": {\n",
      "            \"anova_table\": \"               Anova\\n====================================\\n       F Value Num DF  Den DF Pr > F\\n------------------------------------\\nmethod  1.2605 1.0000 15.0000 0.2792\\n====================================\\n\"\n",
      "        },\n",
      "        \"EE\": {\n",
      "            \"anova_table\": \"               Anova\\n====================================\\n       F Value Num DF  Den DF Pr > F\\n------------------------------------\\nmethod  0.0154 1.0000 15.0000 0.9029\\n====================================\\n\"\n",
      "        },\n",
      "        \"IL\": {\n",
      "            \"anova_table\": \"               Anova\\n====================================\\n       F Value Num DF  Den DF Pr > F\\n------------------------------------\\nmethod  0.9441 1.0000 15.0000 0.3466\\n====================================\\n\"\n",
      "        },\n",
      "        \"LC\": {\n",
      "            \"anova_table\": \"               Anova\\n====================================\\n       F Value Num DF  Den DF Pr > F\\n------------------------------------\\nmethod  0.3678 1.0000 15.0000 0.5532\\n====================================\\n\"\n",
      "        },\n",
      "        \"RQ\": {\n",
      "            \"anova_table\": \"               Anova\\n====================================\\n       F Value Num DF  Den DF Pr > F\\n------------------------------------\\nmethod  0.0400 1.0000 15.0000 0.8442\\n====================================\\n\"\n",
      "        },\n",
      "        \"TP\": {\n",
      "            \"anova_table\": \"               Anova\\n====================================\\n       F Value Num DF  Den DF Pr > F\\n------------------------------------\\nmethod  0.1261 1.0000 15.0000 0.7275\\n====================================\\n\"\n",
      "        }\n",
      "    }\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import statsmodels.api as sm\n",
    "from statsmodels.stats.anova import AnovaRM\n",
    "import json\n",
    "\n",
    "# Load the uploaded CSV data\n",
    "file_path = 'final score with all data.csv'\n",
    "data = pd.read_csv(file_path)\n",
    "\n",
    "# Extract unique strategies\n",
    "strategies = data['strategy'].unique()\n",
    "\n",
    "# Initialize dictionary to store ANOVA results and means of method 0 and method 1\n",
    "results = {}\n",
    "\n",
    "# Prepare subplots for combined visualization\n",
    "fig, axs = plt.subplots(2, 1, figsize=(16, 12))\n",
    "columns = ['withoutcues', 'withcues']\n",
    "axes = axs.flatten()\n",
    "\n",
    "# Iterate over each column of interest\n",
    "for i, column in enumerate(columns):\n",
    "    results[column] = {}\n",
    "    \n",
    "    # Prepare data for plotting and analysis\n",
    "    combined_data = []\n",
    "    labels = []\n",
    "\n",
    "    for strategy in strategies:\n",
    "        strategy_data = data[data['strategy'] == strategy]\n",
    "        \n",
    "        # Reformat the data for ANOVA\n",
    "        long_format_data = pd.melt(strategy_data, id_vars=['participant', 'strategy', 'method'], value_vars=[column],\n",
    "                                  var_name='variable', value_name='value')\n",
    "\n",
    "        # Perform Repeated Measures ANOVA\n",
    "        model = AnovaRM(long_format_data, 'value', 'participant', within=['method'])\n",
    "        results[column][strategy] = model.fit()\n",
    "        \n",
    "        # Prepare data for boxplot\n",
    "        combined_data.append(strategy_data[strategy_data['method'] == 0][column].values)\n",
    "        combined_data.append(strategy_data[strategy_data['method'] == 1][column].values)\n",
    "        labels.append(f'{strategy} (Method 0)')\n",
    "        labels.append(f'{strategy} (Method 1)')\n",
    "    \n",
    "    # Plotting combined boxplot for each column\n",
    "    axes[i].boxplot(combined_data, labels=labels, patch_artist=True)\n",
    "    axes[i].set_title(f'{column.capitalize()} across all Strategies')\n",
    "    axes[i].set_xlabel('Strategy and Method')\n",
    "    axes[i].set_ylabel(column.capitalize())\n",
    "    axes[i].tick_params(axis='x', rotation=45)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "# Display the combined results dictionary with means and ANOVA results\n",
    "anova_results = {}\n",
    "for column, strategy_results in results.items():\n",
    "    anova_results[column] = {}\n",
    "    for strategy, result in strategy_results.items():\n",
    "        anova_results[column][strategy] = {\n",
    "            'anova_table': result.summary().as_text()\n",
    "        }\n",
    "\n",
    "print(json.dumps(anova_results, indent=4))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# final data To test repeated measure(one way) anova on each material "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import statsmodels.api as sm\n",
    "import json\n",
    "\n",
    "# Load the uploaded CSV data\n",
    "file_path = 'final score with all data.csv'\n",
    "data = pd.read_csv(file_path)\n",
    "\n",
    "# Extract unique topics\n",
    "topics = data['topic'].unique()\n",
    "\n",
    "# Initialize dictionary to store ANOVA results and p-values\n",
    "results = {}\n",
    "\n",
    "# Prepare subplots for combined visualization\n",
    "fig, axs = plt.subplots(2, 1, figsize=(18, 12))\n",
    "columns = ['withoutcues', 'withcues']\n",
    "axes = axs.flatten()\n",
    "\n",
    "# Iterate over each dimension (column)\n",
    "for i, column in enumerate(columns):\n",
    "    all_combined_data = []\n",
    "    all_labels = []\n",
    "    \n",
    "    # Initialize results for this column\n",
    "    if column not in results:\n",
    "        results[column] = {}\n",
    "    \n",
    "    for topic in topics:\n",
    "        topic_data = data[data['topic'] == topic]\n",
    "        \n",
    "        # Perform One-Way ANOVA without considering participant\n",
    "        try:\n",
    "            model = sm.formula.ols(f'{column} ~ C(method)', data=topic_data).fit()\n",
    "            anova_table = sm.stats.anova_lm(model, typ=2)\n",
    "            p_value = anova_table['PR(>F)']['C(method)']\n",
    "            results[column][topic] = {\n",
    "                'anova_table': anova_table.to_string(),\n",
    "                'p_value': p_value\n",
    "            }\n",
    "        except Exception as e:\n",
    "            results[column][topic] = {\n",
    "                'anova_table': str(e),\n",
    "                'p_value': 'nan'\n",
    "            }\n",
    "\n",
    "        # Prepare data for plotting\n",
    "        method_0_data = topic_data[topic_data['method'] == 0][column].values\n",
    "        method_1_data = topic_data[topic_data['method'] == 1][column].values\n",
    "        \n",
    "        all_combined_data.append(method_0_data)\n",
    "        all_combined_data.append(method_1_data)\n",
    "        all_labels.append(f'{topic} Method 0')\n",
    "        all_labels.append(f'{topic} Method 1')\n",
    "    \n",
    "    # Plotting combined boxplot for each column\n",
    "    axes[i].boxplot(all_combined_data, labels=all_labels, patch_artist=True)\n",
    "    axes[i].set_title(f'{column.capitalize()} Across Topics')\n",
    "    axes[i].set_xlabel('Topic and Method')\n",
    "    axes[i].set_ylabel(column.capitalize())\n",
    "    axes[i].tick_params(axis='x', rotation=45)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "# Output the results with p-values\n",
    "results_json = json.dumps(results, indent=4)\n",
    "\n",
    "# Extract and print p-values for each topic\n",
    "for column in columns:\n",
    "    print(f\"\\nP-values for '{column}':\")\n",
    "    if column in results:\n",
    "        for topic in topics:\n",
    "            p_value = results[column].get(topic, {}).get('p_value', 'nan')\n",
    "            print(f\"{topic}: {p_value}\")\n",
    "\n",
    "# Print the full results JSON\n",
    "results_json\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Topic‘s influence "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import statsmodels.api as sm\n",
    "from statsmodels.formula.api import ols\n",
    "from statsmodels.stats.multicomp import pairwise_tukeyhsd\n",
    "\n",
    "# 假设数据已加载\n",
    "file_path = 'questionnaire/long_term/response_summary_long.csv'  # 替换为您的文件路径\n",
    "data = pd.read_csv(file_path)\n",
    "\n",
    "# 要分析的四个维度\n",
    "dimensions = ['score', 'recall', 'theme', 'overall']\n",
    "\n",
    "# 循环分析每个维度\n",
    "for dimension in dimensions:\n",
    "    print(f\"\\nAnalysis for {dimension}:\")\n",
    "\n",
    "    # 创建线性回归模型，评估 topic 的影响\n",
    "    model = ols(f'{dimension} ~ topic', data=data).fit()\n",
    "    \n",
    "    # 生成 ANOVA 表\n",
    "    anova_table = sm.stats.anova_lm(model, typ=2)\n",
    "    print(f\"ANOVA results for {dimension}:\")\n",
    "    print(anova_table)\n",
    "\n",
    "    # 执行 Tukey HSD 测试，进一步分析 topic 的影响\n",
    "    print(f\"\\nTukey HSD results for {dimension}:\")\n",
    "    tukey = pairwise_tukeyhsd(endog=data[dimension], groups=data['topic'], alpha=0.05)\n",
    "    print(tukey)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# method=0 or method=1' tukey"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import statsmodels.api as sm\n",
    "from statsmodels.formula.api import ols\n",
    "from statsmodels.stats.anova import anova_lm\n",
    "from statsmodels.stats.multicomp import pairwise_tukeyhsd\n",
    "\n",
    "# 加载数据\n",
    "file_path = 'questionnaire/long_term/response_summary_long.csv'  # 替换为您的文件路径\n",
    "data = pd.read_csv(file_path)\n",
    "\n",
    "# 要分析的四个维度\n",
    "dimensions = ['score', 'recall', 'theme', 'overall']\n",
    "\n",
    "# 分别针对 method=0 和 method=1 进行分析\n",
    "methods = [0, 1]\n",
    "\n",
    "for method in methods:\n",
    "    print(f\"\\nANOVA and Tukey HSD analysis for method={method}:\")\n",
    "\n",
    "    # 过滤数据只保留当前 method 的情况\n",
    "    method_data = data[data['method'] == method]\n",
    "    \n",
    "    for dimension in dimensions:\n",
    "        print(f\"\\nAnalyzing {dimension} (Method = {method}):\")\n",
    "        \n",
    "        # ANOVA 分析\n",
    "        model = ols(f'{dimension} ~ C(topic)', data=method_data).fit()\n",
    "        anova_table = anova_lm(model, typ=2)\n",
    "        print(\"ANOVA results:\")\n",
    "        print(anova_table)\n",
    "        \n",
    "        # 提取p值\n",
    "        p_value = anova_table[\"PR(>F)\"][0]\n",
    "        print(f\"p-value: {p_value:.4f}\")\n",
    "        \n",
    "        # 如果 ANOVA 结果显示 topic 的影响显著（p值小于0.05），进行 Tukey HSD 分析\n",
    "        if p_value < 0.05:\n",
    "            print(f\"\\nTukey HSD results for {dimension} (Method = {method}):\")\n",
    "            tukey = pairwise_tukeyhsd(endog=method_data[dimension], groups=method_data['topic'], alpha=0.05)\n",
    "            print(tukey.summary())\n",
    "        else:\n",
    "            print(f\"No significant effect of topic on {dimension} (Method = {method}). Skipping Tukey HSD analysis.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Short term results "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from scipy.stats import ttest_rel\n",
    "\n",
    "# Step 1: Load the data and split by method\n",
    "df = pd.read_csv('questionnaire/short_term/response_summary.csv')  # Replace with your CSV file path\n",
    "\n",
    "# Split into two dataframes based on method\n",
    "df_method_0 = df[df['method'] == 0]\n",
    "df_method_1 = df[df['method'] == 1]\n",
    "\n",
    "# Function to compute baseline scores\n",
    "def compute_baseline(df_method_0, column_name):\n",
    "    baseline_scores = df_method_0.groupby(['participant', 'corpus'])[column_name].mean().reset_index()\n",
    "    baseline_scores.rename(columns={column_name: f'baseline_{column_name}'}, inplace=True)\n",
    "    return baseline_scores\n",
    "\n",
    "# List of columns to perform t-tests on\n",
    "columns_to_test = [\n",
    "    'score', 'competence', 'activity', 'frustration', 'pleasure', 'pressure', \n",
    "    'effort', 'immersion', 'physicality', 'difficulty', 'familarity', 'understanding'\n",
    "]\n",
    "\n",
    "# Initialize a list to store the results\n",
    "results = []\n",
    "\n",
    "# Function to perform t-test and store results by corpus\n",
    "def perform_t_test_by_corpus(df_method_1_merged, column_name):\n",
    "    grouped = df_method_1_merged.groupby('corpus')\n",
    "    for corpus_name, group in grouped:\n",
    "        t_stat, p_value = ttest_rel(group[column_name], group[f'baseline_{column_name}'])\n",
    "        average_score_method_0 = df_method_0[df_method_0['corpus'] == corpus_name][column_name].mean()\n",
    "        average_score_method_1 = group[column_name].mean()\n",
    "        \n",
    "        # Store the results in the list\n",
    "        results.append({\n",
    "            'corpus': corpus_name,\n",
    "            'metric': column_name,\n",
    "            'average_method_0': average_score_method_0,\n",
    "            'average_method_1': average_score_method_1,\n",
    "            't_statistic': t_stat,\n",
    "            'p_value': p_value\n",
    "        })\n",
    "\n",
    "# Perform t-tests for each column grouped by corpus\n",
    "for column in columns_to_test:\n",
    "    # Compute baseline scores for the current column\n",
    "    baseline_score = compute_baseline(df_method_0, column)\n",
    "    \n",
    "    # Merge the baseline scores with method==1 dataframe\n",
    "    df_method_1_merged = pd.merge(df_method_1, baseline_score, on=['participant', 'corpus'])\n",
    "    \n",
    "    # Perform t-test for the current column grouped by corpus\n",
    "    perform_t_test_by_corpus(df_method_1_merged, column)\n",
    "\n",
    "# Convert the results list to a DataFrame\n",
    "results_df = pd.DataFrame(results)\n",
    "\n",
    "# Output the results DataFrame\n",
    "print(results_df)\n",
    "\n",
    "# Optionally, save the results to a CSV file\n",
    "results_df.to_csv('questionnaire/short_term/t-test_results_all_columns.csv', index=False)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy.stats as stats\n",
    "import json\n",
    "\n",
    "# 读取CSV数据到DataFrame\n",
    "data = pd.read_csv('questionnaire/short_term/t-test_results.csv')\n",
    "\n",
    "# 提取感兴趣的列\n",
    "columns_of_interest = [\n",
    "   'score', 'competence', 'activity', 'frustration', 'pleasure', 'pressure', \n",
    "    'effort', 'immersion', 'physicality', 'difficulty', 'familarity', 'understanding'\n",
    "]\n",
    "\n",
    "# 提取各策略的唯一值\n",
    "strategies = data['strategy'].unique()\n",
    "results = {}\n",
    "\n",
    "# 对每个感兴趣的列进行迭代\n",
    "for column in columns_of_interest:\n",
    "    boxplot_data = []\n",
    "    labels = []\n",
    "    results[column] = {}\n",
    "    \n",
    "    for strategy in strategies:\n",
    "        strategy_data = data[data['strategy'] == strategy]\n",
    "        \n",
    "        # 提取基准数据和策略数据\n",
    "        baseline_data = strategy_data['baseline_' + column].values\n",
    "        strategy_data_values = strategy_data[column].values\n",
    "        \n",
    "        # 计算均值\n",
    "        baseline_mean = baseline_data.mean()\n",
    "        strategy_mean = strategy_data_values.mean()\n",
    "        \n",
    "        # 进行配对t检验以获得p值\n",
    "        t_stat, p_value = stats.ttest_rel(baseline_data, strategy_data_values)\n",
    "        \n",
    "        # 将结果存储到字典中\n",
    "        results[column][strategy] = {\n",
    "            'baseline_mean': baseline_mean,\n",
    "            'strategy_mean': strategy_mean,\n",
    "            'p_value': p_value\n",
    "        }\n",
    "        \n",
    "        # 为箱线图准备数据\n",
    "        boxplot_data.append(baseline_data)\n",
    "        boxplot_data.append(strategy_data_values)\n",
    "        labels.append(f'{strategy} baseline')\n",
    "        labels.append(f'{strategy} w/ strategy')\n",
    "    \n",
    "    # 绘图\n",
    "    fig, ax = plt.subplots(figsize=(12, 6))\n",
    "    ax.boxplot(boxplot_data, labels=labels, patch_artist=True)\n",
    "\n",
    "    plt.xlabel('Strategy')\n",
    "    plt.ylabel(column.capitalize())\n",
    "    plt.title(f'{column.capitalize()} of Baseline vs. Strategy')\n",
    "    plt.xticks(rotation=45)\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "\n",
    "# 可选：将结果保存到JSON文件\n",
    "with open('strategy_results.json', 'w') as json_file:\n",
    "    json.dump(results, json_file, indent=4)\n",
    "\n",
    "# 打印结果字典以供查看\n",
    "print(json.dumps(results, indent=4))\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "da",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}