initial commit

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,10 @@
+---
+title: ChessBot
+emoji: 💻
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+sdk_version: 4.28.3
+app_file: app.py
+pinned: false
+---

app.py

@@ -0,0 +1,131 @@
+import gradio as gr
+from sentence_transformers import SentenceTransformer, util
+import openai
+import os
+
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
+# Initialize paths and model identifiers for easy configuration and maintenance
+filename = "output_topic_details.txt"  # Path to the file storing chess-specific details
+retrieval_model_name = 'output/sentence-transformer-finetuned/'
+
+openai.api_key = os.environ["OPENAI_API_KEY"]
+
+# Attempt to load the necessary models and provide feedback on success or failure
+try:
+    retrieval_model = SentenceTransformer(retrieval_model_name)
+    print("Models loaded successfully.")
+except Exception as e:
+    print(f"Failed to load models: {e}")
+
+def load_and_preprocess_text(filename):
+    """
+    Load and preprocess text from a file, removing empty lines and stripping whitespace.
+    """
+    try:
+        with open(filename, 'r', encoding='utf-8') as file:
+            segments = [line.strip() for line in file if line.strip()]
+        print("Text loaded and preprocessed successfully.")
+        return segments
+    except Exception as e:
+        print(f"Failed to load or preprocess text: {e}")
+        return []
+
+segments = load_and_preprocess_text(filename)
+
+def find_relevant_segment(user_query, segments):
+    """
+    Find the most relevant text segment for a user's query using cosine similarity among sentence embeddings.
+    This version finds the best match based on the content of the query.
+    """
+    try:
+        # Lowercase the query for better matching
+        lower_query = user_query.lower()
+        
+        # Encode the query and the segments
+        query_embedding = retrieval_model.encode(lower_query)
+        segment_embeddings = retrieval_model.encode(segments)
+        
+        # Compute cosine similarities between the query and the segments
+        similarities = util.pytorch_cos_sim(query_embedding, segment_embeddings)[0]
+        
+        # Find the index of the most similar segment
+        best_idx = similarities.argmax()
+        
+        # Return the most relevant segment
+        return segments[best_idx]
+    except Exception as e:
+        print(f"Error in finding relevant segment: {e}")
+        return ""
+
+def generate_response(user_query, relevant_segment):
+    """
+    Generate a response emphasizing the bot's capability in providing chess information.
+    """
+    try:
+        system_message = "You are a chess chatbot specialized in providing information on chess rules, strategies, and terminology."
+        user_message = f"Here's the information on chess: {relevant_segment}"
+        messages = [
+            {"role": "system", "content": system_message},
+            {"role": "user", "content": user_message}
+        ]
+        response = openai.ChatCompletion.create(
+            model="gpt-3.5-turbo",
+            messages=messages,
+            max_tokens=150,
+            temperature=0.2,
+            top_p=1,
+            frequency_penalty=0,
+            presence_penalty=0
+        )
+        return response['choices'][0]['message']['content'].strip()
+    except Exception as e:
+        print(f"Error in generating response: {e}")
+        return f"Error in generating response: {e}"
+
+def query_model(question):
+    """
+    Process a question, find relevant information, and generate a response.
+    """
+    if question == "":
+        return "Welcome to ChessBot! Ask me anything about chess rules, strategies, and terminology."
+    relevant_segment = find_relevant_segment(question, segments)
+    if not relevant_segment:
+        return "Could not find specific information. Please refine your question."
+    response = generate_response(question, relevant_segment)
+    return response
+
+# Define the welcome message and specific topics the chatbot can provide information about
+welcome_message = """
+# ♟️ Welcome to ChessBot!
+
+## Your AI-driven assistant for all chess-related queries. Created by SCHOLAR1, SCHOLAR2, and SCHOLAR3 of the 2024 Kode With Klossy CITY Camp. 
+"""
+
+topics = """
+### Feel Free to ask me anything from the topics below!
+- Chess piece movements
+- Special moves
+- Game phases
+- Common strategies
+- Chess terminology
+- Famous games
+- Chess tactics
+"""
+
+# Setup the Gradio Blocks interface with custom layout components
+with gr.Blocks(theme='JohnSmith9982/small_and_pretty') as demo:
+    gr.Markdown(welcome_message)  # Display the formatted welcome message
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown(topics)  # Show the topics on the left side
+    with gr.Row():
+        with gr.Column():
+            question = gr.Textbox(label="Your question", placeholder="What do you want to ask about?")
+            answer = gr.Textbox(label="ChessBot Response", placeholder="ChessBot will respond here...", interactive=False, lines=10)
+            submit_button = gr.Button("Submit")
+            submit_button.click(fn=query_model, inputs=question, outputs=answer)
+    
+
+# Launch the Gradio app to allow user interaction
+demo.launch(share=True)

model_evaluation.py

@@ -0,0 +1,171 @@
+import pandas as pd
+from datasets import Dataset
+from transformers import pipeline, GPT2Tokenizer
+from sentence_transformers import SentenceTransformer, util
+
+# Define paths and models
+filename = "output_topic_details.txt"
+retrieval_model_name = 'output/sentence-transformer-finetuned/'       #using a prefine-tuned model
+gpt2_model_name = "gpt2"
+csv_file_path = "train_dataset.csv"
+output_csv_file_path = "updated_train_dataset.csv"
+val_csv_file_path = "val_dataset.csv"
+output_val_csv_file_path = "updated_val_csv.csv"
+
+tokenizer = GPT2Tokenizer.from_pretrained(gpt2_model_name)
+
+# Initialize models
+try:
+    retrieval_model = SentenceTransformer(retrieval_model_name)
+    gpt_model = pipeline("text-generation", model=gpt2_model_name)
+    print("Models loaded successfully.")
+except Exception as e:
+    print(f"Failed to load models: {e}")
+
+def load_and_preprocess_text(filename):
+    """
+    Load and preprocess text data from a file.
+
+    Parameters:
+    - filename (str): Path to the text file.
+
+    Returns:
+    - list[str]: A list of preprocessed text segments.
+    """
+    try:
+        with open(filename, 'r', encoding='utf-8') as file:
+            segments = [line.strip() for line in file if line.strip()]
+        print("Text loaded and preprocessed successfully.")
+        return segments
+    except Exception as e:
+        print(f"Failed to load or preprocess text: {e}")
+        return []
+
+segments = load_and_preprocess_text(filename)
+
+def find_relevant_segment(user_query, segments):
+    """
+    Find the most relevant text segment based on a user query.
+
+    Parameters:
+    - user_query (str): The user's query.
+    - segments (list[str]): List of text segments to search within.
+
+    Returns:
+    - str: The most relevant text segment.
+    """
+    try:
+        query_embedding = retrieval_model.encode(user_query)
+        segment_embeddings = retrieval_model.encode(segments)
+        similarities = util.pytorch_cos_sim(query_embedding, segment_embeddings)[0]
+        best_idx = similarities.argmax()
+        return segments[best_idx]
+    except Exception as e:
+        print(f"Error finding relevant segment: {e}")
+        return ""
+
+def generate_response(question):
+    """
+    Generate a response to a given question by finding a relevant text segment and
+    using it to generate a more complete answer.
+
+    Parameters:
+    - question (str): The user's question.
+
+    Returns:
+    - str: Generated response.
+    """
+    relevant_segment = find_relevant_segment(question, segments)
+    return generate_response_with_context(question, relevant_segment)
+
+def generate_response_with_context(user_query, relevant_segment):
+    """
+    Generate a response based on a user query and a relevant segment.
+
+    Parameters:
+    - user_query (str): The user's query.
+    - relevant_segment (str): A relevant fact or detail.
+
+    Returns:
+    - str: Formatted response incorporating the relevant segment.
+    """
+    try:
+        prompt = f"Thank you for your question! Here is an additional fact about your topic: {relevant_segment}"
+        max_tokens = len(tokenizer(prompt)['input_ids']) + 50
+        response = gpt_model(prompt, max_length=max_tokens, temperature=0.25)[0]['generated_text']
+        return clean_up_response(response, relevant_segment)
+    except Exception as e:
+        print(f"Error generating response: {e}")
+        return ""
+
+def clean_up_response(response, segment):
+    """
+    Clean up the generated response to ensure it is tidy and presentable.
+
+    Parameters:
+    - response (str): The initial response generated by the model.
+    - segment (str): The segment used to generate the response.
+
+    Returns:
+    - str: A cleaned and formatted response.
+    """
+    sentences = response.split('.')
+    cleaned_sentences = [sentence.strip() for sentence in sentences if sentence.strip() and sentence.strip() not in segment]
+    cleaned_response = '. '.join(cleaned_sentences).strip()
+    if cleaned_response and not cleaned_response.endswith((".", "!", "?")):
+        cleaned_response += "."
+    return cleaned_response
+
+def process_dataset(csv_file_path, output_csv_file_path):
+    """
+    Process the dataset by generating responses and evaluating their similarities.
+
+    Parameters:
+    - csv_file_path (str): Path to the CSV file containing the dataset.
+    - output_csv_file_path (str): Path where the updated dataset will be saved.
+
+    Prints:
+    - Path to the saved results and the average similarity score.
+    """
+    df = pd.read_csv(csv_file_path)
+    dataset = Dataset.from_pandas(df)
+    updated_dataset = add_model_answers(dataset)
+    similarities = evaluate_similarity(updated_dataset)
+    updated_dataset = updated_dataset.add_column("similarity", similarities)
+    results_df = updated_dataset.to_pandas()
+    results_df.to_csv(output_csv_file_path, index=False)
+    average_similarity = sum(similarities) / len(similarities) if similarities else 0
+    print(f"Results saved to {output_csv_file_path}")
+    print(f"Average Similarity Score: {average_similarity:.3f}")
+
+def add_model_answers(dataset):
+    """
+    Add generated answers to the dataset.
+
+    Parameters:
+    - dataset (datasets.Dataset): The Hugging Face dataset object.
+
+    Returns:
+    - datasets.Dataset: Updated dataset with added answers.
+    """
+    answers = [generate_response(q) for q in dataset['Question']]
+    dataset = dataset.add_column("Answer", answers)
+    return dataset
+
+def evaluate_similarity(dataset):
+    """
+    Evaluate the similarity of generated answers against ground truth answers.
+
+    Parameters:
+    - dataset (datasets.Dataset): The dataset containing both answers and ground truths.
+
+    Returns:
+    - list[float]: List of similarity scores.
+    """
+    similarities = [util.pytorch_cos_sim(retrieval_model.encode(ans), retrieval_model.encode(gt))[0][0].item()
+                    for ans, gt in zip(dataset['Answer'], dataset['GroundTruth'])]
+    return similarities
+
+# Process datasets
+process_dataset(csv_file_path, output_csv_file_path)
+process_dataset(val_csv_file_path, output_val_csv_file_path)

output/sentence-transformer-finetuned.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f96b8ce2ece5d1c766d1169b278147d4f509326274d50725663061b7c4e0c5d3
+size 83608461

output/sentence-transformer-finetuned/1_Pooling/config.json

@@ -0,0 +1,10 @@
+{
+  "word_embedding_dimension": 384,
+  "pooling_mode_cls_token": false,
+  "pooling_mode_mean_tokens": true,
+  "pooling_mode_max_tokens": false,
+  "pooling_mode_mean_sqrt_len_tokens": false,
+  "pooling_mode_weightedmean_tokens": false,
+  "pooling_mode_lasttoken": false,
+  "include_prompt": true
+}

output/sentence-transformer-finetuned/README.md

@@ -0,0 +1,89 @@
+---
+library_name: sentence-transformers
+pipeline_tag: sentence-similarity
+tags:
+- sentence-transformers
+- feature-extraction
+- sentence-similarity
+
+---
+
+# {MODEL_NAME}
+
+This is a [sentence-transformers](https://www.SBERT.net) model: It maps sentences & paragraphs to a 384 dimensional dense vector space and can be used for tasks like clustering or semantic search.
+
+<!--- Describe your model here -->
+
+## Usage (Sentence-Transformers)
+
+Using this model becomes easy when you have [sentence-transformers](https://www.SBERT.net) installed:
+
+```
+pip install -U sentence-transformers
+```
+
+Then you can use the model like this:
+
+```python
+from sentence_transformers import SentenceTransformer
+sentences = ["This is an example sentence", "Each sentence is converted"]
+
+model = SentenceTransformer('{MODEL_NAME}')
+embeddings = model.encode(sentences)
+print(embeddings)
+```
+
+
+
+## Evaluation Results
+
+<!--- Describe how your model was evaluated -->
+
+For an automated evaluation of this model, see the *Sentence Embeddings Benchmark*: [https://seb.sbert.net](https://seb.sbert.net?model_name={MODEL_NAME})
+
+
+## Training
+The model was trained with the parameters:
+
+**DataLoader**:
+
+`torch.utils.data.dataloader.DataLoader` of length 51 with parameters:
+```
+{'batch_size': 16, 'sampler': 'torch.utils.data.sampler.RandomSampler', 'batch_sampler': 'torch.utils.data.sampler.BatchSampler'}
+```
+
+**Loss**:
+
+`sentence_transformers.losses.CosineSimilarityLoss.CosineSimilarityLoss` 
+
+Parameters of the fit()-Method:
+```
+{
+    "epochs": 4,
+    "evaluation_steps": 0,
+    "evaluator": "NoneType",
+    "max_grad_norm": 1,
+    "optimizer_class": "<class 'torch.optim.adamw.AdamW'>",
+    "optimizer_params": {
+        "lr": 2e-05
+    },
+    "scheduler": "WarmupLinear",
+    "steps_per_epoch": null,
+    "warmup_steps": 100,
+    "weight_decay": 0.01
+}
+```
+
+
+## Full Model Architecture
+```
+SentenceTransformer(
+  (0): Transformer({'max_seq_length': 256, 'do_lower_case': False}) with Transformer model: BertModel 
+  (1): Pooling({'word_embedding_dimension': 384, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
+  (2): Normalize()
+)
+```
+
+## Citing & Authors
+
+<!--- Describe where people can find more information -->

output/sentence-transformer-finetuned/config.json

@@ -0,0 +1,26 @@
+{
+  "_name_or_path": "sentence-transformers/all-MiniLM-L6-v2",
+  "architectures": [
+    "BertModel"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "classifier_dropout": null,
+  "gradient_checkpointing": false,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 384,
+  "initializer_range": 0.02,
+  "intermediate_size": 1536,
+  "layer_norm_eps": 1e-12,
+  "max_position_embeddings": 512,
+  "model_type": "bert",
+  "num_attention_heads": 12,
+  "num_hidden_layers": 6,
+  "pad_token_id": 0,
+  "position_embedding_type": "absolute",
+  "torch_dtype": "float32",
+  "transformers_version": "4.39.3",
+  "type_vocab_size": 2,
+  "use_cache": true,
+  "vocab_size": 30522
+}

output/sentence-transformer-finetuned/config_sentence_transformers.json

@@ -0,0 +1,9 @@
+{
+  "__version__": {
+    "sentence_transformers": "2.0.0",
+    "transformers": "4.6.1",
+    "pytorch": "1.8.1"
+  },
+  "prompts": {},
+  "default_prompt_name": null
+}

output/sentence-transformer-finetuned/model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6e55e6c6bb6150eed6b877a2ae6a897cfcfe236c6395cee0e7f5b952541954cf
+size 90864192

output/sentence-transformer-finetuned/modules.json

@@ -0,0 +1,20 @@
+[
+  {
+    "idx": 0,
+    "name": "0",
+    "path": "",
+    "type": "sentence_transformers.models.Transformer"
+  },
+  {
+    "idx": 1,
+    "name": "1",
+    "path": "1_Pooling",
+    "type": "sentence_transformers.models.Pooling"
+  },
+  {
+    "idx": 2,
+    "name": "2",
+    "path": "2_Normalize",
+    "type": "sentence_transformers.models.Normalize"
+  }
+]

output/sentence-transformer-finetuned/sentence_bert_config.json

@@ -0,0 +1,4 @@
+{
+  "max_seq_length": 256,
+  "do_lower_case": false
+}

output/sentence-transformer-finetuned/special_tokens_map.json

@@ -0,0 +1,37 @@
+{
+  "cls_token": {
+    "content": "[CLS]",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "mask_token": {
+    "content": "[MASK]",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": {
+    "content": "[PAD]",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "sep_token": {
+    "content": "[SEP]",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "unk_token": {
+    "content": "[UNK]",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}

output/sentence-transformer-finetuned/tokenizer_config.json

@@ -0,0 +1,64 @@
+{
+  "added_tokens_decoder": {
+    "0": {
+      "content": "[PAD]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "100": {
+      "content": "[UNK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "101": {
+      "content": "[CLS]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "102": {
+      "content": "[SEP]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "103": {
+      "content": "[MASK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "clean_up_tokenization_spaces": true,
+  "cls_token": "[CLS]",
+  "do_basic_tokenize": true,
+  "do_lower_case": true,
+  "mask_token": "[MASK]",
+  "max_length": 128,
+  "model_max_length": 512,
+  "never_split": null,
+  "pad_to_multiple_of": null,
+  "pad_token": "[PAD]",
+  "pad_token_type_id": 0,
+  "padding_side": "right",
+  "sep_token": "[SEP]",
+  "stride": 0,
+  "strip_accents": null,
+  "tokenize_chinese_chars": true,
+  "tokenizer_class": "BertTokenizer",
+  "truncation_side": "right",
+  "truncation_strategy": "longest_first",
+  "unk_token": "[UNK]"
+}

requirements.txt

@@ -0,0 +1,115 @@
+accelerate==0.29.2
+aiofiles==23.2.1
+aiohttp==3.9.4
+aiosignal==1.3.1
+altair==5.3.0
+annotated-types==0.6.0
+anyio==4.3.0
+appnope==0.1.4
+asttokens==2.4.1
+attrs==23.2.0
+certifi==2024.2.2
+charset-normalizer==3.3.2
+click==8.1.7
+comm==0.2.2
+contourpy==1.2.1
+cycler==0.12.1
+datasets==2.18.0
+debugpy==1.8.1
+decorator==5.1.1
+dill==0.3.8
+executing==2.0.1
+fastapi==0.110.1
+ffmpy==0.3.2
+filelock==3.13.4
+fonttools==4.51.0
+frozenlist==1.4.1
+fsspec==2024.2.0
+gradio==4.26.0
+gradio_client==0.15.1
+h11==0.14.0
+httpcore==1.0.5
+httpx==0.27.0
+huggingface-hub==0.22.2
+idna==3.7
+importlib_resources==6.4.0
+ipykernel==6.29.4
+ipython==8.23.0
+jedi==0.19.1
+Jinja2==3.1.3
+joblib==1.4.0
+jsonschema==4.21.1
+jsonschema-specifications==2023.12.1
+jupyter_client==8.6.1
+jupyter_core==5.7.2
+kiwisolver==1.4.5
+markdown-it-py==3.0.0
+MarkupSafe==2.1.5
+matplotlib==3.8.4
+matplotlib-inline==0.1.6
+mdurl==0.1.2
+mpmath==1.3.0
+multidict==6.0.5
+multiprocess==0.70.16
+nest-asyncio==1.6.0
+networkx==3.3
+numpy==1.26.4
+orjson==3.10.0
+packaging==24.0
+pandas==2.2.2
+parso==0.8.4
+pexpect==4.9.0
+pillow==10.3.0
+platformdirs==4.2.0
+prompt-toolkit==3.0.43
+psutil==5.9.8
+ptyprocess==0.7.0
+pure-eval==0.2.2
+pyarrow==15.0.2
+pyarrow-hotfix==0.6
+pydantic==2.7.0
+pydantic_core==2.18.1
+pydub==0.25.1
+Pygments==2.17.2
+pyparsing==3.1.2
+python-dateutil==2.9.0.post0
+python-multipart==0.0.9
+pytz==2024.1
+PyYAML==6.0.1
+pyzmq==25.1.2
+referencing==0.34.0
+regex==2023.12.25
+requests==2.31.0
+rich==13.7.1
+rpds-py==0.18.0
+ruff==0.3.7
+safetensors==0.4.2
+scikit-learn==1.4.2
+scipy==1.13.0
+semantic-version==2.10.0
+sentence-transformers==2.6.1
+shellingham==1.5.4
+six==1.16.0
+sniffio==1.3.1
+stack-data==0.6.3
+starlette==0.37.2
+sympy==1.12
+threadpoolctl==3.4.0
+tokenizers==0.15.2
+tomlkit==0.12.0
+toolz==0.12.1
+torch==2.2.2
+tornado==6.4
+tqdm==4.66.2
+traitlets==5.14.2
+transformers==4.39.3
+typer==0.12.3
+typing_extensions==4.11.0
+tzdata==2024.1
+urllib3==2.2.1
+uvicorn==0.29.0
+wcwidth==0.2.13
+websockets==11.0.3
+xxhash==3.4.1
+yarl==1.9.4
+openai==0.28

test_dataset.csv

@@ -0,0 +1,21 @@
+Question,GroundTruth
+How does a pawn move in chess?,"A pawn moves forward one square, but it captures diagonally. On its first move, a pawn can move forward two squares."
+What are the basic moves of a king in chess?,"The king moves one square in any direction: horizontally, vertically, or diagonally."
+How does a knight move in chess?,"The knight moves in an L-shape: two squares in one direction and then one square perpendicular, or one square in one direction and then two squares perpendicular."
+What is castling in chess?,"Castling is a move that involves the king moving two squares towards a rook on the player's first rank, then the rook moving to the square over which the king crossed."
+What is a check in chess?,"A check is a situation where a king is under threat of being captured on the next move."
+How do you win a game of chess?,"A game of chess is won by checkmating your opponent's king, which means the king is in a position to be captured and cannot escape."
+What is a stalemate in chess?,"A stalemate occurs when the player whose turn it is to move has no legal move and their king is not in check. It results in a draw."
+What is en passant in chess?,"En passant is a special pawn capture that can occur if a pawn moves two squares forward from its starting position and lands beside an opponent's pawn."
+What is the purpose of a chess clock?,"A chess clock is used to track the total time each player takes for their moves. If a player's time runs out, they lose the game."
+What is a fork in chess?,"A fork is a tactic where a single piece attacks two or more of the opponent's pieces at the same time."
+How does a bishop move in chess?,"A bishop moves diagonally any number of squares, but cannot jump over other pieces."
+What is a pin in chess?,"A pin occurs when a piece cannot move without exposing a more valuable piece, like the king or queen, to attack."
+What is a discovered check in chess?,"A discovered check happens when a piece moves, revealing an attack on the opponent's king by another piece."
+How does a rook move in chess?,"A rook moves any number of squares along a row or column."
+What is a gambit in chess?,"A gambit is a chess opening in which a player sacrifices material, usually a pawn, with the hope of achieving a subsequent advantageous position."
+What is the fifty-move rule in chess?,"The fifty-move rule allows a player to claim a draw if no pawn has been moved and no capture has been made in the last fifty moves by each player."
+What is the difference between check and checkmate?,"Check is when the king is in danger but can still escape, whereas checkmate is when the king is in danger and cannot escape."
+How does a queen move in chess?,"The queen can move any number of squares along a row, column, or diagonal."
+What is a perpetual check in chess?,"Perpetual check is a situation in which one player can check the opponent's king continuously, resulting in a draw if it occurs three times."
+What are the three phases of a chess game?,"The three phases of a chess game are the opening, the middlegame, and the endgame."

train_dataset.csv

@@ -0,0 +1,14 @@
+Question,GroundTruth
+What is the best opening move for white?,"The best opening move for white is often considered to be 1. e4, aiming to control the center and open lines for the queen and bishop."
+What are the common responses to 1. e4?,"Common responses to 1. e4 include 1... e5, 1... c5 (Sicilian Defense), 1... e6 (French Defense), and 1... c6 (Caro-Kann Defense)."
+How do I play the Sicilian Defense?,"To play the Sicilian Defense, respond to 1. e4 with 1... c5, aiming to challenge white's control of the center and create an asymmetrical pawn structure."
+What is a good strategy for the middle game?,"A good strategy for the middle game includes developing your pieces to active squares, controlling the center, coordinating your pieces for potential attacks, and ensuring king safety."
+How can I effectively coordinate an attack?,"To effectively coordinate an attack, focus on piece activity, look for weaknesses in your opponent's position, and try to double your rooks or align them with your queen for combined threats."
+What should I focus on in the endgame?,"In the endgame, focus on king activity, promoting pawns, and creating passed pawns. It's crucial to centralize your king and use it actively in the fight."
+How do I achieve a checkmate with a king and rook against a lone king?,"To achieve checkmate with a king and rook against a lone king, force the opposing king to the edge of the board and use your king and rook to create a checkmate pattern, often referred to as the 'box' method."
+What is the Lucena position?,"The Lucena position is a winning technique in rook endgames where the stronger side's king is cut off by a file, and the winning side uses the rook to build a 'bridge' for the king to support the promotion of a pawn."
+How do I play the Philidor position?,"The Philidor position is a defensive technique in rook endgames where the defender places the rook on the third rank, preventing the opposing king from advancing and thus creating a draw by maintaining the position."
+What is a pin in chess?,"A pin in chess is a tactic where a piece cannot move without exposing a more valuable piece behind it to capture. Pins can be absolute, where the pinned piece is in front of the king, or relative, involving other pieces."
+How do I use a fork in chess?,"A fork is a tactic where a single piece, often a knight, attacks two or more of the opponent's pieces simultaneously, creating a scenario where the opponent cannot defend both pieces effectively."
+How can I improve my chess rating?,"To improve your chess rating, study opening theory, practice middle game tactics, and learn endgame techniques. Regularly playing games, analyzing your losses, and solving chess puzzles can also help improve your skills."
+What resources are good for learning chess?,"Good resources for learning chess include online platforms like Chess.com and Lichess.org, books such as 'My System' by Aron Nimzowitsch and 'Chess Fundamentals' by José Capablanca, and video lessons from experienced players."

val_dataset.csv

@@ -0,0 +1,12 @@
+Question,GroundTruth
+What are the rules for castling in chess?,"Castling is a special move in chess that involves the king and one of the rooks. The king moves two squares towards the rook, and the rook moves to the square next to the king. Certain conditions must be met: neither the king nor the rook involved has previously moved, there are no pieces between the king and the rook, the king is not in check, and the squares the king moves across are not under attack."
+How does en passant work in chess?,"En passant is a special pawn capture in chess. It occurs when a pawn moves two squares forward from its starting position and lands beside an opponent's pawn. The opponent's pawn can capture the moving pawn as if it had moved only one square. This capture must be made immediately on the next move."
+What is the purpose of a pawn promotion?,"Pawn promotion occurs when a pawn reaches the farthest rank from its starting position. The pawn can then be promoted to any other piece, except a king, typically a queen. This is to reward the player for advancing the pawn so far across the board, significantly increasing the material advantage."
+Can you explain stalemate in chess?,"A stalemate in chess occurs when a player has no legal moves and their king is not in check. This situation results in a draw. It often happens in endgames when one side has few pieces left and is unable to make a legal move without placing their king in check."
+What constitutes checkmate in chess?,"Checkmate occurs when a player's king is in a position to be captured (in check) and there is no legal move to remove the threat of capture. This results in a win for the player delivering the checkmate."
+How does the fifty-move rule work in chess?,"The fifty-move rule in chess allows a player to claim a draw if no pawn movement or capture has been made in the last fifty moves by either player. This rule is intended to prevent endlessly drawn-out games."
+What is the basic strategy for the opening phase in chess?,"In the opening phase of chess, the basic strategy includes controlling the center of the board, developing your pieces (knights and bishops), and ensuring the king's safety, usually by castling. Developing pawns and pieces to active squares helps in controlling the game from the start."
+How do you perform a fork in chess?,"A fork in chess is a tactic where a single piece makes two or more direct attacks simultaneously. Knights are particularly effective at forking because they can attack pieces in different directions that are not aligned. Other pieces can also fork by targeting multiple high-value pieces at once."
+What is a pin in chess?,"A pin in chess is a tactic where a piece cannot move without exposing a more valuable piece behind it to capture. For example, a bishop can pin a knight to a king if moving the knight would place the king in check."
+Explain the concept of zugzwang in chess?,"Zugzwang is a situation in chess where a player is put at a disadvantage because they must make a move, even though any move will worsen their position. It often occurs in endgames, where any move a player makes will lead to a weaker position or a loss."
+