add files

.gitignore

@@ -0,0 +1,2 @@
+venv
+prompt.md

README.md

@@ -1,3 +1,17 @@
----
-license: mit
----
+# leaves of grass
+
+The following is a dataset for training a model to generate text in the style of Walt Whitman's "Leaves of Grass".
+
+The idea with this dataset is to provide a single line or multiple lines from the poem, and then provide the next line in the poem. The model will be trained to predict the next line in the poem given the previous lines.
+
+There is a [generate_data.py](generate_data.py) script that can be used to generate the dataset. The script takes a text file of the poem and generates a dataset in the format described above.
+
+It keeps some formatting. After each poem title, there is a dobule newline character. Each block of a poem is also separated by a dobule newline character.
+
+Every line in a block is separated by a single newline character. Tabs are used as poetic indentations. 
+Overall the original formatting is kept but made more machine readable.
+
+## Usage
+
+    python generate_data.py
+

generate_data.py

@@ -0,0 +1,127 @@
+import re
+import json
+
+
+def clean_text_file(input_file, output_file):
+    """
+    Cleans the text file by:
+    - Removing lines that start with 'BOOK' or contain only numbers,
+    - Substituting two leading spaces with a single tab,
+    - Normalizing all leading whitespace to no more than two tabs of indentation,
+    - Splitting the text into chunks separated by at least 3 newlines.
+    """
+    with open(input_file, "r", encoding="utf-8") as infile:
+        lines = infile.readlines()
+
+    cleaned_lines = []
+
+    for line in lines:
+        stripped_line = line.strip()
+        if stripped_line.startswith("BOOK") or stripped_line.isdigit():
+            continue
+
+        line = re.sub(r"^ ", "\t", line)
+        line = re.sub(r"^[\t ]+", normalize_whitespace, line)
+
+        # Remove a single leading tab if present
+        if line.startswith("\t"):
+            line = line[1:]
+        cleaned_lines.append(line)
+
+    cleaned_text = "".join(cleaned_lines)
+    chunks = [chunk.strip() for chunk in cleaned_text.split("\n\n\n") if chunk.strip()]
+
+    with open(output_file, "w", encoding="utf-8") as outfile:
+        outfile.writelines(cleaned_lines)
+
+    return chunks
+
+
+def normalize_whitespace(match):
+    whitespace = match.group(0).replace("\t", "  ")
+    tab_count = len(whitespace) // 2
+    return "\t" * min(tab_count, 2)
+
+
+def chunk_poem_by_lines(lines, max_chunk_lines, overlap_lines):
+    """
+    Split a poem into chunks of manageable size, preserving lines and overlap for continuity.
+    """
+    chunks = []
+    for i in range(0, len(lines), max_chunk_lines - overlap_lines):
+        chunk = lines[i : i + max_chunk_lines]
+        chunks.append(chunk)
+    return chunks
+
+
+def generate_training_pairs(
+    poems, max_context_lines=10, max_chunk_lines=20, overlap_lines=10
+):
+    """
+    Generate input-output training pairs for poetry generation, using line-based chunking.
+    max_context_lines: The maximum number of lines to consider as context for the next line.
+    max_chunk_lines: The maximum number of lines to consider in a single chunk.
+    overlap_lines: The number of lines to overlap between chunks for continuity.
+
+
+    """
+    training_data = []
+
+    for poem in poems:
+        lines = poem.splitlines(keepends=True)
+
+        # Chunk the poem into manageable pieces
+        chunks = chunk_poem_by_lines(
+            lines, max_chunk_lines=max_chunk_lines, overlap_lines=overlap_lines
+        )
+
+        for chunk in chunks:
+            for i in range(1, len(chunk)):
+                input_lines = "".join(chunk[max(0, i - max_context_lines) : i])
+                output_line = chunk[i]  # The next line to predict
+                training_data.append({"input": input_lines, "output": output_line})
+
+    return training_data
+
+
+# Example usage
+poems = clean_text_file("leaves-of-grass-original.txt", "leaves-of-grass-cleaned.txt")
+
+# 400 poems
+print(f"Number of poems: {len(poems)}")
+
+# TODO: Implement generate_training_pairs
+# poems = poems[25:26]  # For testing purposes. Long poem.
+
+
+# Compact Poetry Model
+max_context_lines = 5
+max_chunk_lines = 10
+overlap_lines = 2
+
+"""
+# Narrative Poetry Model
+max_context_lines = 10
+max_chunk_lines = 20
+overlap_lines = 5
+"""
+
+"""
+# Epic or Free Verse Poetry 
+max_context_lines = 20
+max_chunk_lines = 50
+overlap_lines = 10
+"""
+
+training_data = generate_training_pairs(
+    poems,
+    max_context_lines=max_context_lines,
+    max_chunk_lines=max_chunk_lines,
+    overlap_lines=overlap_lines,
+)
+
+print(f"Number of training pairs: {len(training_data)}")
+
+# write the training data to a file
+with open("train.json", "w") as outfile:
+    json.dump(training_data, outfile, indent=2, ensure_ascii=False)