{"metadata":{"kernelspec":{"name":"python3","display_name":"Python 3","language":"python"},"language_info":{"name":"python","version":"3.11.11","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"colab":{"provenance":[]},"kaggle":{"accelerator":"none","dataSources":[{"sourceId":87793,"databundleVersionId":12276181,"sourceType":"competition"}],"dockerImageVersionId":31040,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":false}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"# RNA 3D Structure Prediction using GNN (Starter Script)\nAuthor: Ishita | Competition Starter Kit","metadata":{"id":"82fa181f"}},{"cell_type":"code","source":"","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"![header (9).png](data:image/png;base64,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)","metadata":{"id":"uEfpAssG2NZJ"}},{"cell_type":"code","source":"!pip install kaggle==1.5.12","metadata":{"id":"sBYeaKbV2N0P","outputId":"8233ecee-7d69-43b5-f43e-48d6b980b2b5"},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Task\nTell me about this dataset.\n\nHere is all the data you need:\n\"kaggle (3).json\"","metadata":{"id":"shSdPGPO2vxY"}},{"cell_type":"markdown","source":"## Data loading\n\n### Subtask:\nLoad the dataset \"kaggle (3).json\" into a pandas DataFrame.\n","metadata":{"id":"Rcq6F71A2wTc"}},{"cell_type":"markdown","source":"**Reasoning**:\nLoad the dataset \"kaggle (3).json\" into a pandas DataFrame and display the first 5 rows.\n\n","metadata":{"id":"Uytz25MJ2wyC"}},{"cell_type":"code","source":"import pandas as pd\n\ntry:\n    df = pd.read_json('kaggle (3).json')\n    display(df.head())\nexcept FileNotFoundError:\n    print(\"Error: 'kaggle (3).json' not found. Please ensure the file exists in the current directory.\")\n    df = None  # Set df to None to indicate failure\nexcept Exception as e:\n    print(f\"An error occurred: {e}\")\n    df = None","metadata":{"id":"9YQhh0Gr2xB8","outputId":"8cd93f7c-115f-4806-8401-5ee8636e9682"},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"**Reasoning**:\nThe error message indicates that the JSON file might not be formatted correctly for direct reading with `read_json()`.  I'll try loading it with the `lines=True` parameter, which is often needed for JSON files where each line represents a JSON object.\n\n","metadata":{"id":"BkdQrp5A2yQs"}},{"cell_type":"code","source":"import pandas as pd\n\ntry:\n    df = pd.read_json('kaggle (3).json', lines=True)\n    display(df.head())\nexcept FileNotFoundError:\n    print(\"Error: 'kaggle (3).json' not found. Please ensure the file exists in the current directory.\")\n    df = None\nexcept Exception as e:\n    print(f\"An error occurred: {e}\")\n    df = None","metadata":{"id":"JeM69lks2ygi","outputId":"d49ec477-0743-4f20-d4b8-8e2c2db347a5"},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## Data exploration\n\n### Subtask:\nExplore the loaded dataset to understand its characteristics.\n","metadata":{"id":"Z_ORdQQR21ps"}},{"cell_type":"markdown","source":"**Reasoning**:\nExamine the shape, data types, descriptive statistics, missing values, and distributions of the data.\n\n","metadata":{"id":"yLxIZgGt22QZ"}},{"cell_type":"code","source":"# Examine the shape of the DataFrame\nprint(\"Shape of the DataFrame:\", df.shape)\n\n# Check data types\nprint(\"\\nData Types:\\n\", df.dtypes)\n\n# Descriptive statistics for numerical columns (if any)\nprint(\"\\nDescriptive Statistics:\\n\", df.describe(include='all'))\n\n# Missing values\nprint(\"\\nMissing Values:\")\nprint(df.isnull().sum())\nprint(\"\\nPercentage of Missing Values:\")\nprint(df.isnull().sum() / len(df) * 100)\n\n# Analyze distributions of key variables\nprint(\"\\nValue Counts for 'username':\\n\", df['username'].value_counts())\nprint(\"\\nValue Counts for 'key':\\n\", df['key'].value_counts())\n\n# Unique values and frequencies of categorical columns\nprint(\"\\nUnique values and frequencies for 'username':\")\nprint(df['username'].value_counts())\nprint(\"\\nUnique values and frequencies for 'key':\")\nprint(df['key'].value_counts())","metadata":{"id":"N_YFslPf22iZ","outputId":"c43bd1d8-7376-46d6-91ca-b7854ba19cb7"},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## Data analysis\n\n### Subtask:\nPerform basic statistical analysis on the data.\n","metadata":{"id":"Q9UOK0vO257e"}},{"cell_type":"markdown","source":"**Reasoning**:\nSummarize the unique values and their counts for the 'username' and 'key' columns, and discuss the implications of having only one data point.\n\n","metadata":{"id":"rAdm8LXS26qS"}},{"cell_type":"code","source":"# Summarize unique values and counts\nprint(\"Unique values and counts for 'username':\")\nprint(df['username'].value_counts())\nprint(\"\\nUnique values and counts for 'key':\")\nprint(df['key'].value_counts())\n\nprint(\"\\n\\nImplications of a single data point:\")\nprint(\"With only one data point, meaningful statistical analysis is impossible.  Traditional measures like mean, median, and standard deviation are not applicable to a single value.  Any attempt at modeling or prediction would be highly unreliable, as there's no variation in the data to learn from.  The single data point provides no information about the broader population or distribution.  More data is needed for meaningful analysis.\")","metadata":{"id":"XQbav0uI27Ar","outputId":"699df896-2880-4641-d718-9ba0a840eb58"},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## Data visualization\n\n### Subtask:\nVisualize the single data point present in the dataset.\n","metadata":{"id":"0m3QbYCC2904"}},{"cell_type":"markdown","source":"**Reasoning**:\nCreate a simple bar chart to visualize the single data point, clearly indicating the username and key.\n\n","metadata":{"id":"YL9DwJ5O2-mD"}},{"cell_type":"code","source":"import matplotlib.pyplot as plt\n\n# Create a bar chart\nplt.figure(figsize=(8, 6))  # Adjust figure size for better readability\nplt.bar(['username', 'key'], [1, 1], color=['skyblue', 'lightcoral'])\nplt.title('Visualization of Single Data Point')\nplt.xlabel('Features')\nplt.ylabel('Count')\nplt.ylim(0, 2)  # Set y-axis limits to emphasize the single count\nplt.xticks(['username', 'key'], ['ishitabahamnia', '673d82b99023b67e48877f4cbde5f8be'])\nplt.text(0, 1.1, 'ishitabahamnia', ha='center', va='bottom')\nplt.text(1, 1.1, '673d82b99023b67e48877f4cbde5f8be', ha='center', va='bottom')\nplt.show()","metadata":{"id":"P42kvYwg2-2A","outputId":"99003920-a6f2-479f-d48f-ea6fcf526cd2"},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"\n\n---\n\n","metadata":{"id":"XXSjgblG3FNz"}},{"cell_type":"markdown","source":"# Task\nexecute\n\nHere is all the data you need:\n\"sample_submission (2).csv\"","metadata":{"id":"xg_Uh-le3kWP"}},{"cell_type":"markdown","source":"## Data loading\n\n### Subtask:\nLoad the data from \"sample_submission (2).csv\" into a pandas DataFrame.\n","metadata":{"id":"rmKLQrA13lQV"}},{"cell_type":"markdown","source":"**Reasoning**:\nLoad the data from \"sample_submission (2).csv\" into a pandas DataFrame and display its first few rows and shape.\n\n","metadata":{"id":"01V9oWId3lhj"}},{"cell_type":"code","source":"import pandas as pd\n\ntry:\n    df = pd.read_csv('sample_submission (2).csv')\n    display(df.head())\n    print(df.shape)\nexcept FileNotFoundError:\n    print(\"Error: 'sample_submission (2).csv' not found.\")\nexcept Exception as e:\n    print(f\"An error occurred: {e}\")","metadata":{"id":"Q6KAJgG63lxg","outputId":"84c753ff-ad23-4ae0-a00d-159a0e2afa95"},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## Data exploration\n\n### Subtask:\nExplore the loaded data to understand its structure, including column names, data types, and the presence of missing values. Determine the overall shape and distribution of the data.\n","metadata":{"id":"iMYekR2A3pTc"}},{"cell_type":"markdown","source":"**Reasoning**:\nDisplay the column names, data types, missing values, descriptive statistics, and data distribution of the dataframe `df`.\n\n","metadata":{"id":"sNpbBzYA3p2J"}},{"cell_type":"code","source":"# Display column names\nprint(\"Column Names:\\n\", df.columns)\n\n# Display data types\nprint(\"\\nData Types:\\n\", df.dtypes)\n\n# Check for missing values\nprint(\"\\nMissing Values:\\n\", df.isnull().sum())\n\n# Generate descriptive statistics\nprint(\"\\nDescriptive Statistics:\\n\", df.describe())\n\n# Analyze data distribution\nprint(\"\\nData Info:\\n\")\ndf.info()\n\n# Histograms for numerical columns\ndf.hist(figsize=(15, 10), bins=20)\n\n# Bar plots for categorical columns (if any)\ncategorical_columns = df.select_dtypes(include=['object']).columns\nfor col in categorical_columns:\n    df[col].value_counts().plot(kind='bar', title=f'Distribution of {col}')","metadata":{"id":"cNCvWcBk3qGf","outputId":"da454c56-c206-4224-a157-233a94e45dcd"},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## Data analysis\n\n### Subtask:\nAnalyze the data to identify patterns, trends, or anomalies, focusing on the 'resid' column and the coordinate columns.\n","metadata":{"id":"wrnmLvK13wf5"}},{"cell_type":"markdown","source":"**Reasoning**:\nCalculate summary statistics for the 'resid' column and investigate the relationship between 'resid', 'resname', and coordinate columns.  Since all coordinates are zero, focus on the potential relationship between 'resid' and 'resname'.\n\n","metadata":{"id":"LROB_4qP3xg-"}},{"cell_type":"code","source":"# Calculate summary statistics for 'resid'\nresid_stats = df['resid'].describe()\nprint(\"Summary statistics for 'resid':\\n\", resid_stats)\n\n# Group data by 'resname' and calculate summary statistics\ngrouped_data = df.groupby('resname')['resid'].agg(['min', 'max', 'mean', 'median', 'std'])\nprint(\"\\nSummary statistics for 'resid' grouped by 'resname':\\n\", grouped_data)\n\n# Investigate potential outliers in 'resid'\n# Check for values significantly above or below the mean/median\nprint(\"\\nPotential outliers in 'resid':\")\n# Example:  Values more than 2 standard deviations away from the mean\noutliers = df[(df['resid'] < resid_stats['mean'] - 2 * resid_stats['std']) | (df['resid'] > resid_stats['mean'] + 2 * resid_stats['std'])]\nprint(outliers)\n\n# Analyze the relationship between 'resid' and 'resname'\nprint(\"\\nRelationship between 'resid' and 'resname':\")\n# Example: Count the occurrences of each 'resid' within each 'resname' group\nresid_by_resname = df.groupby('resname')['resid'].value_counts().unstack(fill_value=0)\nprint(resid_by_resname)\n\n# Hypothesis about zero coordinate values\nprint(\"\\nHypothesis about zero coordinate values:\")\nprint(\"All coordinate values being zero suggests missing or invalid coordinate data.  This might be due to an error during data collection or processing, or it could be a placeholder for coordinates that have not yet been determined.\")\nprint(\"Further investigation into the data source and any preprocessing steps is needed to understand the cause of these zero values.\")","metadata":{"id":"ZRv-yKcC3y07","outputId":"df7c391e-03be-4025-cceb-a0430d891661"},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Task\nexecute and store the output in csv file for further test .\n\nHere is all the data you need:\n\"train_labels.v2.csv\"\n\"train_sequences.v2.csv\"\n\"train_sequences.csv\"\n\"train_labels.csv\"","metadata":{"id":"0JcPZ9QE6wQb"}},{"cell_type":"markdown","source":"## Data loading\n\n### Subtask:\nLoad the four provided CSV files into pandas DataFrames.\n","metadata":{"id":"gFNuVENS6wwE"}},{"cell_type":"markdown","source":"**Reasoning**:\nLoad the four CSV files into pandas DataFrames as specified in the instructions.\n\n","metadata":{"id":"9Hq5ecS26xSX"}},{"cell_type":"code","source":"import pandas as pd\n\ntry:\n    df_labels_v2 = pd.read_csv('train_labels.v2.csv')\n    df_sequences_v2 = pd.read_csv('train_sequences.v2.csv')\n    df_sequences = pd.read_csv('train_sequences.csv')\n    df_labels = pd.read_csv('train_labels.csv')\n    print(\"Successfully loaded all CSV files into pandas DataFrames.\")\nexcept FileNotFoundError:\n    print(\"One or more CSV files not found. Please check file paths.\")\nexcept pd.errors.ParserError:\n    print(\"Error parsing one or more CSV files. Please check file format.\")\nexcept Exception as e:\n    print(f\"An unexpected error occurred: {e}\")","metadata":{"id":"wFY2Yp-p6xi4","outputId":"abdeaafa-42a5-45d6-bbdb-51b9321b1068"},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## Data exploration\n\n### Subtask:\nExplore the loaded dataframes to understand their structure, identify potential issues, and prepare for merging.\n","metadata":{"id":"IBOowCXt63Ig"}},{"cell_type":"markdown","source":"**Reasoning**:\nExplore the dataframes to understand their structure, identify potential issues, and prepare for merging. This involves examining the first few rows, shapes, data types, summary statistics, missing values, unique values in key columns, and data distributions.  Also compare the v2 and non-v2 dataframes for inconsistencies.\n\n","metadata":{"id":"-71R2ZG964dE"}},{"cell_type":"code","source":"# Display basic info for each dataframe\ndataframes = [df_labels_v2, df_sequences_v2, df_sequences, df_labels]\ndataframe_names = ['df_labels_v2', 'df_sequences_v2', 'df_sequences', 'df_labels']\n\nfor i, df in enumerate(dataframes):\n    print(f\"--- {dataframe_names[i]} ---\")\n    display(df.head())\n    print(f\"Shape: {df.shape}\")\n    print(f\"Data Types:\\n{df.dtypes}\")\n    print(f\"Summary Statistics:\\n{df.describe(include='all')}\")\n    print(f\"Missing Values:\\n{df.isnull().sum()}\")\n    if 'ID' in df.columns:\n      print(f\"Unique IDs: {df['ID'].nunique()}\")\n    if 'target_id' in df.columns:\n      print(f\"Unique Target IDs: {df['target_id'].nunique()}\")\n    if 'resid' in df.columns:\n        print(f\"Unique Resids: {df['resid'].nunique()}\")\n    print(\"\\n\")\n\n# Compare v2 and non-v2 dataframes\nprint(\"--- Comparing df_labels_v2 and df_labels ---\")\nprint(f\"Number of rows in df_labels_v2: {len(df_labels_v2)}\")\nprint(f\"Number of rows in df_labels: {len(df_labels)}\")\ncommon_ids = set(df_labels_v2['ID']).intersection(set(df_labels['ID']))\nprint(f\"Number of common IDs: {len(common_ids)}\")\n# Find discrepancies in ID values\ndiff_v2 = set(df_labels_v2['ID']) - set(df_labels['ID'])\ndiff = set(df_labels['ID']) - set(df_labels_v2['ID'])\nprint(f\"IDs unique to v2: {len(diff_v2)}\")\nprint(f\"IDs unique to non-v2: {len(diff)}\")\n\n\nprint(\"--- Comparing df_sequences_v2 and df_sequences ---\")\nprint(f\"Number of rows in df_sequences_v2: {len(df_sequences_v2)}\")\nprint(f\"Number of rows in df_sequences: {len(df_sequences)}\")\ncommon_targets = set(df_sequences_v2['target_id']).intersection(set(df_sequences['target_id']))\nprint(f\"Number of common target IDs: {len(common_targets)}\")\ndiff_v2_seq = set(df_sequences_v2['target_id']) - set(df_sequences['target_id'])\ndiff_seq = set(df_sequences['target_id']) - set(df_sequences_v2['target_id'])\nprint(f\"Target IDs unique to v2: {len(diff_v2_seq)}\")\nprint(f\"Target IDs unique to non-v2: {len(diff_seq)}\")","metadata":{"id":"_W2p17fF64s9","outputId":"acf5c1e1-6e3e-4f97-fb74-67a0443d0de9"},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## Data preparation\n\n### Subtask:\nPrepare the dataframes for merging, addressing inconsistencies and missing values.\n","metadata":{"id":"B5xRe40E7CVP"}},{"cell_type":"markdown","source":"**Reasoning**:\nHandle missing values in the coordinate columns and the 'all_sequences' column. Then, address ID and target_id discrepancies by using an inner join, as it will only keep data points present in both datasets. Finally, prepare the join keys by ensuring consistent data types and names.\n\n","metadata":{"id":"HE9kSLwW7DNn"}},{"cell_type":"code","source":"# Impute missing coordinate values with the mean for both df_labels_v2 and df_labels\nfor col in ['x_1', 'y_1', 'z_1']:\n    df_labels_v2[col] = df_labels_v2[col].fillna(df_labels_v2[col].mean())\n    df_labels[col] = df_labels[col].fillna(df_labels[col].mean())\n\n# Impute missing 'all_sequences' values with an empty string for both df_sequences_v2 and df_sequences\ndf_sequences_v2['all_sequences'] = df_sequences_v2['all_sequences'].fillna('')\ndf_sequences['all_sequences'] = df_sequences['all_sequences'].fillna('')\n\n# Inner join df_labels_v2 and df_labels on 'ID'\ndf_labels_merged = pd.merge(df_labels_v2, df_labels, on='ID', how='inner', suffixes=('_v2', '_original'))\n\n# Inner join df_sequences_v2 and df_sequences on 'target_id'\ndf_sequences_merged = pd.merge(df_sequences_v2, df_sequences, on='target_id', how='inner', suffixes=('_v2', '_original'))\n\n# Ensure consistent data types and names for join keys (already consistent)\n","metadata":{"id":"xui5pNUn7Dd-"},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## Data wrangling\n\n### Subtask:\nMerge the prepared dataframes (df_labels_merged and df_sequences_merged) into a single comprehensive dataframe.\n","metadata":{"id":"I2OLYiNq7JDi"}},{"cell_type":"markdown","source":"**Reasoning**:\nMerge `df_labels_merged` and `df_sequences_merged` based on a common identifier, handling potential naming differences.  Then, examine the merged dataframe and drop redundant columns.\n\n","metadata":{"id":"6lf3GPYg7J57"}},{"cell_type":"code","source":"# Identify a common identifier between the two dataframes.\n# 'ID' in df_labels_merged seems to correspond to 'target_id' in df_sequences_merged,\n# but they may have different formats (e.g., suffixes).\n# We will try to extract a common identifier part and merge on that.\n\ndef extract_common_id(id_string):\n    \"\"\"Extracts the common part of the ID.\"\"\"\n    parts = id_string.split('_')\n    return '_'.join(parts[:-1]) if len(parts) > 1 else id_string\n\n# Apply the extraction to both dataframes\ndf_labels_merged['common_id'] = df_labels_merged['ID'].apply(extract_common_id)\ndf_sequences_merged['common_id'] = df_sequences_merged['target_id'].apply(extract_common_id)\n\n# Merge the two dataframes\ndf_merged = pd.merge(df_labels_merged, df_sequences_merged, on='common_id', how='inner')\n\n# Examine the merged dataframe\nprint(f\"Shape of merged dataframe: {df_merged.shape}\")\nprint(f\"Columns of merged dataframe: {df_merged.columns.tolist()}\")\ndisplay(df_merged.head())\n\n# Drop redundant columns\ncolumns_to_drop = ['ID', 'target_id', 'common_id']  # Initial list of columns to drop\n# Add more columns to the list if needed, after inspection\nfor col in df_merged.columns:\n    if '_original' in col:\n        columns_to_drop.append(col)\n\ndf_merged = df_merged.drop(columns=columns_to_drop, errors='ignore')\n\nprint(f\"Shape of merged dataframe after dropping columns: {df_merged.shape}\")\nprint(f\"Columns of merged dataframe after dropping columns: {df_merged.columns.tolist()}\")\ndisplay(df_merged.head())","metadata":{"id":"QDEuQPNm7KKB","outputId":"a80fe078-a42e-47fa-b89e-e81c6b9a6232"},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"**Reasoning**:\nThe previous merge resulted in an empty DataFrame, indicating no matching `common_id` values between `df_labels_merged` and `df_sequences_merged`.  I will try a different approach by merging on 'ID' and 'target_id' directly and inspecting the results before dropping columns.  I will then save the resulting dataframe to a CSV file.\n\n","metadata":{"id":"JweLwXyW7O7u"}},{"cell_type":"code","source":"# Attempt merging directly on 'ID' and 'target_id'\ntry:\n    df_merged = pd.merge(df_labels_merged, df_sequences_merged, left_on='ID', right_on='target_id', how='inner')\n    print(\"Successfully merged dataframes on 'ID' and 'target_id'.\")\nexcept Exception as e:\n    print(f\"An error occurred during the merge: {e}\")\n\nprint(f\"Shape of merged dataframe: {df_merged.shape}\")\nprint(f\"Columns of merged dataframe: {df_merged.columns.tolist()}\")\ndisplay(df_merged.head())\n\n# Save to CSV\ntry:\n    df_merged.to_csv('merged_data.csv', index=False)\n    print(\"Successfully saved merged dataframe to 'merged_data.csv'.\")\nexcept Exception as e:\n    print(f\"An error occurred while saving the file: {e}\")","metadata":{"id":"0YQjk03Z7PL0","outputId":"22f9f7fb-58a8-45f9-c7e9-b57a7f52583c"},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## Data wrangling\n\n### Subtask:\nData Wrangling - Retry 1\n\n#### Instructions\nMerge the prepared dataframes (`df_labels_merged` and `df_sequences_merged`) into a single dataframe.  The previous attempts to merge using 'ID' and 'target_id' directly, or a common substring extracted from these columns, have failed, resulting in an empty dataframe. This retry will investigate alternative merging strategies.\n","metadata":{"id":"xnOdo8Mm7WH3"}},{"cell_type":"markdown","source":"**Reasoning**:\nThe previous attempts to merge the dataframes failed.  I will try to merge based on the observation that the 'ID' column in `df_labels_merged` and the `target_id` column in `df_sequences_merged` seem to share a common prefix, but have different suffixes. I'll extract this prefix and use it as a common key to merge.\n\n","metadata":{"id":"0VjhdcOp7W39"}},{"cell_type":"code","source":"import pandas as pd\n\ndef extract_common_id(id_string):\n    \"\"\"Extracts the common part of the ID.\"\"\"\n    parts = id_string.split('_')\n    if len(parts) > 1:\n        return '_'.join(parts[:-1])\n    else:\n        return id_string\n\n# Apply the extraction to both dataframes\ndf_labels_merged['common_id'] = df_labels_merged['ID'].apply(extract_common_id)\ndf_sequences_merged['common_id'] = df_sequences_merged['target_id'].apply(extract_common_id)\n\n\n# Merge the two dataframes using the common_id\ndf_merged = pd.merge(df_labels_merged, df_sequences_merged, on='common_id', how='inner')\n\n# Drop redundant columns\ncolumns_to_drop = ['common_id']\nfor col in df_merged.columns:\n    if '_original' in col or '_y' in col:\n        columns_to_drop.append(col)\ndf_merged = df_merged.drop(columns=columns_to_drop, errors='ignore')\n\n# Display the head and summary statistics of the merged dataframe\ndisplay(df_merged.head())\nprint(df_merged.describe(include='all'))\nprint(f\"Unique IDs in merged dataframe: {df_merged['ID'].nunique()}\")\nprint(f\"Unique target_ids in merged dataframe: {df_merged['target_id'].nunique()}\")","metadata":{"id":"kdDNwpM-7XIP","outputId":"29ec1ffb-2fac-4e2c-8842-ef6245de392c"},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Task\nTell me about this dataset.\n\nHere is all the data you need:\n\"train_sequences.v2.csv\"","metadata":{"id":"DPWlN_O0FBA0"}},{"cell_type":"markdown","source":"## Data loading\n\n### Subtask:\nLoad the dataset \"train_sequences.v2.csv\" into a pandas DataFrame.\n","metadata":{"id":"8AB4CT8UFBuT"}},{"cell_type":"markdown","source":"**Reasoning**:\nLoad the dataset \"train_sequences.v2.csv\" into a pandas DataFrame and display the first 5 rows.\n\n","metadata":{"id":"ovhmKX6KFCFk"}},{"cell_type":"code","source":"import pandas as pd\ntry:\n    df = pd.read_csv('train_sequences.v2.csv')\n    display(df.head())\nexcept FileNotFoundError:\n    print(\"Error: 'train_sequences.v2.csv' not found.\")\n    df = None\nexcept Exception as e:\n    print(f\"An unexpected error occurred: {e}\")\n    df = None","metadata":{"id":"HQz7XGZHFCk5","outputId":"48162311-7662-42d1-8793-750a14c95146"},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## Data exploration\n\n### Subtask:\nExplore the loaded dataset to understand its structure and characteristics.\n","metadata":{"id":"Q1ph0FmUFGGO"}},{"cell_type":"markdown","source":"**Reasoning**:\nExamine the shape, data types, descriptive statistics, unique values, missing values, and first/last few rows of the DataFrame to understand its structure and characteristics.\n\n","metadata":{"id":"c5S_buyPFG1M"}},{"cell_type":"markdown","source":"**Reasoning**:\nThe previous code block failed due to a `ValueError: No objects to concatenate` when trying to calculate descriptive statistics for numerical columns. This error suggests that there are no numerical columns in the DataFrame.  I will remove the attempt to describe numerical columns and proceed with the rest of the exploration.\n\n","metadata":{"id":"gy42n3EJFIlJ"}},{"cell_type":"code","source":"# Examine the shape of the DataFrame\nprint(\"Shape of the DataFrame:\", df.shape)\n\n# Investigate data types and missing values\nprint(\"\\nData Types and Missing Values:\")\nprint(df.info())\n\n# Explore non-numerical columns\nfor col in ['sequence', 'description', 'all_sequences', 'target_id', 'temporal_cutoff']:\n    print(f\"\\nColumn: {col}\")\n    print(\"Number of unique values:\", df[col].nunique())\n    print(\"Value counts:\")\n    print(df[col].value_counts().head())\n    if df[col].dtype == 'object':  # Check if the column contains strings\n        print(\"Example lengths of strings:\")\n        print(df[col].str.len().head())\n\n# Check for missing values\nprint(\"\\nMissing Values:\")\nprint(df.isnull().sum())\nprint(\"\\nPercentage of Missing Values:\")\nprint((df.isnull().sum() / len(df)) * 100)\n\n\n# Examine the first and last few rows\nprint(\"\\nFirst few rows:\")\ndisplay(df.head())\nprint(\"\\nLast few rows:\")\ndisplay(df.tail())","metadata":{"id":"15TCbhZcFI7a","outputId":"cc930aa4-26fc-42a1-86e8-d0fd58076320"},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## Data analysis\n\n### Subtask:\nAnalyze the distribution of key variables and identify potential patterns or outliers in the 'sequence', 'description', and 'all_sequences' columns.\n","metadata":{"id":"7AYr0H_fFPlJ"}},{"cell_type":"markdown","source":"**Reasoning**:\nAnalyze the length distribution of sequences in the 'sequence' column, investigate the 'description' column for recurring patterns, analyze the 'all_sequences' column focusing on the number of sequences, and explore potential relationships between these columns.\n\n","metadata":{"id":"uP7BOeP9FQlk"}},{"cell_type":"code","source":"import matplotlib.pyplot as plt\n# Sequence length analysis\ndf['sequence_length'] = df['sequence'].str.len()\nprint(\"Sequence Length Statistics:\")\nprint(df['sequence_length'].describe())\nplt.figure(figsize=(10, 6))\nplt.hist(df['sequence_length'], bins=50)\nplt.xlabel(\"Sequence Length\")\nplt.ylabel(\"Frequency\")\nplt.title(\"Distribution of Sequence Lengths\")\nplt.show()\n\n# Description analysis (example: word frequency)\nfrom collections import Counter\ndescription_words = \" \".join(df['description']).lower().split()\nword_counts = Counter(description_words)\nprint(\"\\nMost Common Words in Descriptions:\")\nprint(word_counts.most_common(10))\n\n# 'all_sequences' analysis\ndf['num_sequences'] = df['all_sequences'].str.count('>')\nprint(\"\\nNumber of Sequences Statistics:\")\nprint(df['num_sequences'].describe())\n\nplt.figure(figsize=(10, 6))\nplt.hist(df['num_sequences'], bins=50)\nplt.xlabel(\"Number of Sequences\")\nplt.ylabel(\"Frequency\")\nplt.title(\"Distribution of Number of Sequences\")\nplt.show()\n\n# Relationship exploration\nplt.figure(figsize=(10, 6))\nplt.scatter(df['sequence_length'], df['num_sequences'], alpha=0.5)\nplt.xlabel(\"Sequence Length\")\nplt.ylabel(\"Number of Sequences\")\nplt.title(\"Relationship between Sequence Length and Number of Sequences\")\nplt.show()\n\n# Temporal cutoff analysis\nprint(\"\\nTemporal Cutoff Value Counts:\")\nprint(df['temporal_cutoff'].value_counts().head(10))","metadata":{"id":"yGSqTHwWFQ1x","outputId":"1ffdc332-ffa1-48f4-873b-f509ae3f3df2"},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## Data visualization\n\n### Subtask:\nVisualize the distributions and relationships identified in the data analysis step.\n","metadata":{"id":"xqjKXB39FVhS"}},{"cell_type":"markdown","source":"**Reasoning**:\nCreate a combined plot with subplots for the distributions and relationships identified in the data analysis.\n\n","metadata":{"id":"9Flp65kvFXB-"}},{"cell_type":"code","source":"import matplotlib.pyplot as plt\n\nplt.figure(figsize=(20, 15))\n\n# Subplot 1: Histogram of sequence lengths\nplt.subplot(3, 2, 1)\nplt.hist(df['sequence_length'], bins=50, color='skyblue', edgecolor='black')\nplt.xlabel(\"Sequence Length\")\nplt.ylabel(\"Frequency\")\nplt.yscale('log') # Use log scale for better visualization if needed.\nplt.title(\"Distribution of Sequence Lengths\")\n\n\n# Subplot 2: Bar chart of top 10 most frequent words\nplt.subplot(3, 2, 2)\nfrom collections import Counter\ndescription_words = \" \".join(df['description']).lower().split()\nword_counts = Counter(description_words)\ntop_10_words = word_counts.most_common(10)\nwords, frequencies = zip(*top_10_words)\nplt.bar(words, frequencies, color='lightcoral')\nplt.xlabel(\"Words\")\nplt.ylabel(\"Frequency\")\nplt.title(\"Top 10 Most Frequent Words in Descriptions\")\nplt.xticks(rotation=45, ha='right')\n\n\n# Subplot 3: Histogram of number of sequences\nplt.subplot(3, 2, 3)\nplt.hist(df['num_sequences'], bins=50, color='lightgreen', edgecolor='black')\nplt.xlabel(\"Number of Sequences\")\nplt.ylabel(\"Frequency\")\nplt.yscale('log') # Use log scale if needed.\nplt.title(\"Distribution of Number of Sequences\")\n\n\n# Subplot 4: Scatter plot of sequence length vs. number of sequences\nplt.subplot(3, 2, 4)\nplt.scatter(df['sequence_length'], df['num_sequences'], alpha=0.5, color='orange')\nplt.xlabel(\"Sequence Length\")\nplt.ylabel(\"Number of Sequences\")\nplt.title(\"Relationship between Sequence Length and Number of Sequences\")\n\n\n# Subplot 5: Bar chart of top 10 most frequent temporal cutoffs\nplt.subplot(3, 2, 5)\ntop_10_temporal_cutoffs = df['temporal_cutoff'].value_counts().head(10)\nplt.bar(top_10_temporal_cutoffs.index, top_10_temporal_cutoffs.values, color='lightblue')\nplt.xlabel(\"Temporal Cutoff\")\nplt.ylabel(\"Frequency\")\nplt.title(\"Top 10 Most Frequent Temporal Cutoffs\")\nplt.xticks(rotation=45, ha='right')\n\n\nplt.tight_layout()  # Adjust subplot parameters for a tight layout\nplt.suptitle(\"Data Visualization: Distributions and Relationships\", fontsize=16)\nplt.show()","metadata":{"id":"-SlNlPMQFXT9","outputId":"e4467a09-ce58-4c60-b98e-649cd75bc1e6"},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Task\nTell me about this dataset.\n\nHere is all the data you need:\n\"validation_sequences.csv\"\n\"validation_labels.csv\"","metadata":{"id":"SCCM4bn8Fzza"}},{"cell_type":"markdown","source":"## Data loading\n\n### Subtask:\nLoad the validation data.\n","metadata":{"id":"s-0TWE4DF0dI"}},{"cell_type":"markdown","source":"**Reasoning**:\nLoad the validation data into pandas DataFrames and display the first 5 rows of each.\n\n","metadata":{"id":"v6vH7JP9F0s9"}},{"cell_type":"code","source":"import pandas as pd\n\ntry:\n    df_sequences = pd.read_csv('validation_sequences.csv')\n    df_labels = pd.read_csv('validation_labels.csv')\n    display(df_sequences.head())\n    display(df_labels.head())\nexcept FileNotFoundError:\n    print(\"Error: One or both of the CSV files were not found.\")\nexcept pd.errors.ParserError:\n    print(\"Error: There was an issue parsing the CSV file(s).  Check the file format.\")\nexcept Exception as e:\n    print(f\"An unexpected error occurred: {e}\")","metadata":{"id":"Ec0ezuZVF0-R","outputId":"7064cf74-9f1b-4b3b-e09f-2535cdc9f5fa"},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## Data exploration\n\n### Subtask:\nExplore the `validation_sequences.csv` dataframe.\n","metadata":{"id":"yTFFJBZDF5cL"}},{"cell_type":"markdown","source":"**Reasoning**:\nExplore the `validation_sequences.csv` dataframe by examining its shape, data types, descriptive statistics, missing values, unique values in 'target_id', sequence length distribution, 'temporal_cutoff' column, 'description' column, and summarize the findings.\n\n","metadata":{"id":"Z-2ANFifF6cc"}},{"cell_type":"markdown","source":"**Reasoning**:\nThe previous code block failed due to a `ValueError: No objects to concatenate` when calculating descriptive statistics. This likely happened because `df_sequences.describe(include='number')` didn't find any numerical columns.  I need to re-examine the dataframe and make sure numerical columns are present or create new numerical ones before running the describe() function.  I also need to correct other parts of the code where there were errors.\n\n","metadata":{"id":"yQDtMggOF9Vs"}},{"cell_type":"code","source":"# Examine the shape of the DataFrame\nprint(\"Shape of df_sequences:\", df_sequences.shape)\n\n# Investigate data types\nprint(\"\\nData types of df_sequences columns:\\n\", df_sequences.dtypes)\n\n# Create a numerical column (sequence length) if it doesn't exist\nif 'sequence_length' not in df_sequences.columns:\n    df_sequences['sequence_length'] = df_sequences['sequence'].str.len()\n\n# Descriptive statistics for numerical columns\nprint(\"\\nDescriptive statistics of numerical columns:\\n\", df_sequences.describe(include='number'))\n\n# Check for missing values\nprint(\"\\nMissing values in df_sequences:\\n\", df_sequences.isnull().sum())\n\n# Analyze unique values in 'target_id'\nprint(\"\\nNumber of unique target IDs:\", df_sequences['target_id'].nunique())\nprint(\"Number of total target IDs:\", len(df_sequences['target_id']))\nprint(\"\\nFirst few unique target IDs:\\n\", df_sequences['target_id'].unique()[:5])\n\n# Examine sequence length distribution (already calculated above)\nprint(\"\\nSequence length distribution:\\n\", df_sequences['sequence_length'].describe())\n\n# Explore 'temporal_cutoff' column\nprint(\"\\nTemporal cutoff distribution:\\n\", df_sequences['temporal_cutoff'].describe())\nprint(\"\\nFirst few temporal cutoffs:\\n\", df_sequences['temporal_cutoff'].unique()[:5])\n\n# Briefly examine 'description' column\nprint(\"\\nFirst few descriptions:\\n\", df_sequences['description'].unique()[:5])\n\n# Summarize findings\nprint(\"\\nSummary of Findings:\")\nprint(\"1. Shape: The DataFrame has\", df_sequences.shape[0], \"rows and\", df_sequences.shape[1], \"columns.\")\nprint(\"2. Data Types: Note the data types of each column.  'temporal_cutoff' might need to be converted to datetime.\")\nprint(\"3. Descriptive Statistics: Provided for numerical columns, including sequence length.\")\nprint(\"4. Missing Values: Report the number of missing values for each column.\")\nprint(\"5. 'target_id': Compare the number of unique target IDs to the total number of IDs to check for duplicates.\")\nprint(\"6. Sequence Length: Observe the min, max, mean, and standard deviation of sequence lengths.\")\nprint(\"7. Temporal Cutoff: Analyze the distribution and format of temporal information.\")\nprint(\"8. Description: Inspect the first few descriptions for potential patterns or keywords.\")","metadata":{"id":"-vpbxD2RF9oz","outputId":"ca00fe9e-0691-4471-f0a8-b8f28f03a804"},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## Data exploration\n\n### Subtask:\nExplore the `validation_labels.csv` dataframe.\n","metadata":{"id":"iAkl8v0YGBv7"}},{"cell_type":"markdown","source":"**Reasoning**:\nI need to explore the `df_labels` dataframe, as instructed in the subtask. This involves examining its shape, data types, descriptive statistics for numerical columns (especially coordinates), missing values, unique values in the 'ID' column, and the relationship between 'ID' and 'target_id' in `df_sequences`.  I also need to explore the `resname` and `resid` columns.\n\n","metadata":{"id":"7wLMX4uKGCxg"}},{"cell_type":"code","source":"# Examine the shape of the DataFrame\nprint(\"Shape of df_labels:\", df_labels.shape)\n\n# Investigate data types\nprint(\"\\nData types of df_labels columns:\\n\", df_labels.dtypes)\n\n# Descriptive statistics for numerical columns (coordinates)\ncoordinate_columns = [col for col in df_labels.columns if col.startswith(('x_', 'y_', 'z_'))]\nprint(\"\\nDescriptive statistics of coordinate columns:\\n\", df_labels[coordinate_columns].describe())\n\n# Check for missing values\nprint(\"\\nMissing values in df_labels:\\n\", df_labels.isnull().sum())\n\n# Analyze unique values in 'ID' and compare with 'target_id'\nunique_ids_labels = df_labels['ID'].nunique()\nprint(f\"\\nNumber of unique IDs in df_labels: {unique_ids_labels}\")\nunique_ids_sequences = df_sequences['target_id'].nunique()\nprint(f\"Number of unique target_ids in df_sequences: {unique_ids_sequences}\")\n\nids_in_labels_not_in_sequences = set(df_labels['ID']) - set(df_sequences['target_id'])\nprint(f\"\\nIDs in df_labels but not in df_sequences: {ids_in_labels_not_in_sequences}\")\n\nids_in_sequences_not_in_labels = set(df_sequences['target_id']) - set(df_labels['ID'])\nprint(f\"\\nIDs in df_sequences but not in df_labels: {ids_in_sequences_not_in_labels}\")\n\n# Explore 'resname' and 'resid' columns\nprint(\"\\nNumber of unique resnames:\", df_labels['resname'].nunique())\nprint(\"Unique resnames:\", df_labels['resname'].unique())\nprint(\"\\nNumber of unique resids:\", df_labels['resid'].nunique())\nprint(\"Descriptive statistics for resid:\", df_labels['resid'].describe())","metadata":{"id":"ni1PmHXAGDBY","outputId":"a7a3eb15-6a32-4935-f70b-6362bb4c16b8"},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"**Reasoning**:\nThe previous code block output shows that there are many IDs in `df_labels` that are not present in `df_sequences`.  I need to investigate this further and summarize all the findings.\n\n","metadata":{"id":"rfgsd2FkGEvw"}},{"cell_type":"code","source":"# Summarize findings\nprint(\"\\nSummary of Findings:\")\nprint(\"1. Shape: The DataFrame has\", df_labels.shape[0], \"rows and\", df_labels.shape[1], \"columns.\")\nprint(\"2. Data Types: The coordinate columns ('x_1', 'y_1', 'z_1', etc.) are of type float64, which is expected. Other columns include 'ID' (object), 'resname' (object), and 'resid' (int64).\")\nprint(\"3. Descriptive Statistics: The descriptive statistics for the coordinate columns reveal a wide range of values.  There are many extremely large negative values and some reasonable positive values.  This suggests that there may be missing values encoded as a specific negative value.  There are also some suspiciously large standard deviations.\")\nprint(\"4. Missing Values: There are no explicitly missing values (NaN) in the DataFrame.\")\nprint(\"5. 'ID' Analysis: There are 2515 unique IDs in df_labels.  However, there are only 12 unique `target_id` values in df_sequences.\")\nprint(\"   There are a large number of IDs in df_labels that do not exist in df_sequences.  This suggests a significant inconsistency between the two dataframes.\")\nprint(\"6. 'resname' and 'resid': There are\", df_labels['resname'].nunique(), \"unique residue names. The distribution of 'resid' suggests there are many observations for each residue ID.\")\n\n#Inconsistencies\nprint(\"\\nInconsistencies and potential issues:\")\nprint(\"The most significant issue is the mismatch between the 'ID' column in df_labels and the 'target_id' column in df_sequences.  A substantial number of IDs in df_labels do not have corresponding entries in df_sequences. This needs to be investigated further to understand the relationship between the two files and how to proceed with the analysis.\")\nprint(\"The coordinate data also presents an issue with many extremely large negative values.  It is unclear what these represent, but they may indicate missing data or errors in the data collection process.\")","metadata":{"id":"JfUvA5m7GFBv","outputId":"f6812f09-b62e-4af6-bb98-f0b276c5fc94"},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## Data analysis\n\n### Subtask:\nAnalyze the relationship between `df_sequences` and `df_labels` DataFrames, focusing on the identified inconsistencies.\n","metadata":{"id":"P9QvZCQ6GI33"}},{"cell_type":"markdown","source":"**Reasoning**:\nAnalyze the relationship between `df_sequences` and `df_labels` DataFrames, focusing on the identified inconsistencies, by examining shared identifiers, unique IDs, coordinate data distribution, and potential merging strategies.\n\n","metadata":{"id":"VuwNyXaMGJ50"}},{"cell_type":"code","source":"# 1. Relationship between 'ID' and 'target_id'\nshared_ids = set(df_labels['ID']).intersection(set(df_sequences['target_id']))\nnum_shared = len(shared_ids)\nunique_ids_labels = df_labels['ID'].nunique()\nunique_ids_sequences = df_sequences['target_id'].nunique()\n\nprint(f\"Number of shared IDs: {num_shared}\")\nprint(f\"Number of unique IDs in df_labels: {unique_ids_labels}\")\nprint(f\"Number of unique IDs in df_sequences: {unique_ids_sequences}\")\n\n# 2. Coordinate data analysis\ncoordinate_columns = [col for col in df_labels.columns if col.startswith(('x_', 'y_', 'z_'))]\n# Exclude extremely large negative values (likely representing missing data)\nfiltered_df = df_labels[df_labels[coordinate_columns] > -1e10]\n\n# Calculate descriptive statistics for the filtered coordinate data.\ncoordinate_stats = filtered_df[coordinate_columns].describe()\nprint(\"\\nDescriptive statistics of coordinate columns (excluding large negative values):\\n\", coordinate_stats)\n\n# 3. & 4. Exploring potential strategies and alternative keys\n# Given the significant mismatch between 'ID' and 'target_id', a direct merge is not feasible.\n# Explore other columns for potential relationships. The 'ID' column in df_labels has a suffix.\n# Let's try to extract the common part of the 'ID' column in df_labels and compare it to 'target_id'.\ndf_labels['base_id'] = df_labels['ID'].str.split('_').str[0]\nshared_base_ids = set(df_labels['base_id']).intersection(set(df_sequences['target_id']))\nnum_shared_base_ids = len(shared_base_ids)\nprint(f\"\\nNumber of shared base IDs: {num_shared_base_ids}\")\n\n# Check if there is any other potential key in df_labels and df_sequences\nprint(f\"\\nColumns in df_labels: {df_labels.columns.tolist()}\")\nprint(f\"Columns in df_sequences: {df_sequences.columns.tolist()}\")\n\n#Summarize the findings\nprint(\"\\nSummary:\")\nprint(f\"There are {num_shared} IDs shared between the two dataframes, which is very low.\")\nprint(f\"There are {num_shared_base_ids} base IDs shared between the two dataframes.\")\nprint(\"The coordinate data shows a large number of extremely large negative values, likely indicating missing values.\")\nprint(\"Descriptive statistics of the coordinate data excluding these values are shown above.\")\nprint(\"No other obvious relationships between the dataframes were found.\")\n","metadata":{"id":"C90zL_zyGKKN","outputId":"3536cc0c-82bc-4ae7-bd54-5f07c8a52e50"},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## Data visualization\n\n### Subtask:\nVisualize the distribution of labels and sequence lengths.\n","metadata":{"id":"BUQibEzLGOWy"}},{"cell_type":"markdown","source":"**Reasoning**:\nCreate the visualizations as requested in the subtask.\n\n","metadata":{"id":"RTAn2lSWGPH7"}},{"cell_type":"code","source":"import matplotlib.pyplot as plt\n\n# 1. Histogram of sequence lengths\nplt.figure(figsize=(10, 6))\nplt.hist(df_sequences['sequence_length'], bins=20, color='skyblue', edgecolor='black')\nplt.title('Distribution of Sequence Lengths')\nplt.xlabel('Sequence Length')\nplt.ylabel('Frequency')\nplt.show()\n\n# 2. Bar chart of base_id counts\nbase_id_counts = df_labels['base_id'].value_counts()\nplt.figure(figsize=(10, 6))\nplt.bar(base_id_counts.index, base_id_counts.values, color='salmon')\nplt.title('Number of Entries per Base ID in df_labels')\nplt.xlabel('Base ID')\nplt.ylabel('Count')\nplt.xticks(rotation=45, ha='right')  # Rotate x-axis labels for readability\nplt.tight_layout()\nplt.show()\n\n\n# 3. Scatter plot of sequence length vs. label count per target_id\ntarget_id_counts = df_labels.groupby('base_id').size().reset_index(name='count')\nmerged_df = pd.merge(df_sequences, target_id_counts, left_on='target_id', right_on='base_id', how='left')\n\nplt.figure(figsize=(10, 6))\nplt.scatter(merged_df['sequence_length'], merged_df['count'], color='mediumseagreen')\nplt.title('Sequence Length vs. Number of Corresponding Entries in df_labels')\nplt.xlabel('Sequence Length')\nplt.ylabel('Count of Entries')\nplt.show()","metadata":{"id":"-SsmMhS0GPZ0","outputId":"ff0ebfde-dc11-4c11-a798-ab00d9bb6b5e"},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Task\nTell me about this dataset.\n\nHere is all the data you need:\n\"test_sequences.csv\"","metadata":{"id":"rGqyBc3QIwjt"}},{"cell_type":"markdown","source":"## Data loading\n\n### Subtask:\nLoad the data from \"test_sequences.csv\" into a pandas DataFrame.\n","metadata":{"id":"dnTXFMxFIxPB"}},{"cell_type":"markdown","source":"**Reasoning**:\nLoad the data from \"test_sequences.csv\" into a pandas DataFrame and display the first 5 rows.\n\n","metadata":{"id":"V5WNYuURIxl2"}},{"cell_type":"code","source":"import pandas as pd\n\ntry:\n    df = pd.read_csv('test_sequences.csv')\n    display(df.head())\nexcept FileNotFoundError:\n    print(\"Error: 'test_sequences.csv' not found.\")\n    df = None\nexcept pd.errors.ParserError:\n    print(\"Error: Could not parse the CSV file. Please check its format.\")\n    df = None\nexcept Exception as e:\n    print(f\"An unexpected error occurred: {e}\")\n    df = None","metadata":{"id":"RqVnA7ReIyE7","outputId":"517af8c6-2716-4d9b-8325-059eb07bffdc"},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## Data exploration\n\n### Subtask:\nExplore the loaded data to understand its characteristics.\n","metadata":{"id":"5PfynzBvI2VV"}},{"cell_type":"markdown","source":"**Reasoning**:\nI need to explore the data, including shape, data types, descriptive statistics, missing values, and unique values in relevant columns.  This will give an overview of the dataset's characteristics.\n\n","metadata":{"id":"bBrYktoGI3EL"}},{"cell_type":"markdown","source":"**Reasoning**:\nThe previous code block failed due to a `ValueError: No objects to concatenate` when calling `df.describe(include='number')`. This likely indicates that there are no numerical columns in the DataFrame. I'll remove the `df.describe()` call and the code that relies on it. I will also modify the loop for the non-numerical columns to handle potential KeyError if the column doesn't exist.\n\n","metadata":{"id":"TvKsrSxFI5W4"}},{"cell_type":"code","source":"# Examine the shape of the DataFrame.\nprint(\"Shape of the DataFrame:\", df.shape)\n\n# Determine the data types of each column.\nprint(\"\\nData types of each column:\\n\", df.dtypes)\n\n# Check for missing values.\nprint(\"\\nMissing values per column:\\n\", df.isnull().sum())\nprint(\"\\nPercentage of missing values per column:\\n\", (df.isnull().sum() / len(df)) * 100)\n\n# Explore non-numerical columns.\nfor col in ['sequence', 'description', 'all_sequences', 'target_id', 'temporal_cutoff']:\n    if col in df.columns:\n        print(f\"\\nAnalysis for column '{col}':\")\n        print(\"Number of unique values:\", df[col].nunique())\n        print(\"Most frequent value:\", df[col].mode()[0] if not df[col].mode().empty else \"No mode\")\n        print(\"Frequency of the most frequent value:\", df[col].value_counts().max() if not df[col].value_counts().empty else 0)","metadata":{"id":"H7fEAGmEI5mr","outputId":"78943922-1159-4f42-9e1d-fab957a720c8"},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## Data analysis\n\n### Subtask:\nAnalyze the distribution of key variables and identify potential patterns or outliers in the 'test_sequences.csv' dataset.  Focus on the 'sequence', 'description', and 'all_sequences' columns.\n","metadata":{"id":"tdBw-0x8I-EV"}},{"cell_type":"markdown","source":"**Reasoning**:\nAnalyze the frequency distribution of 'sequence', 'description', and 'all_sequences', investigate the relationship between 'sequence' and 'all_sequences', and explore recurring keywords in 'description'.\n\n","metadata":{"id":"oNdPKl7bJE2r"}},{"cell_type":"code","source":"# Frequency distribution of 'sequence', 'description', and 'all_sequences'\nsequence_counts = df['sequence'].value_counts()\ndescription_counts = df['description'].value_counts()\nall_sequences_counts = df['all_sequences'].value_counts()\n\nprint(\"Sequence Counts:\\n\", sequence_counts)\nprint(\"\\nDescription Counts:\\n\", description_counts)\nprint(\"\\nAll Sequences Counts:\\n\", all_sequences_counts)\n\n# Relationship between 'sequence' and 'all_sequences'\n# Check if any sequences appear in the 'all_sequences' field\nsequence_in_all_sequences = 0\nfor index, row in df.iterrows():\n    if row['sequence'] in row['all_sequences']:\n        sequence_in_all_sequences += 1\n\nprint(\"\\nNumber of times 'sequence' appears in 'all_sequences':\", sequence_in_all_sequences)\n\n# Explore 'description' column for recurring keywords\nfrom collections import Counter\n\n# Combine all descriptions into a single string\nall_descriptions = ' '.join(df['description'].astype(str))\n\n# Tokenize the combined descriptions (split into words)\nwords = all_descriptions.lower().split()\n\n# Count word frequencies\nword_counts = Counter(words)\n\n# Print the 10 most common words\nprint(\"\\n10 Most Common Words in Descriptions:\\n\", word_counts.most_common(10))","metadata":{"id":"WjhFb-UgJFG6","outputId":"71d8c925-fe83-41cc-9455-50165e807d20"},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## Data visualization\n\n### Subtask:\nVisualize the distributions and relationships within the data.\n","metadata":{"id":"4nqoEIbGJJST"}},{"cell_type":"markdown","source":"**Reasoning**:\nCreate the visualizations as specified in the instructions, handling potential overlapping x-axis labels and ensuring clear labels for all charts.\n\n","metadata":{"id":"jxbpRZVsJKXD"}},{"cell_type":"code","source":"import matplotlib.pyplot as plt\n\nplt.figure(figsize=(12, 6))\n\n# 1. Frequency distribution of 'sequence'\nplt.subplot(2, 2, 1)\ndf['sequence'].value_counts().plot(kind='bar', color='skyblue')\nplt.title('Frequency Distribution of Sequence')\nplt.xlabel('Sequence')\nplt.ylabel('Frequency')\nplt.xticks(rotation=45, ha='right')\n\n# 2. Frequency distribution of 'description'\nplt.subplot(2, 2, 2)\ndf['description'].value_counts().plot(kind='bar', color='lightcoral')\nplt.title('Frequency Distribution of Description')\nplt.xlabel('Description')\nplt.ylabel('Frequency')\nplt.xticks(rotation=45, ha='right')\n\n# 3. Frequency distribution of 'all_sequences'\nplt.subplot(2, 2, 3)\ndf['all_sequences'].value_counts().plot(kind='bar', color='lightgreen')\nplt.title('Frequency Distribution of All Sequences')\nplt.xlabel('All Sequences')\nplt.ylabel('Frequency')\nplt.xticks(rotation=45, ha='right')\n\n# 4. Horizontal bar chart of top 10 most common words in 'description'\nfrom collections import Counter\nall_descriptions = ' '.join(df['description'].astype(str))\nwords = all_descriptions.lower().split()\nword_counts = Counter(words)\ntop_10_words = word_counts.most_common(10)\nwords, counts = zip(*top_10_words)\n\nplt.subplot(2, 2, 4)\nplt.barh(words, counts, color='plum')\nplt.title('Top 10 Most Common Words in Descriptions')\nplt.xlabel('Frequency')\nplt.ylabel('Words')\n\nplt.tight_layout()\nplt.show()","metadata":{"id":"8gE7ZvH0JKn9","outputId":"f6311c50-6552-44df-c781-2b10f5b33e1e"},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"**Reasoning**:\nThe previous attempt to create the visualizations resulted in a tight layout warning.  I will try again adjusting the figure size and using `plt.subplots_adjust` to fine-tune the spacing between subplots, which should prevent overlapping labels.\n\n","metadata":{"id":"oxpsXVRMJPv2"}},{"cell_type":"code","source":"import matplotlib.pyplot as plt\n\nplt.figure(figsize=(16, 12))\n\n# 1. Frequency distribution of 'sequence'\nplt.subplot(2, 2, 1)\ndf['sequence'].value_counts().plot(kind='bar', color='skyblue')\nplt.title('Frequency Distribution of Sequence')\nplt.xlabel('Sequence')\nplt.ylabel('Frequency')\nplt.xticks(rotation=45, ha='right')\n\n# 2. Frequency distribution of 'description'\nplt.subplot(2, 2, 2)\ndf['description'].value_counts().plot(kind='bar', color='lightcoral')\nplt.title('Frequency Distribution of Description')\nplt.xlabel('Description')\nplt.ylabel('Frequency')\nplt.xticks(rotation=45, ha='right')\n\n# 3. Frequency distribution of 'all_sequences'\nplt.subplot(2, 2, 3)\ndf['all_sequences'].value_counts().plot(kind='bar', color='lightgreen')\nplt.title('Frequency Distribution of All Sequences')\nplt.xlabel('All Sequences')\nplt.ylabel('Frequency')\nplt.xticks(rotation=45, ha='right')\n\n# 4. Horizontal bar chart of top 10 most common words in 'description'\nfrom collections import Counter\nall_descriptions = ' '.join(df['description'].astype(str))\nwords = all_descriptions.lower().split()\nword_counts = Counter(words)\ntop_10_words = word_counts.most_common(10)\nwords, counts = zip(*top_10_words)\n\nplt.subplot(2, 2, 4)\nplt.barh(words, counts, color='plum')\nplt.title('Top 10 Most Common Words in Descriptions')\nplt.xlabel('Frequency')\nplt.ylabel('Words')\n\nplt.subplots_adjust(hspace=0.5, wspace=0.3) # Adjust spacing\nplt.show()","metadata":{"id":"lsUvuymAJQAP","outputId":"c4f77089-dac2-4e3f-8d98-eddaf80ecb7f"},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import pandas as pd","metadata":{"id":"POY9kVHrKTWB"},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Task\nTell me about this dataset.\n\nHere is all the data you need:\n\"test_sequences.csv\"","metadata":{"id":"ysQhSlqNTEuA"}},{"cell_type":"markdown","source":"## Data loading\n\n### Subtask:\nLoad the data from \"test_sequences.csv\" into a pandas DataFrame.\n","metadata":{"id":"W7lwF0rLTFWM"}},{"cell_type":"markdown","source":"**Reasoning**:\nLoad the data from \"test_sequences.csv\" into a pandas DataFrame and display the first 5 rows.\n\n","metadata":{"id":"ZBGJbX9QTFnM"}},{"cell_type":"code","source":"import pandas as pd\n\ntry:\n    df = pd.read_csv('test_sequences.csv')\n    display(df.head())\nexcept FileNotFoundError:\n    print(\"Error: 'test_sequences.csv' not found.\")\n    df = None\nexcept pd.errors.ParserError:\n    print(\"Error: Could not parse the CSV file. Check file format.\")\n    df = None\nexcept Exception as e:\n    print(f\"An unexpected error occurred: {e}\")\n    df = None","metadata":{"id":"pZl4Sw45TF4Z","outputId":"f315c11f-2a70-4dc6-e6f1-f187806fc1fe"},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## Data exploration\n\n### Subtask:\nExplore the loaded dataset to understand its characteristics.\n","metadata":{"id":"kMq9j61hTKwf"}},{"cell_type":"markdown","source":"**Reasoning**:\nThe previous code block failed due to a `ValueError: No objects to concatenate` when calling `.describe()`. This likely means there are no numerical columns in the DataFrame.  I'll modify the code to handle this error gracefully and continue with the other exploratory steps.\n\n","metadata":{"id":"UHVKpOOXTOCX"}},{"cell_type":"code","source":"# Examine the shape of the DataFrame\nprint(\"Shape of the DataFrame:\", df.shape)\n\n# Determine the data types of each column\nprint(\"\\nData types of each column:\\n\", df.dtypes)\n\n# Generate descriptive statistics for numerical features (handle potential errors)\ntry:\n    print(\"\\nDescriptive statistics for numerical features:\\n\", df.describe(include='number'))\nexcept ValueError as e:\n    print(f\"\\nError generating descriptive statistics for numerical features: {e}\")\n    print(\"This likely means there are no numerical columns in the DataFrame.\")\n\n# Check for missing values\nprint(\"\\nMissing values per column:\\n\", df.isnull().sum())\n\n# Examine the distribution of 'target_id' and 'temporal_cutoff'\nprint(\"\\nUnique 'target_id' values:\", df['target_id'].nunique())\nprint(\"Unique 'temporal_cutoff' values:\", df['temporal_cutoff'].nunique())\nprint(\"\\nFirst few 'temporal_cutoff' values:\\n\", df['temporal_cutoff'].head())\n\n# Analyze unique values and frequencies in the 'description' column\nprint(\"\\nFirst few descriptions:\\n\", df['description'].head())\nprint(\"\\nNumber of unique descriptions:\", df['description'].nunique())\n\n# Examine the 'sequence' column (sequence length and characters)\nprint(\"\\nFirst sequence:\", df['sequence'].iloc[0][:50] + \"...\")  # Display first 50 characters\nsequence_lengths = df['sequence'].str.len()\nprint(\"Min sequence length:\", sequence_lengths.min())\nprint(\"Max sequence length:\", sequence_lengths.max())\nprint(\"Mean sequence length:\", sequence_lengths.mean())\n\n# Analyze the 'all_sequences' column\nprint(\"\\nFirst 'all_sequences' entry:\\n\", df['all_sequences'].iloc[0][:100] + \"...\")","metadata":{"id":"NenT3ugJTOSn","outputId":"18e1469b-0596-4adf-a806-3b3e895ecefb"},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## Data analysis\n\n### Subtask:\nAnalyze the data to gain insights into the relationships between variables and identify potential outliers.\n","metadata":{"id":"8O48p_FkTSOu"}},{"cell_type":"markdown","source":"**Reasoning**:\nCalculate descriptive statistics for sequence lengths, identify outliers using the IQR method, and visualize the distribution using a histogram and a box plot.  Then convert the 'temporal_cutoff' column to datetime objects and explore the relationship between sequence length and 'temporal_cutoff'.\n\n","metadata":{"id":"nW_JITxaTTGr"}},{"cell_type":"code","source":"import pandas as pd\nimport matplotlib.pyplot as plt\nimport numpy as np\nfrom datetime import datetime\n\n# Calculate sequence lengths\nsequence_lengths = df['sequence'].str.len()\n\n# Descriptive statistics\nprint(\"Descriptive statistics for sequence lengths:\")\nprint(sequence_lengths.describe())\n\n# IQR outlier detection\nQ1 = sequence_lengths.quantile(0.25)\nQ3 = sequence_lengths.quantile(0.75)\nIQR = Q3 - Q1\nlower_bound = Q1 - 1.5 * IQR\nupper_bound = Q3 + 1.5 * IQR\noutliers = sequence_lengths[(sequence_lengths < lower_bound) | (sequence_lengths > upper_bound)]\nprint(\"\\nPotential outliers (IQR method):\")\nprint(outliers)\n\n# Visualization\nplt.figure(figsize=(12, 5))\nplt.subplot(1, 2, 1)\nplt.hist(sequence_lengths, bins=20, color='skyblue', edgecolor='black')\nplt.xlabel(\"Sequence Length\")\nplt.ylabel(\"Frequency\")\nplt.title(\"Distribution of Sequence Lengths\")\n\nplt.subplot(1, 2, 2)\nplt.boxplot(sequence_lengths, vert=False, patch_artist=True, boxprops=dict(facecolor='lightcoral'))\nplt.xlabel(\"Sequence Length\")\nplt.title(\"Box Plot of Sequence Lengths\")\nplt.tight_layout()\nplt.show()\n\n\n# Convert 'temporal_cutoff' to datetime objects\ntry:\n    df['temporal_cutoff'] = pd.to_datetime(df['temporal_cutoff'])\nexcept ValueError as e:\n    print(f\"Error converting 'temporal_cutoff' to datetime: {e}\")\n    print(\"Check the format of the 'temporal_cutoff' column.\")\n\n# Numerical representation of temporal_cutoff (days since a reference date)\nreference_date = datetime(2022, 1, 1)\ndf['days_since_reference'] = (df['temporal_cutoff'] - reference_date).dt.days\n\n# Scatter plot of sequence length vs. days_since_reference\nplt.figure(figsize=(8, 6))\nplt.scatter(df['days_since_reference'], sequence_lengths, color='green', alpha=0.7)\nplt.xlabel(\"Days Since Reference Date (2022-01-01)\")\nplt.ylabel(\"Sequence Length\")\nplt.title(\"Sequence Length vs. Temporal Cutoff\")\nplt.grid(True)\nplt.show()","metadata":{"id":"4Kmdb1zQTTWs","outputId":"b782c803-9e6c-4b1f-d913-c2b10cf7b584"},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"**Reasoning**:\nAnalyze the text data in the 'description' column by investigating the most frequent words and phrases.  Then explore relationships between the identified themes and other variables.\n\n","metadata":{"id":"UL4FM5T5TWZj"}},{"cell_type":"code","source":"import pandas as pd\nimport matplotlib.pyplot as plt\nfrom collections import Counter\nfrom wordcloud import WordCloud\n\n# Combine all descriptions into a single string\ntext = ' '.join(df['description'].astype(str))\n\n# Tokenize the text and remove punctuation\nwords = [word.lower() for word in text.split() if word.isalnum()]\n\n# Count word frequencies\nword_counts = Counter(words)\n\n# Display the 10 most common words\nprint(\"10 Most Common Words:\")\nprint(word_counts.most_common(10))\n\n\n# Create a word cloud\nwordcloud = WordCloud(width=800, height=400, background_color='white').generate_from_frequencies(word_counts)\n\nplt.figure(figsize=(10, 6))\nplt.imshow(wordcloud, interpolation='bilinear')\nplt.axis('off')\nplt.title('Word Cloud of Descriptions')\nplt.show()\n\n# Explore relationships between themes and other variables (example: sequence length)\n#  (This is a placeholder; a more sophisticated approach might use topic modeling)\n#  For simplicity, just examine the frequency of the top 5 words across different sequence length ranges\ntop_5_words = [word for word, count in word_counts.most_common(5)]\n\nfor word in top_5_words:\n    plt.figure(figsize=(8, 6))\n    plt.scatter(df['days_since_reference'], df['description'].str.lower().str.count(word), alpha=0.7)\n    plt.xlabel(\"Days Since Reference Date\")\n    plt.ylabel(f\"Frequency of '{word}'\")\n    plt.title(f\"Frequency of '{word}' vs Temporal Cutoff\")\n    plt.grid(True)\n    plt.show()","metadata":{"id":"f40hBxdMTW1d","outputId":"1741eca7-20d1-4ad8-9a54-fc451b0973a3"},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import pandas as pd\nimport matplotlib.pyplot as plt\nimport numpy as np\nfrom datetime import datetime\n\n\n# Load the test sequences\n# Function to load test_sequences with user input\ndef load_test_sequences():\n    \"\"\"Loads the test_sequences.csv file, prompting the user for a path if needed.\"\"\"\n    while True:\n        try:\n            # Try loading with relative path\n            file_path = input(\"Enter the path to 'test_sequences.csv': \") or '../test_sequences.csv'\n            # Specify the delimiter explicitly, trying different options if necessary\n            test_sequences = pd.read_csv(file_path, delimiter=',')  # Try comma first\n            # if error try: test_sequences = pd.read_csv(file_path, delimiter='\\t') #Try tab\n            # if error try: test_sequences = pd.read_csv(file_path, delimiter=';') #Try semicolon\n            return test_sequences  # Return if successful\n        except FileNotFoundError:\n            print(\"Error: File not found. Please enter a valid path.\")\n        except pd.errors.ParserError:\n            print(\"Error parsing the file. Please check the delimiter and file format.\")\n            # You can optionally add code here to inspect the problematic line (line 9)\n            # and try to identify the correct delimiter\n\n\n# Call the function to load the data\ntest_sequences = load_test_sequences()\n\n# Create an empty DataFrame for the submission file\nsubmission_df = pd.DataFrame(columns=['ID', 'resname', 'resid'] + \\\n                                    [f'{coord}_{struct}'\n                                     for struct in range(1, 6)\n                                     for coord in 'xyz'])\n\n# Iterate through the test sequences and generate predictions\nfor index, row in test_sequences.iterrows():\n    # Use 'target_id' instead of 'ID'\n    sequence_id = row['target_id']\n\n    # Placeholder for prediction function\n    def predict_structure(sequence, structure_number):\n        \"\"\"\n        This function should predict the 3D structure of the RNA sequence\n        and return the coordinates of the C1' atoms.\n\n        Args:\n            sequence: The RNA sequence.\n            structure_number: The structure number (1-5).\n\n        Returns:\n            A list of (x, y, z) coordinates for the C1' atoms.\n        \"\"\"\n        # Replace this with your actual prediction logic\n        # This is just a random example\n        import random\n        num_residues = len(sequence)\n        coordinates = [(random.uniform(-10, 10),\n                        random.uniform(-10, 10),\n                        random.uniform(-10, 10))\n                       for _ in range(num_residues)]\n        return coordinates\n\n    # Get the sequence and residue information\n    sequence = row['sequence']\n    resname = [c for c in sequence]\n    resid = range(1, len(sequence) + 1)\n\n    # Predict 5 structures and build the row data\n    row_data = []  # Initialize an empty list to store row data\n    for struct_num in range(1, 6):\n        predicted_coords = predict_structure(sequence, struct_num)\n        row_data.extend([coord for coords in predicted_coords for coord in coords])  # Flatten the list\n\n    # Create a new row for the submission DataFrame\n    new_row = pd.DataFrame([[f'{sequence_id}_1', resname[0], resid[0]] + row_data], # Use sequence_id_1 for ID\n                        columns=submission_df.columns)  # Ensure columns match\n\n    # Append the new row to the submission DataFrame\n    submission_df = pd.concat([submission_df, new_row], ignore_index=True)\n\n# Save the submission file\nsubmission_df.to_csv('submission.csv', index=False)\n\nprint(\"Submission file created successfully!\")","metadata":{"id":"WwOCg9I9pXwk","outputId":"276f7847-86ea-41ca-c940-345020505ab7"},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import numpy as np\nimport pandas as pd\ndf = pd.DataFrame(\n    np.random.rand(100, 5),\n    columns=['a', 'b', 'c', 'd', 'e'])\ndf.to_csv('/kaggle/working/df.csv',index=False)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-14T12:41:31.011406Z","iopub.execute_input":"2025-05-14T12:41:31.011887Z","iopub.status.idle":"2025-05-14T12:41:31.024501Z","shell.execute_reply.started":"2025-05-14T12:41:31.011847Z","shell.execute_reply":"2025-05-14T12:41:31.023379Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# List all installed packages and package versions\n!pip freeze","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-14T12:41:07.900907Z","iopub.execute_input":"2025-05-14T12:41:07.901210Z","iopub.status.idle":"2025-05-14T12:41:12.089322Z","shell.execute_reply.started":"2025-05-14T12:41:07.901185Z","shell.execute_reply":"2025-05-14T12:41:12.087838Z"}},"outputs":[],"execution_count":null}]}