add pytorch manual method

.github/workflows/python-app.yaml

@@ -0,0 +1,29 @@
+# .github/workflows/python-app.yml
+
+name: Python application
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.8'
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -r requirements.txt
+        pip install pytest pytest-mock
+    - name: Run tests
+      run: |
+        pytest

.gitignore

@@ -0,0 +1 @@
+__pycache__

app.py

@@ -0,0 +1,8 @@
+from app.interface import create_interface
+
+def main():
+    interface = create_interface()
+    interface.launch()
+
+if __name__ == "__main__":
+    main()

app/interface.py

@@ -0,0 +1,113 @@
+import gradio as gr
+from .models import LanguageModel
+from .processing import process_file, process_text_input
+
+def create_interface():
+    # Initialize the language model
+    language_model = LanguageModel()
+
+    # Define the Output Format Selector
+    output_format_selector = gr.Radio(
+        choices=["CSV", "JSON"],
+        label="Select Output Format",
+        value="JSON",
+        type="value"
+    )
+
+    # Define the Output Flashcards
+    flashcard_output_file = gr.Textbox(
+        label="Flashcards",
+        lines=20,
+        placeholder="Extracted flashcards will appear here..."
+    )
+    flashcard_output_text = gr.Textbox(
+        label="Flashcards",
+        lines=20,
+        placeholder="Extracted flashcards will appear here..."
+    )
+
+    # Define the Gradio interface function for File Upload
+    def handle_file_upload(file_obj, output_format):
+        try:
+            flashcards = process_file(file_obj, output_format, language_model)
+            return flashcards
+        except ValueError as ve:
+            return str(ve)
+
+    # Define the Gradio interface function for Text Input
+    def handle_text_input(input_text, output_format):
+        try:
+            flashcards = process_text_input(input_text, output_format, language_model)
+            return flashcards
+        except ValueError as ve:
+            return str(ve)
+
+    # Create the Gradio Tabs
+    with gr.Blocks() as interface:
+        gr.Markdown("# Flashcard Extraction Tool")
+        gr.Markdown(
+            "Extract flashcards from uploaded files or directly input text. Choose your preferred output format."
+        )
+        with gr.Tab("Upload File"):
+            with gr.Row():
+                with gr.Column():
+                    file_input = gr.File(
+                        label="Upload a File",
+                        file_types=['.pdf', '.txt', '.md']
+                    )
+                    format_selector = gr.Radio(
+                        choices=["CSV", "JSON"],
+                        label="Select Output Format",
+                        value="JSON",
+                        type="value"
+                    )
+                    submit_file = gr.Button("Extract Flashcards")
+                with gr.Column():
+                    flashcard_output_file = gr.Textbox(
+                        label="Flashcards",
+                        lines=20,
+                        placeholder="Extracted flashcards will appear here..."
+                    )
+            submit_file.click(
+                fn=handle_file_upload,
+                inputs=[file_input, format_selector],
+                outputs=flashcard_output_file
+            )
+
+        with gr.Tab("Input Text"):
+            with gr.Row():
+                with gr.Column():
+                    text_input = gr.Textbox(
+                        label="Enter Text",
+                        lines=20,
+                        placeholder="Type or paste your text here..."
+                    )
+                    format_selector_text = gr.Radio(
+                        choices=["CSV", "JSON"],
+                        label="Select Output Format",
+                        value="JSON",
+                        type="value"
+                    )
+                    submit_text = gr.Button("Extract Flashcards")
+                with gr.Column():
+                    flashcard_output_text = gr.Textbox(
+                        label="Flashcards",
+                        lines=20,
+                        placeholder="Extracted flashcards will appear here..."
+                    )
+            submit_text.click(
+                fn=handle_text_input,
+                inputs=[text_input, format_selector_text],
+                outputs=flashcard_output_text
+            )
+
+        gr.Markdown(
+            """
+            ---
+            **Notes:**
+            - Supported file types: `.pdf`, `.txt`, `.md`.
+            - Ensure that the input text is clear and well-structured for optimal flashcard extraction.
+            """
+        )
+
+    return interface

app/models.py

@@ -0,0 +1,31 @@
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+class LanguageModel:
+    def __init__(self, model_name: str = "Qwen/Qwen2.5-7B-Instruct"):
+        self.device = self._determine_device()
+        self.model = AutoModelForCausalLM.from_pretrained(
+            model_name,
+            torch_dtype="auto",
+            device_map="auto"
+        )
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+
+    def _determine_device(self):
+        if torch.cuda.is_available():
+            return torch.device("cuda")
+        elif torch.backends.mps.is_available():
+            return torch.device("mps")
+        else:
+            return torch.device("cpu")
+
+    def generate_flashcards(self, prompt: str, max_new_tokens: int = 1024) -> str:
+        inputs = self.tokenizer(prompt, return_tensors='pt').to(self.model.device)
+        with torch.no_grad():
+            output_ids = self.model.generate(
+                inputs.input_ids,
+                max_new_tokens=max_new_tokens,
+                do_sample=True
+            )
+        response = self.tokenizer.decode(output_ids[0], skip_special_tokens=True)
+        return response

app/processing.py

@@ -0,0 +1,95 @@
+import os
+import pymupdf4llm
+
+def process_pdf(pdf_path: str) -> str:
+    """
+    Extracts text from a PDF file using pymupdf4llm.
+    """
+    try:
+        text = pymupdf4llm.extract_text(pdf_path)
+        return text
+    except Exception as e:
+        raise ValueError(f"Error processing PDF: {str(e)}")
+
+def read_text_file(file_path: str) -> str:
+    """
+    Reads text from a .txt or .md file.
+    """
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            text = f.read()
+        return text
+    except Exception as e:
+        raise ValueError(f"Error reading text file: {str(e)}")
+
+def format_prompt(output_format: str) -> str:
+    """
+    Formats the prompt based on the output type.
+    """
+    if output_format.lower() == "json":
+        return """You only respond with cards in JSON format. Follow the example below.
+
+    EXAMPLE:
+    [
+        {"question": "What is AI?", "answer": "Artificial Intelligence."},
+        {"question": "What is ML?", "answer": "Machine Learning."}
+        ...
+    ]
+    """
+    elif output_format.lower() == "csv":
+        return """You only respond with cards in CSV format. Follow the example below.
+
+    EXAMPLE:
+        "What is AI?", "Artificial Intelligence."
+        "What is ML?", "Machine Learning."
+        ...
+    """
+
+def extract_flashcards(text: str, output_format: str, language_model: str) -> str:
+    """
+    Extracts flashcards from the input text using the LLM and formats them in CSV or JSON.
+    """
+    prompt = f"""You are an expert flashcard creator. You always include a single knowledge item per flashcard.
+
+    {format_prompt(output_format)}
+
+
+    Extract flashcards from the user's text:
+
+    {text}
+
+    Do not include the prompt or any other unnecessary information in the flashcards.
+    Do not include triple ticks (```) or any other code blocks in the flashcards.
+    """
+    # TODO:
+    # see https://qwen.readthedocs.io/en/latest/inference/chat.html
+    # e.g. pipeline = pipeline("text-generation", model="Qwen/Qwen2.5-7B-Instruct")
+    response = language_model.generate_flashcards(prompt)
+    return response
+
+def process_file(file_obj, output_format: str, language_model) -> str:
+    """
+    Processes the uploaded file based on its type and extracts flashcards.
+    """
+    file_path = file_obj.name
+    file_ext = os.path.splitext(file_path)[1].lower()
+
+    if file_ext == '.pdf':
+        text = process_pdf(file_path)
+    elif file_ext in ['.txt', '.md']:
+        text = read_text_file(file_path)
+    else:
+        raise ValueError("Unsupported file type.")
+
+    flashcards = extract_flashcards(text, output_format, language_model)
+    return flashcards
+
+def process_text_input(input_text: str, output_format: str, language_model) -> str:
+    """
+    Processes the input text and extracts flashcards.
+    """
+    if not input_text.strip():
+        raise ValueError("No text provided.")
+
+    flashcards = extract_flashcards(input_text, output_format, language_model)
+    return flashcards

environment.yml

@@ -0,0 +1,19 @@
+name: flashcard-maker
+channels:
+  - conda-forge
+  - pytorch
+  - defaults
+dependencies:
+  - python=3.12
+  - torch
+  - torchvision
+  - torchaudio
+  - cudatoolkit=11.7  # Remove or adjust if installing CPU-only
+  - transformers
+  - gradio
+  - librosa
+  - pytest
+  - pytest-mock
+  - pip
+  - pip:
+    - pymupdf4llm

pytest.ini

@@ -0,0 +1,5 @@
+# pytest.ini
+
+[pytest]
+filterwarnings =
+    ignore::DeprecationWarning

requirements.txt

@@ -0,0 +1,7 @@
+pytorch
+transformers
+gradio
+librosa
+pymupdf4llm
+pytest
+pytest-mock        # Added for mocking capabilities

tests/conftest.py

@@ -0,0 +1,14 @@
+import pytest
+from unittest.mock import Mock
+from app.models import LanguageModel
+
+@pytest.fixture
+def language_model():
+    """
+    Fixture to provide a mocked LanguageModel instance.
+    """
+    # Create a mock instance of LanguageModel
+    lm = Mock(spec=LanguageModel)
+    # Mock the generate_flashcards method
+    lm.generate_flashcards.return_value = '{"flashcards": []}'
+    return lm

tests/test_models.py

@@ -0,0 +1,20 @@
+# tests/test_models.py
+
+import pytest
+
+def test_generate_flashcards(language_model, mocker):
+    """
+    Test the generate_flashcards method of LanguageModel.
+    """
+    prompt = "Sample prompt for flashcard generation."
+    expected_response = '{"flashcards": [{"Question": "What is AI?", "Answer": "Artificial Intelligence."}]}'
+
+    # Configure the mock to return a specific response
+    language_model.generate_flashcards.return_value = expected_response
+
+    # Call the method
+    response = language_model.generate_flashcards(prompt)
+
+    # Assertions
+    assert response == expected_response
+    language_model.generate_flashcards.assert_called_once_with(prompt)

tests/test_processing.py

@@ -0,0 +1,73 @@
+# tests/test_processing.py
+
+import pytest
+from app.processing import process_text_input, process_file
+
+def test_process_text_input_success(language_model):
+    """
+    Test processing of valid text input.
+    """
+    input_text = "This is a sample text for flashcard extraction."
+    output_format = "JSON"
+    expected_output = '{"flashcards": []}'
+
+    result = process_text_input(input_text, output_format, language_model)
+    assert result == expected_output
+    language_model.generate_flashcards.assert_called_once()
+
+def test_process_text_input_empty(language_model):
+    """
+    Test processing of empty text input.
+    """
+    input_text = "   "
+    output_format = "JSON"
+
+    with pytest.raises(ValueError) as excinfo:
+        process_text_input(input_text, output_format, language_model)
+    assert "No text provided." in str(excinfo.value)
+
+def test_process_file_unsupported_type(language_model, tmp_path):
+    """
+    Test processing of an unsupported file type.
+    """
+    # Create a dummy unsupported file
+    dummy_file = tmp_path / "dummy.unsupported"
+    dummy_file.write_text("Unsupported content")
+
+    with pytest.raises(ValueError) as excinfo:
+        process_file(dummy_file, "JSON", language_model)
+    assert "Unsupported file type." in str(excinfo.value)
+
+def test_process_file_pdf(language_model, tmp_path, mocker):
+    """
+    Test processing of a PDF file.
+    """
+    # Mock the process_pdf function
+    mocker.patch('app.processing.process_pdf', return_value="Extracted PDF text.")
+
+    # Create a dummy PDF file
+    dummy_file = tmp_path / "test.pdf"
+    dummy_file.write_text("PDF content")
+
+    expected_output = '{"flashcards": []}'
+
+    result = process_file(dummy_file, "JSON", language_model)
+    assert result == expected_output
+    language_model.generate_flashcards.assert_called_once()
+
+def test_process_file_txt(language_model, tmp_path, mocker):
+    """
+    Test processing of a TXT file.
+    """
+    # Mock the read_text_file function
+    mocker.patch('app.processing.read_text_file', return_value="Extracted TXT text.")
+
+    # Create a dummy TXT file
+    dummy_file = tmp_path / "test.txt"
+    dummy_file.write_text("TXT content")
+
+    expected_output = '{"flashcards": []}'
+
+    result = process_file(dummy_file, "JSON", language_model)
+    assert result == expected_output
+    language_model.generate_flashcards.assert_called_once()