huggingface_docmatix.txt

# File: docmatix-main/analysis/count_words_in_dataset.py
from collections import Counter
import string

def count_words(df, column_name):
    overall_counter = Counter()
    word_counts = []
    for text in df[column_name]:
        text = text.translate(str.maketrans(string.punctuation, ' ' * len(string.punctuation)))
        words = text.lower().split()
        word_count = len(words)
        word_counts.append(word_count)
        overall_counter.update(words)
    df['word_count'] = word_counts
    most_common_words = overall_counter.most_common(100)
    return (df, most_common_words)

# File: docmatix-main/analysis/plot.py
import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
analysis_df = pd.read_json('prompt_analysis_results.json', orient='records', lines=True)
sns.set(style='whitegrid')
plt.figure(figsize=(16, 12))
plt.subplot(3, 2, 1)
sns.barplot(x='Prompt ID', y='Number of Q/A pairs', data=analysis_df, palette='viridis')
plt.title('Number of Q/A pairs per Prompt ID')
plt.xlabel('Prompt ID')
plt.ylabel('Number of Q/A pairs')
for (i, row) in analysis_df.iterrows():
    plt.text(i, row['Number of Q/A pairs'], f"{row['Number of Q/A pairs'] / 1000000.0:.2f}e6", ha='center', va='bottom')
plt.subplot(3, 2, 2)
sns.barplot(x='Prompt ID', y='Average answer length', data=analysis_df, palette='viridis')
plt.title('Average Answer Length per Prompt ID')
plt.xlabel('Prompt ID')
plt.ylabel('Average Answer Length')
for (i, row) in analysis_df.iterrows():
    plt.text(i, row['Average answer length'], f"{row['Average answer length']:.2f}", ha='center', va='bottom')
plt.subplot(3, 2, 3)
sns.barplot(x='Prompt ID', y='Diversity within documents', data=analysis_df, palette='viridis')
plt.title('Diversity within Documents per Prompt ID')
plt.xlabel('Prompt ID')
plt.ylabel('Diversity within Documents')
for (i, row) in analysis_df.iterrows():
    plt.text(i, row['Diversity within documents'], f"{row['Diversity within documents']:.2f}", ha='center', va='bottom')
plt.subplot(3, 2, 4)
sns.barplot(x='Prompt ID', y='Total empty questions', data=analysis_df, palette='viridis')
plt.title('Total Empty Questions per Prompt ID')
plt.xlabel('Prompt ID')
plt.ylabel('Total Empty Questions')
for (i, row) in analysis_df.iterrows():
    plt.text(i, row['Total empty questions'], f"{row['Total empty questions']}", ha='center', va='bottom')
plt.subplot(3, 2, 5)
sns.barplot(x='Prompt ID', y='Average Q/A pairs per page', data=analysis_df, palette='viridis')
plt.title('Average Q/A pairs per Page per Prompt ID')
plt.xlabel('Prompt ID')
plt.ylabel('Average Q/A pairs per Page')
for (i, row) in analysis_df.iterrows():
    plt.text(i, row['Average Q/A pairs per page'], f"{row['Average Q/A pairs per page']:.2f}", ha='center', va='bottom')
plt.subplot(3, 2, 6)
sns.barplot(x='Prompt ID', y='Number of unique questions', data=analysis_df, palette='viridis')
plt.title('Number of unique questions per Prompt ID')
plt.xlabel('Prompt ID')
plt.ylabel('Number of unique questions')
for (i, row) in analysis_df.iterrows():
    plt.text(i, row['Number of unique questions'], f"{row['Number of unique questions'] / 1000000.0:.2f}e6", ha='center', va='bottom')
plt.tight_layout()
plt.savefig('prompt_analysis_plots_enhanced.png')
plt.show()
report = f"\nPrompt Analysis Report\n=======================\nNumber of Q/A pairs per Prompt ID:\n{analysis_df[['Prompt ID', 'Number of Q/A pairs']]}\n\nAverage answer length per Prompt ID:\n{analysis_df[['Prompt ID', 'Average answer length']]}\n\nUnique questions per Prompt ID:\n{analysis_df[['Prompt ID', 'Number of unique questions']]}\n\nTotal pages per Prompt ID:\n{analysis_df[['Prompt ID', 'Total pages']]}\n\nAverage Q/A pairs per page per Prompt ID:\n{analysis_df[['Prompt ID', 'Average Q/A pairs per page']]}\n\nAverage answer length per page per Prompt ID:\n{analysis_df[['Prompt ID', 'Average answer length per page']]}\n\nDiversity within documents per Prompt ID:\n{analysis_df[['Prompt ID', 'Diversity within documents']]}\n\nTotal empty questions per Prompt ID:\n{analysis_df[['Prompt ID', 'Total empty questions']]}\n\n"
with open('prompt_analysis_report.txt', 'w') as f:
    f.write(report)
print('Report and plots generated successfully.')

# File: docmatix-main/clean_and_create/load_data.py
import os
import re
import io
from io import BytesIO
import pandas as pd
import datasets
from pdf2image import convert_from_bytes
from tqdm import tqdm
from concurrent.futures import ThreadPoolExecutor
import argparse
import fitz
import PIL.Image
tqdm.pandas(desc='Pandas apply progress')
fitz.TOOLS.mupdf_display_errors(False)
DATA_PATH = '/fsx/andi/pdfa_data/'
TAR_FILE_PATTERN = 'pdfa-eng-train-{:06d}.tar'

def resize_large_images(image, max_image_size=2940):
    (width, height) = image.size
    aspect_ratio = width / height
    resized = False
    if width >= height and width > max_image_size:
        width = max_image_size
        height = int(width / aspect_ratio)
        resized = True
    elif height > width and height > max_image_size:
        height = max_image_size
        width = int(height * aspect_ratio)
        resized = True
    if resized:
        image = image.resize((width, height), PIL.Image.LANCZOS)
    return image

def _decode_pdf_pages(sample):
    try:
        image_fmt = 'L'
        with io.BytesIO(sample) as b:
            doc = fitz.Document(stream=b)
            num_image_pages = doc.page_count
            decoded_image_pages = []
            for page_index in range(num_image_pages):
                page = doc.load_page(page_index)
                pixmap = page.get_pixmap(dpi=150)
                page_image = PIL.Image.frombuffer('RGB', (pixmap.width, pixmap.height), pixmap.samples)
                page_image = resize_large_images(page_image.convert(image_fmt))
                decoded_image_pages += [page_image]
            return decoded_image_pages
    except Exception as e:
        print(f'Error decoding pdf pages: {e}')
        return None

def convert_img_to_png_bytes(img):
    with BytesIO() as buffer:
        img.save(buffer, format='PNG')
        return buffer.getvalue()

def process_images(pdf_bytes):
    images = convert_from_bytes(pdf_bytes, dpi=150)
    return [convert_img_to_png_bytes(resize_large_images(img)) for img in images]

def is_valid_question_or_answer(text):
    if not text or text.strip() == '':
        return False
    patterns = ['\\{.*?\\}', '\\[.*?\\]', '<.*?>', '\\b\\d{1,3}(\\.\\d{1,3}){3}\\b', '\\w+\\.\\w+', '\\n\\s*\\n', 'unanswerable', 'Q\\d+: ', 'A\\d+: ']
    return not any((re.search(pattern, text, re.IGNORECASE) for pattern in patterns))

def process_group(key_group):
    try:
        (key, group) = key_group
        qa_pairs = []
        for (_, row) in group.iterrows():
            question = re.sub('^Q\\d+: ', '', row['question'])
            answer = re.sub('^A\\d+: ', '', row['answer'])
            if is_valid_question_or_answer(question) and is_valid_question_or_answer(answer):
                qa_pairs.append({'user': question, 'assistant': answer, 'source': 'PDFA key: ' + str(row['__key__'])})
        if qa_pairs:
            return {'texts': qa_pairs, 'images': group['pdf'].iloc[0]}
    except Exception as e:
        print(f'Error processing group {key}: {e}')
        return None

def process_tar_index(tar_index, step_size, question_answer_df):
    shard_nr = tar_index // step_size
    loaded_datasets = []
    for inner_idx in range(step_size):
        tar_file = os.path.join(DATA_PATH, TAR_FILE_PATTERN.format(tar_index + inner_idx))
        try:
            print(f'Loading dataset from: {tar_file}')
            hf_dataset = datasets.load_dataset('webdataset', split='train', data_files=tar_file, cache_dir='/fsx/.cache').to_pandas()
            hf_dataset.__key__ = hf_dataset.__key__.apply(pd.to_numeric)
            loaded_datasets.append(hf_dataset)
        except Exception as e:
            print(f'Error loading dataset from: {tar_file}')
            print(e)
    hf_dataset = pd.concat(loaded_datasets, ignore_index=True)
    print(f'Concatenated datasets with {len(hf_dataset)} samples')
    hf_dataset = hf_dataset[hf_dataset['__key__'].isin(question_answer_df['__key__'].unique())]
    df_data = pd.DataFrame({'key': []})
    if os.path.exists(f'/fsx/m4/datasets/large_docvqa/shard_{shard_nr}'):
        print('using saved data')
        df_data = datasets.load_from_disk(f'/fsx/m4/datasets/large_docvqa/shard_{shard_nr}').to_pandas()
        df_data['__key__'] = df_data.texts.apply(lambda x: x[0]['source'].split('_')[1])
        df_data['__key__'] = df_data['__key__'].apply(pd.to_numeric)
        df_data.drop(columns=['texts'], inplace=True)
        hf_dataset = hf_dataset[hf_dataset['__key__'].isin(df_data['__key__'].unique())]
        hf_dataset = pd.merge(hf_dataset, df_data, on='__key__', how='inner')
        hf_dataset['pdf'] = hf_dataset['images']
        hf_dataset.drop(columns=['images'], inplace=True)
        del df_data
    else:
        hf_dataset['pdf'] = hf_dataset['pdf'].progress_apply(lambda x: process_images(x))
        hf_dataset = hf_dataset[~hf_dataset['pdf'].isnull()]
    merged_df = pd.merge(hf_dataset, question_answer_df, on='__key__', how='inner')
    data_extracted = []
    max_threads = 10
    with ThreadPoolExecutor(max_threads) as executor:
        results = list(tqdm(executor.map(process_group, merged_df.groupby('__key__')), desc='Extracting data', total=len(merged_df['__key__'].unique())))
    data_extracted.extend(results)
    data_extracted = list(filter(lambda item: item is not None, data_extracted))
    FEATURES = datasets.Features({'images': datasets.Sequence(datasets.Image(decode=True)), 'texts': [{'user': datasets.Value('string'), 'assistant': datasets.Value('string'), 'source': datasets.Value('string')}]})

    def data_generator():
        for data_dict in data_extracted:
            yield data_dict
    ds_shard = datasets.Dataset.from_generator(data_generator, features=FEATURES, writer_batch_size=100, cache_dir='/fsx/.cache')
    ds_shard.save_to_disk(f'/fsx/m4/datasets/docvqa_instruct/shard_{shard_nr}')

def load_and_concatenate_dataframes():
    if os.path.exists('concatenated_synthetic_dataset.parquet.gzip'):
        return pd.read_parquet('concatenated_synthetic_dataset.parquet.gzip')
    directory = '.'
    all_files = os.listdir(directory)
    h5_files = sorted([f for f in all_files if re.match('synthetic_dataset_batch_\\d+\\.h5$', f)])
    dataframes = []
    for file in tqdm(h5_files, desc='Loading data'):
        file_path = os.path.join(directory, file)
        df = pd.read_hdf(file_path)
        if '__key__' not in df.columns:
            raise ValueError(f'Key column not found in {file_path}')
        df.__key__ = df.__key__.apply(pd.to_numeric)
        dataframes.append(df)
    concatenated_df = pd.concat(dataframes, ignore_index=True)
    concatenated_df.to_parquet('concatenated_synthetic_dataset.parquet.gzip', compression='gzip')
    return concatenated_df
if __name__ == '__main__':
    parser = argparse.ArgumentParser(description='Process .h5 files and tar indices.')
    parser.add_argument('--start_index', type=int, default=0, help='The starting index for tar processing.')
    parser.add_argument('--step_size', type=int, default=1, help='The step size for tar processing.')
    args = parser.parse_args()
    question_answer_df = load_and_concatenate_dataframes()
    print(len(question_answer_df))
    process_tar_index(args.start_index, args.step_size, question_answer_df=question_answer_df)

# File: docmatix-main/create_only_with_pdfs/load_data.py
import os
import re
import pandas as pd
import datasets
from tqdm import tqdm
from concurrent.futures import ThreadPoolExecutor
import argparse
tqdm.pandas(desc='Pandas apply progress')
DATA_PATH = '/fsx/andi/pdfa_data/'
TAR_FILE_PATTERN = 'pdfa-eng-train-{:06d}.tar'

def is_valid_question_or_answer(text):
    if not text or text.strip() == '':
        return False
    patterns = ['\\{.*?\\}', '\\[.*?\\]', '<.*?>', '\\b\\d{1,3}(\\.\\d{1,3}){3}\\b', '\\w+\\.\\w+', '\\n\\s*\\n', 'unanswerable', 'Q\\d+: ', 'A\\d+: ']
    return not any((re.search(pattern, text, re.IGNORECASE) for pattern in patterns))

def process_group(key_group):
    try:
        (key, group) = key_group
        qa_pairs = []
        for (_, row) in group.iterrows():
            question = re.sub('^Q\\d+: ', '', row['question'])
            answer = re.sub('^A\\d+: ', '', row['answer'])
            if is_valid_question_or_answer(question) and is_valid_question_or_answer(answer):
                qa_pairs.append({'user': question, 'assistant': answer, 'source': 'PDFA key: ' + str(row['__key__'])})
        if qa_pairs:
            return {'texts': qa_pairs, 'pdf': group['pdf'].iloc[0]}
    except Exception as e:
        print(f'Error processing group {key}: {e}')
        return None

def process_tar_index(tar_index, step_size, question_answer_df):
    shard_nr = tar_index // step_size
    loaded_datasets = []
    for inner_idx in range(step_size):
        tar_file = os.path.join(DATA_PATH, TAR_FILE_PATTERN.format(tar_index + inner_idx))
        try:
            print(f'Loading dataset from: {tar_file}')
            hf_dataset = datasets.load_dataset('webdataset', split='train', data_files=tar_file, cache_dir='/fsx/.cache').to_pandas()
            hf_dataset.__key__ = hf_dataset.__key__.apply(pd.to_numeric)
            loaded_datasets.append(hf_dataset)
        except Exception as e:
            print(f'Error loading dataset from: {tar_file}')
            print(e)
    hf_dataset = pd.concat(loaded_datasets, ignore_index=True)
    print(f'Concatenated datasets with {len(hf_dataset)} samples')
    hf_dataset = hf_dataset[hf_dataset['__key__'].isin(question_answer_df['__key__'].unique())]
    merged_df = pd.merge(hf_dataset, question_answer_df, on='__key__', how='inner')
    data_extracted = []
    max_threads = 10
    with ThreadPoolExecutor(max_threads) as executor:
        results = list(tqdm(executor.map(process_group, merged_df.groupby('__key__')), desc='Extracting data', total=len(merged_df['__key__'].unique())))
    data_extracted.extend(results)
    data_extracted = list(filter(lambda item: item is not None, data_extracted))
    FEATURES = datasets.Features({'pdf': datasets.Value('binary'), 'texts': [{'user': datasets.Value('string'), 'assistant': datasets.Value('string'), 'source': datasets.Value('string')}]})

    def data_generator():
        for data_dict in data_extracted:
            yield data_dict
    ds_shard = datasets.Dataset.from_generator(data_generator, features=FEATURES, writer_batch_size=100, cache_dir='/fsx/.cache')
    ds_shard.save_to_disk(f'/fsx/m4/datasets/docmatix_pdf/shard_{shard_nr}')

def load_and_concatenate_dataframes():
    if os.path.exists('/fsx/andi/llm-swarm/concatenated_synthetic_dataset.parquet.gzip'):
        return pd.read_parquet('/fsx/andi/llm-swarm/concatenated_synthetic_dataset.parquet.gzip')
    directory = '.'
    all_files = os.listdir(directory)
    h5_files = sorted([f for f in all_files if re.match('synthetic_dataset_batch_\\d+\\.h5$', f)])
    dataframes = []
    for file in tqdm(h5_files, desc='Loading data'):
        file_path = os.path.join(directory, file)
        df = pd.read_hdf(file_path)
        if '__key__' not in df.columns:
            raise ValueError(f'Key column not found in {file_path}')
        df.__key__ = df.__key__.apply(pd.to_numeric)
        dataframes.append(df)
    concatenated_df = pd.concat(dataframes, ignore_index=True)
    concatenated_df.to_parquet('concatenated_synthetic_dataset.parquet.gzip', compression='gzip')
    return concatenated_df
if __name__ == '__main__':
    parser = argparse.ArgumentParser(description='Process .h5 files and tar indices.')
    parser.add_argument('--start_index', type=int, default=0, help='The starting index for tar processing.')
    parser.add_argument('--step_size', type=int, default=1, help='The step size for tar processing.')
    args = parser.parse_args()
    question_answer_df = load_and_concatenate_dataframes()
    print(len(question_answer_df))
    process_tar_index(args.start_index, args.step_size, question_answer_df=question_answer_df)

# File: docmatix-main/create_only_with_pdfs/upload_data.py
from datasets import load_from_disk, concatenate_datasets
from tqdm import tqdm
import os

def get_datasets():
    if os.path.isdir('/fsx/m4/datasets/docmatix_pdf/concatenated'):
        return load_from_disk('/fsx/m4/datasets/docmatix_pdf/concatenated')
    hf_datasets = []
    for shard_nr in tqdm(range(200)):
        try:
            hf_datasets.append(load_from_disk(f'/fsx/m4/datasets/docmatix_pdf/shard_{shard_nr}'))
        except Exception as e:
            print(f'Error loading dataset from: {shard_nr}')
            print(e)
    hf_data = concatenate_datasets(hf_datasets)
    hf_data.save_to_disk('/fsx/m4/datasets/docmatix_pdf/concatenated')
    return hf_data
data = get_datasets()
print(data.features)
print(data[0]['texts'])
print(data[0]['pdf'][:10])
print(len(data))
data.push_to_hub('HuggingFaceM4/Docmatix', 'pdf')

# File: docmatix-main/florence_2_dataset/create_florence_2_dataset.py
from functools import partial
from datasets import load_from_disk, concatenate_datasets
from tqdm import tqdm
import re
import pandas as pd
import os
import datasets
IMAGE_FEATURES = datasets.Features({'image': datasets.Image(decode=True), '__key__': datasets.Value('int64')})
TEXT_FEATURES = datasets.Features({'question': datasets.Value('string'), 'answer': datasets.Value('string'), '__key__': datasets.Value('int64')})

def text_generator(df_text):
    for (i, row) in df_text.iterrows():
        print(i, row['__key__'])
        yield {'question': row['question'], 'answer': row['answer'], '__key__': row['__key__']}

def img_generator(df_img):
    for (i, row) in df_img.iterrows():
        print(i, row['__key__'])
        yield {'image': row['images'][0], '__key__': row['__key__']}
pre_key_len = len('PDFA key: ')
for shard_number in tqdm(range(0, 200)):
    try:
        if os.path.exists(f'/fsx/m4/datasets/florence_vqa_instruct/shard_{shard_number}') and os.path.exists(f'/fsx/m4/datasets/florence_vqa_instruct_images/shard_{shard_number}'):
            continue
        df_data = load_from_disk(f'/fsx/m4/datasets/docvqa_instruct/shard_{shard_number}').to_pandas()
        df_data['__key__'] = df_data.texts.apply(lambda x: x[0]['source'][pre_key_len:])
        df_data['__key__'] = df_data['__key__'].apply(pd.to_numeric)
        df_images = df_data[['images', '__key__']].copy()
        df_images = df_images[df_images['images'].apply(len) <= 1]
        df_texts = df_data[['texts']].explode('texts')
        df_texts['question'] = df_texts['texts'].apply(lambda x: x.get('user'))
        df_texts['answer'] = df_texts['texts'].apply(lambda x: x.get('assistant'))
        df_texts['__key__'] = df_texts['texts'].apply(lambda x: x.get('source')[pre_key_len:])
        df_texts['__key__'] = df_texts['__key__'].apply(pd.to_numeric)
        df_texts = df_texts[df_texts['__key__'].isin(df_images['__key__'].unique())]
        df_texts.drop(columns=['texts'], inplace=True)
        df_texts = df_texts[df_texts['question'].apply(lambda x: len(x.split()) <= 900)]
        df_texts = df_texts[df_texts['answer'].apply(lambda x: len(x.split()) <= 900)]
        df_images = df_images[df_images['__key__'].isin(df_texts['__key__'].unique())]
        ds_text = datasets.Dataset.from_generator(partial(text_generator, df_texts), features=TEXT_FEATURES, writer_batch_size=100, cache_dir='/fsx/.cache')
        ds_text.save_to_disk(f'/fsx/m4/datasets/florence_vqa_instruct/shard_{shard_number}')
        df_image = datasets.Dataset.from_generator(partial(img_generator, df_images), features=IMAGE_FEATURES, writer_batch_size=100, cache_dir='/fsx/.cache')
        df_image.save_to_disk(f'/fsx/m4/datasets/florence_vqa_instruct_images/shard_{shard_number}')
        print(f'Finished processing shard: {shard_number}')
    except:
        print(f'shard {shard_number} failed')
all_ds = []
for shard in tqdm(range(0, 200)):
    try:
        data = load_from_disk(f'/fsx/m4/datasets/florence_vqa_instruct/shard_{shard}')
        all_ds.append(data)
    except:
        print(f'shard {shard} failed')
all_ds = concatenate_datasets(all_ds)
all_ds.save_to_disk('/fsx/m4/datasets/complete_florence_vqa_instruct', num_proc=96)

# File: docmatix-main/generation/base_prompts.py
BASE_PROMPT = '\nYou are reading text extracted from a PDF with several pages. The pages are divided by a line saying \'NEW PAGE\'. \nYour role is to {role_description}. If the type of questions requested are impossible to generate due to the simplicity of the document, default to simpler factual questions.\nThe PDFs might contain tables or images that are poorly parsed in the text. Avoid asking questions about these.\nIf the text seems to only contain uninteresting information, output "unanswerable" as the answer.\nHere are some examples for questions that follow your role:\n{examples}\n'
BASE_USER_CONTENT = 'The text contained in the PDF is: \n{text} \n\nCreate the question answer pairs following this format:\nQ#: \nA#:\n\nIf you can\'t generate a questions for the text, write "unanswerable" as the answer.\n'
PROMPTS = [{'role_description': 'understand the content of the PDF and create as many pairs of questions and answers as you need to cover the content of the PDF comprehensively. The questions should be varied, covering factual information, inferences, and deeper analysis of the text.', 'examples': '\n        Q1: What is the main topic of the document?\n        A1: The main topic of the document is...\n        \n        Q2: What are the key points discussed in the first section?\n        A2: The key points discussed in the first section include...\n\n        Q3: How does the author support their argument about X?\n        A3: The author supports their argument about X by...\n\n        Q4: What can be inferred about Y from the document?\n        A4: From the document, it can be inferred that Y...\n\n        Q5: What are the implications of Z mentioned in the document?\n        A5: The implications of Z mentioned in the document are...\n        '}, {'role_description': 'focus on generating enough pairs of questions and answers for each section of the document to ensure a detailed and complete coverage the document.', 'examples': '\n        Q1: What is the primary focus of the first section?\n        A1: The primary focus of the first section is...\n\n        Q2: What are the significant details mentioned in the second section?\n        A2: The significant details mentioned in the second section include...\n\n        Q3: How does the information in the third section relate to the overall topic of the document?\n        A3: The information in the third section relates to the overall topic by...\n        '}, {'role_description': 'understand the content of the PDF and create as many pairs of questions and answers as you need to cover the content of the PDF comprehensively. The questions should require critical thinking and analysis.', 'examples': '\n        Q1: What arguments does the author present in support of their thesis?\n        A1: The arguments presented by the author in support of their thesis include...\n\n        Q2: How does the author compare X and Y in the text?\n        A2: The author compares X and Y by...\n\n        Q3: What are the potential implications of the findings discussed in the document?\n        A3: The potential implications of the findings are...\n        '}, {'role_description': 'create as many pairs of questions and answers as you need to cover both summaries of sections and specific details. Ensure a coverage of broad themes and granular information.', 'examples': '\n        Q1: What is the summary of the first section?\n        A1: The summary of the first section is...\n\n        Q2: What specific data or evidence is provided in the second section?\n        A2: The specific data or evidence provided in the second section includes...\n\n        Q3: How do the details in the third section support the main argument of the document?\n        A3: The details in the third section support the main argument by...\n        '}, {'role_description': 'understand the content of the PDF and create as many pairs of questions and answers as you need to cover the content of the PDF comprehensively. The questions should be varied, covering factual information, inferences, and deeper analysis of the text. The questions should be asked in a general manner without introducing details from the document itself.', 'examples': '\n        Q1: What is the summary of the first section?\n        A1: The first section, called xxx, can be summarized as is...\n\n        Q2: What specific data or evidence is provided in the second section?\n        A2: In the section called xxx, there is a much data and evidence presented, such as...\n\n        Q3: How do the details in the third section support the main argument of the document?\n        A3: The details in the section on "xxx" support the main argument by...\n        '}]

def create_prompts(text):
    prompts = []
    for prompt in PROMPTS:
        system_content = BASE_PROMPT.format(role_description=prompt['role_description'], examples=prompt['examples'])
        prompts.append([{'role': 'system', 'content': system_content}, {'role': 'user', 'content': BASE_USER_CONTENT.format(text=text)}])
    return prompts

# File: docmatix-main/generation/llm_swarm_script.py
import asyncio
import json
import os
import random
import re
from concurrent.futures import ThreadPoolExecutor
from typing import Any, Dict, List, Optional
import pandas as pd
from datasets import IterableDataset, load_dataset
from huggingface_hub import AsyncInferenceClient
from tqdm import trange
from tqdm.asyncio import tqdm_asyncio
from transformers import AutoTokenizer
from examples.question_answer_pairs.phase_1.base_prompts import BASE_PROMPT, BASE_USER_CONTENT, PROMPTS
from llm_swarm import LLMSwarm, LLMSwarmConfig
CHECKPOINT_FILE = 'checkpoint.json'
DATA_PATH = '/fsx/andi/pdfa_data/'
TAR_FILE_PATTERN = 'pdfa-eng-train-{:06d}.tar'
NUM_TAR_FILES = 1800
MAX_PAGES_PER_PDF = 4
STEP_SIZE = 10
model_id = 'microsoft/Phi-3-small-8k-instruct'

def create_llm_prompt(prompt, text):
    system_content = BASE_PROMPT.format(role_description=prompt['role_description'], examples=prompt['examples'])
    return [{'role': 'system', 'content': system_content}, {'role': 'user', 'content': BASE_USER_CONTENT.format(text=text)}]

def extract_text_per_page_from_sample(sample: Dict[str, Any]) -> List[str]:
    texts = []
    for page in sample['json']['pages']:
        pages_text = ' \n '.join(page['lines']['text'])
        texts.append(pages_text)
    return texts

def extract_chunks(pages: List[Any], max_tokens_per_group: int, max_pages_per_group: int, n_overlap: int) -> List[str]:
    chunks = []
    current_chunk = []
    current_chunk_tokens = 0
    current_chunk_pages = 0
    page_token_counts = [len(tokenizer.encode(page, add_special_tokens=False)) for page in pages]
    for (i, page) in enumerate(pages):
        page_tokens = page_token_counts[i]
        if page_tokens > max_tokens_per_group:
            print(f'Skipping document where page nr {i} has {page_tokens} tokens.')
            return []
        if current_chunk_tokens + page_tokens > max_tokens_per_group or current_chunk_pages + 1 > max_pages_per_group:
            if current_chunk:
                chunks.append('\nNEW PAGE\n'.join(current_chunk))
            current_chunk = current_chunk[-n_overlap:] if n_overlap > 0 else []
            current_chunk_tokens = sum(page_token_counts[max(0, i - n_overlap):i])
            current_chunk_pages = len(current_chunk)
        current_chunk.append(page)
        current_chunk_tokens += page_tokens
        current_chunk_pages += 1
    if current_chunk:
        chunks.append('\nNEW PAGE\n'.join(current_chunk))
    return chunks

def create_tasks(dataset: IterableDataset, prompt_id: Optional[int]=None, n_overlap: int=2) -> List[Dict[str, Any]]:
    if prompt_id is not None:
        selected_id_prompt = prompt_id
    tasks = []
    for (index, sample) in dataset.iterrows():
        text_per_page = extract_text_per_page_from_sample(sample)
        if len(text_per_page) > MAX_PAGES_PER_PDF:
            continue
        page_chunks = extract_chunks(text_per_page, max_tokens_per_group=5000, max_pages_per_group=5, n_overlap=n_overlap)
        for chunk in page_chunks:
            if prompt_id is None:
                selected_id_prompt = random.randint(0, 4)
            prompt = PROMPTS[selected_id_prompt]
            messages = create_llm_prompt(prompt, chunk)
            prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
            tasks_dict = {'__key__': sample['__key__'], 'Page count': len(text_per_page), 'messages': prompt, 'Prompt ID': selected_id_prompt}
            tasks.append(tasks_dict)
    return tasks

def extract_qa_pairs(text):
    qa_pattern = re.compile('(Q\\d+:\\s*.*?)(A\\d+:\\s*.*?)(?=(Q\\d+:)|$)', re.DOTALL)
    matches = qa_pattern.findall(text)
    qa_pairs = [(q.strip(), a.strip()) for match in matches for (q, a) in [match[:2]]]
    return qa_pairs

def process_outputs_to_df(df):
    all_data = []
    for (index, row) in df.iterrows():
        task = row['Task']
        completion = row['Completion']
        sample_key = task['__key__']
        page_count = task['Page count']
        prompt_id = task['Prompt ID']
        qa_pairs = extract_qa_pairs(completion)
        if len(qa_pairs) == 0:
            print('No Q&A pairs found for sample:', sample_key)
        for (question, answer) in qa_pairs:
            all_data.append({'__key__': sample_key, 'Page count': page_count, 'Prompt ID': prompt_id, 'question': question, 'answer': answer})
    qa_df = pd.DataFrame(all_data)
    return qa_df

def save_checkpoint(tar_index, total_examples):
    checkpoint_data = {'tar_index': tar_index, 'total_examples': total_examples}
    with open(CHECKPOINT_FILE, 'w') as f:
        json.dump(checkpoint_data, f)

def load_checkpoint():
    if os.path.exists(CHECKPOINT_FILE):
        with open(CHECKPOINT_FILE, 'r') as f:
            return json.load(f)
    return {'tar_index': 0, 'total_examples': 0}
tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)

def launch():
    with LLMSwarm(LLMSwarmConfig(instances=8, inference_engine='vllm', gpus=1, model=model_id, slurm_template_path='templates/vllm_h100.template.slurm', load_balancer_template_path='templates/nginx.template.conf', trust_remote_code=True, per_instance_max_parallel_requests=200)) as llm_swarm:
        semaphore = asyncio.Semaphore(llm_swarm.suggested_max_parallel_requests)
        client = AsyncInferenceClient(model=llm_swarm.endpoint)

        async def process_text(prompt):
            async with semaphore:
                response = await client.post(json={'prompt': prompt, 'max_tokens': 2000})
                res = json.loads(response.decode('utf-8'))['text'][0][len(prompt):]
                return res

        def load_and_process_dataset(tar_file):
            try:
                print(f'Loading dataset from: {tar_file}')
                dataset = load_dataset('webdataset', split='train', data_files=tar_file).to_pandas()
                tasks = create_tasks(dataset, prompt_id=None, n_overlap=1)
                return tasks
            except Exception as e:
                print(f'Error loading dataset from: {tar_file}')
                print(e)
                return []

        def get_future_tasks(tar_index, executor):
            futures = []
            for inner_idx in range(STEP_SIZE):
                tar_file = os.path.join(DATA_PATH, TAR_FILE_PATTERN.format(tar_index + inner_idx))
                futures.append(executor.submit(load_and_process_dataset, tar_file))
            return futures

        async def process_dataset(tar_index, total_examples):
            next_future_tasks = get_future_tasks(tar_index, ThreadPoolExecutor(max_workers=STEP_SIZE))
            for idx in trange(tar_index, NUM_TAR_FILES + STEP_SIZE, STEP_SIZE, desc='Creating Dataset'):
                print(f'Processing tar file {idx}')
                tasks = []
                future_tasks = next_future_tasks
                results = [f.result() for f in future_tasks]
                for result in results:
                    tasks.extend(result)
                next_future_tasks = get_future_tasks(idx + STEP_SIZE, ThreadPoolExecutor(max_workers=1))
                results = await tqdm_asyncio.gather(*(process_text(task['messages']) for task in tasks))
                df = pd.DataFrame({'Task': tasks, 'Completion': results})
                df_new = process_outputs_to_df(df)
                df_new.to_hdf(f'synthetic_dataset_batch_{idx}.h5', key='df', mode='w')
                unique_keys = df_new['__key__'].nunique()
                total_examples += unique_keys
                save_checkpoint(idx, total_examples)

        async def main():
            checkpoint = load_checkpoint()
            tar_index = checkpoint['tar_index']
            if tar_index != 0:
                tar_index += STEP_SIZE
                print(f'Resuming from tar file {tar_index}')
            total_examples = checkpoint['total_examples']
            processor = asyncio.create_task(process_dataset(tar_index, total_examples))
            await processor
            print('All batches processed.')
        asyncio.run(main())
launch()

# File: docmatix-main/zero_shot_exp/zero_shot.py
from datasets import Dataset, Features, Value, load_dataset, Image, Sequence
TEST_SUBSET_LEN = 200
TRAIN_SUBSET_LEN = 1700
FEATURES = Features({'images': Sequence(Image(decode=True)), 'texts': [{'user': Value('string'), 'assistant': Value('string'), 'source': Value('string')}]})
ds = load_dataset('HuggingFaceM4/Docmatix', 'images', streaming=True)
test_subset = []
train_subset = []
for (idx, sample) in enumerate(ds['train']):
    if idx < TEST_SUBSET_LEN:
        test_subset.append(sample)
    if idx >= TEST_SUBSET_LEN - 1:
        if idx >= TEST_SUBSET_LEN + TRAIN_SUBSET_LEN - 1:
            break
        train_subset.append(sample)
new_test_data = Dataset.from_list(test_subset, features=FEATURES)
new_train_data = Dataset.from_list(train_subset, features=FEATURES)
new_test_data.push_to_hub('HuggingFaceM4/Docmatix', 'zero-shot-exp', split='test')
new_train_data.push_to_hub('HuggingFaceM4/Docmatix', 'zero-shot-exp', split='train')