KameshRsk/flan_cot

Cleaned FLAN v2 Dataset 8K

Dataset Name: Cleaned FLAN v2 Dataset
Source: SirNeural/flan_v2
Files Included:

• cot_fs_noopt_train.jsonl
• cot_fs_opt_train.jsonl
• cot_zs_noopt_train.jsonl
• cot_zs_opt_train.jsonl

Data Processing and Cleaning

The dataset was processed and cleaned using the following steps:

1. Merging the JSONL Files:

   • The original dataset comprises four separate JSONL files:
     • cot_fs_noopt_train.jsonl
     • cot_fs_opt_train.jsonl
     • cot_zs_noopt_train.jsonl
     • cot_zs_opt_train.jsonl
   • These files were combined into a single file named cot_fs_noopt_train.jsonl.

2. Filtering Instructions with Short Responses:

   • Instructions with responses having less than 100 tokens were removed.
   • A tokenizer (bert-base-uncased) was used to count the tokens.

3. Data Deduplication Using Cosine Similarity:

   • The combined text of inputs and targets was used to identify and remove duplicate entries.
   • TF-IDF Vectorizer was used to transform the combined text into vectors.
   • Cosine similarity was computed between the vectors to identify duplicates with a similarity threshold greater than 0.95.
   • Duplicate entries were removed based on this threshold.

Code for Data Cleaning

The following Python code was used for data cleaning:

import json
import pandas as pd
from transformers import AutoTokenizer
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np

# Step 1: Read the JSONL file line by line
json_list = []
with open('/kaggle/input/arakooai-data/cot_fs_noopt_train.jsonl', 'r') as file:
    for line in file:
        json_obj = json.loads(line)
        json_list.append(json_obj)

# Step 2: Normalize the JSON data
df = pd.json_normalize(json_list, sep='_')

# Filter out 'task' column if it exists
if 'task' in df.columns:
    df.drop('task', axis=1, inplace=True)

# Initialize the tokenizer
tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")

# Step 2: Remove instructions with less than 100 tokens in the response
def filter_long_responses(row):
    response_tokens = tokenizer(row['targets'], truncation=False)['input_ids']
    return len(response_tokens) >= 100

filtered_df = df[df.apply(filter_long_responses, axis=1)]

# Step 3: Data Deduplication by cosine similarity
# Combine inputs and targets into a single string for deduplication
filtered_df['combined'] = filtered_df['inputs'] + " " + filtered_df['targets']

# Use TF-IDF Vectorizer for cosine similarity computation
vectorizer = TfidfVectorizer().fit_transform(filtered_df['combined'])
vectors = vectorizer.toarray()

# Compute cosine similarity matrix
cosine_sim_matrix = cosine_similarity(vectors)

# Create a mask for deduplication (threshold > 0.95)
threshold = 0.95
similar_pairs = np.argwhere(cosine_sim_matrix > threshold)
to_remove = set()

for i, j in similar_pairs:
    if i != j and i not in to_remove and j not in to_remove:
        to_remove.add(j)  # remove the duplicate

# Remove duplicates
indices_to_keep = [i for i in range(len(filtered_df)) if i not in to_remove]
deduplicated_df = filtered_df.iloc[indices_to_keep]

# Step 4: Save the cleaned dataset locally
deduplicated_df.drop(columns=['combined'], inplace=True)
deduplicated_df.to_csv('/kaggle/working/cleaned_output.csv', index=False)

print("Dataset cleaned and saved to CSV")

Acknowledgements

• The original dataset is provided by SirNeural/flan_v2.
• Tokenizer used: bert-base-uncased from Hugging Face.