Initial commit for GPT

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* 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
+*.csv filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,160 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

analysis.ipynb

@@ -0,0 +1,324 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "df_input = pd.read_csv('sampled_data.csv')\n",
+    "df_inferenced = pd.read_csv('inference_output.csv')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 59,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1000\n",
+      "1000\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(len(df_input))\n",
+    "print(len(df_inferenced))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 60,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_combined = pd.concat([df_input, df_inferenced], axis=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 61,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>title</th>\n",
+       "      <th>text</th>\n",
+       "      <th>label</th>\n",
+       "      <th>Output</th>\n",
+       "      <th>Tokens Used</th>\n",
+       "      <th>Finish Reason</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Live at Truthdig: Robert Scheer and Thomas Fra...</td>\n",
+       "      <td>Live at Truthdig: Robert Scheer and Thomas Fra...</td>\n",
+       "      <td>0</td>\n",
+       "      <td>Real</td>\n",
+       "      <td>265</td>\n",
+       "      <td>stop</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>The Mirage of a Return to Manufacturing Greatn...</td>\n",
+       "      <td>Half a century ago, harvesting California’s 2....</td>\n",
+       "      <td>1</td>\n",
+       "      <td>Real</td>\n",
+       "      <td>1627</td>\n",
+       "      <td>stop</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>British PM expected to offer to fill post-Brex...</td>\n",
+       "      <td>(Reuters) - The British government has told Ge...</td>\n",
+       "      <td>1</td>\n",
+       "      <td>fake</td>\n",
+       "      <td>200</td>\n",
+       "      <td>stop</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>Checkmating Obama</td>\n",
+       "      <td>Originally published by the Jerusalem Post . \\...</td>\n",
+       "      <td>0</td>\n",
+       "      <td>fake</td>\n",
+       "      <td>2166</td>\n",
+       "      <td>stop</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>Thirty-eight injured in police charges in Cata...</td>\n",
+       "      <td>MADRID (Reuters) - Emergency services have att...</td>\n",
+       "      <td>1</td>\n",
+       "      <td>Real</td>\n",
+       "      <td>176</td>\n",
+       "      <td>stop</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                                               title  \\\n",
+       "0  Live at Truthdig: Robert Scheer and Thomas Fra...   \n",
+       "1  The Mirage of a Return to Manufacturing Greatn...   \n",
+       "2  British PM expected to offer to fill post-Brex...   \n",
+       "3                                  Checkmating Obama   \n",
+       "4  Thirty-eight injured in police charges in Cata...   \n",
+       "\n",
+       "                                                text  label Output  \\\n",
+       "0  Live at Truthdig: Robert Scheer and Thomas Fra...      0   Real   \n",
+       "1  Half a century ago, harvesting California’s 2....      1   Real   \n",
+       "2  (Reuters) - The British government has told Ge...      1   fake   \n",
+       "3  Originally published by the Jerusalem Post . \\...      0   fake   \n",
+       "4  MADRID (Reuters) - Emergency services have att...      1   Real   \n",
+       "\n",
+       "   Tokens Used Finish Reason  \n",
+       "0          265          stop  \n",
+       "1         1627          stop  \n",
+       "2          200          stop  \n",
+       "3         2166          stop  \n",
+       "4          176          stop  "
+      ]
+     },
+     "execution_count": 61,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df_combined.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 62,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array(['stop', 'length'], dtype=object)"
+      ]
+     },
+     "execution_count": 62,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df_combined[\"Finish Reason\"].unique()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 63,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "994"
+      ]
+     },
+     "execution_count": 63,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df_combined = df_combined[df_combined[\"Finish Reason\"] != \"length\"]\n",
+    "len(df_combined)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_combined.drop(columns=[\"title\", \"text\", \"Tokens Used\", \"Finish Reason\"], inplace=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 66,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\kimi\\AppData\\Local\\Temp\\ipykernel_31372\\3169472720.py:2: DeprecationWarning: In a future version, `df.iloc[:, i] = newvals` will attempt to set the values inplace instead of always setting a new array. To retain the old behavior, use either `df[df.columns[i]] = newvals` or, if columns are non-unique, `df.isetitem(i, newvals)`\n",
+      "  df_combined.loc[:, \"Output\"] = df_combined[\"Output\"].str.strip().str.lower().map({\"real\": 1, \"fake\": 0})\n"
+     ]
+    }
+   ],
+   "source": [
+    "df_combined = df_combined.copy()\n",
+    "df_combined.loc[:, \"Output\"] = df_combined[\"Output\"].str.strip().str.lower().map({\"real\": 1, \"fake\": 0})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 68,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "994"
+      ]
+     },
+     "execution_count": 68,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(df_combined)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 70,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Accuracy: 0.7323943661971831\n",
+      "F1 Score: 0.5969696969696969\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\kimi\\AppData\\Local\\Temp\\ipykernel_31372\\2541391757.py:14: MatplotlibDeprecationWarning: The seaborn styles shipped by Matplotlib are deprecated since 3.6, as they no longer correspond to the styles shipped by seaborn. However, they will remain available as 'seaborn-v0_8-<style>'. Alternatively, directly use the seaborn API instead.\n",
+      "  plt.style.use(\"seaborn-whitegrid\")\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import pandas as pd\n",
+    "from sklearn.metrics import accuracy_score, f1_score, confusion_matrix\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "\n",
+    "accuracy = accuracy_score(df_combined[\"label\"], df_combined[\"Output\"])\n",
+    "f1 = f1_score(df_combined[\"label\"], df_combined[\"Output\"])\n",
+    "\n",
+    "print(f\"Accuracy: {accuracy}\")\n",
+    "print(f\"F1 Score: {f1}\")\n",
+    "\n",
+    "conf_matrix = confusion_matrix(df_combined[\"label\"], df_combined[\"Output\"])\n",
+    "\n",
+    "plt.style.use(\"seaborn-whitegrid\")\n",
+    "plt.figure(figsize=(8, 6))\n",
+    "sns.heatmap(conf_matrix, annot=True, fmt=\"d\", cmap=\"Blues\")\n",
+    "plt.title(\"Confusion Matrix (GPT-4 Turbo)\")\n",
+    "plt.ylabel(\"True Label\")\n",
+    "plt.xlabel(\"Predicted Label\")\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "torch",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

data_2/WELFake_Dataset.csv

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

data_3/news_articles.csv

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

inference.py

@@ -0,0 +1,56 @@
+from openai import OpenAI
+import os
+import csv
+import pandas as pd
+
+df = pd.read_csv("sampled_data.csv")
+
+df["text"] = df["text"].str.replace(
+    r"(\b[A-Z]{2,}(?:\s[A-Z]{2,})*\s\(Reuters\)\s-|\(Reuters\))", "", regex=True
+)
+
+df["text"] = df["text"].str.replace(r"Featured image via .+?\.($|\s)", "", regex=True)
+
+df["text"] = df["title"] + " " + df["text"]
+
+df = df[["text", "label"]]
+
+client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))
+
+system_prompt = """You are an expert in identifying fake news and disinformation. Please identify whether the piece of news is real or fake.
+Please think step-by-step as you answer the question. However, please only respond with 'real' if the news is real or 'fake' if the news is fake.
+Do not respond with any other words or phrases.
+If you are unsure if the news is real or fake, please still make an educational guess."""
+
+for i in range(961, len(df)):
+    response = client.chat.completions.create(
+        model="gpt-4-1106-preview",
+        max_tokens=10,
+        messages=[
+            {
+                "role": "system",
+                "content": system_prompt,
+            },
+            {
+                "role": "user",
+                "content": str(df.iloc[i]["text"]),
+            },
+        ],
+    )
+    # Extract the response message
+    output = response.choices[0].message.content
+    tokens_used = response.usage.total_tokens
+    finish_reason = response.choices[0].finish_reason
+
+    with open("inference_output.csv", "a", newline="", encoding="utf-8") as file:
+        writer = csv.writer(file)
+
+        # If the file is empty, write a header
+        if file.tell() == 0:
+            writer.writerow(["Output", "Tokens Used", "Finish Reason"])
+
+        # Write the data
+        writer.writerow([output, tokens_used, finish_reason])
+
+    if i % 50 == 0:
+        print(f"Batch: {i} / {len(df)}")

inference_output.csv

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

preprocessing.ipynb

@@ -0,0 +1,181 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import numpy as np"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load the datasets\n",
+    "df_1 = pd.read_csv(\"data_2/WELFake_Dataset.csv\")\n",
+    "df_2 = pd.read_csv(\"data_3/news_articles.csv\")\n",
+    "\n",
+    "# Drop index\n",
+    "df_1.drop(df_1.columns[0], axis=1, inplace=True)\n",
+    "df_1.dropna(inplace=True)\n",
+    "\n",
+    "# Swapping labels around since it originally is the opposite\n",
+    "df_1[\"label\"] = df_1[\"label\"].map({0: 1, 1: 0})\n",
+    "\n",
+    "# Add labels\n",
+    "df_2.drop(\n",
+    "    columns=[\n",
+    "        \"author\",\n",
+    "        \"published\",\n",
+    "        \"site_url\",\n",
+    "        \"main_img_url\",\n",
+    "        \"type\",\n",
+    "        \"text_without_stopwords\",\n",
+    "        \"title_without_stopwords\",\n",
+    "        \"hasImage\",\n",
+    "    ],\n",
+    "    inplace=True,\n",
+    ")\n",
+    "# Map Real to 1 and Fake to 0\n",
+    "df_2[\"label\"] = df_2[\"label\"].map({\"Real\": 1, \"Fake\": 0})\n",
+    "df_2 = df_2[df_2[\"label\"].isin([1, 0])]\n",
+    "\n",
+    "# Drop rows where the language is not 'english'\n",
+    "df_2 = df_2[df_2[\"language\"] == \"english\"]\n",
+    "df_2.drop(columns=[\"language\"], inplace=True)\n",
+    "\n",
+    "# Convert \"no title\" to empty string\n",
+    "df_2[\"title\"] = df_2[\"title\"].apply(lambda x: \"\" if x == \"no title\" else x)\n",
+    "\n",
+    "df_2.dropna(inplace=True)\n",
+    "\n",
+    "random_1 = df_1.sample(n=500, random_state=42)\n",
+    "random_2 = df_2.sample(n=500, random_state=42)\n",
+    "\n",
+    "# Combine the datasets\n",
+    "df = pd.concat([random_1, random_2], ignore_index=True)\n",
+    "\n",
+    "df[\"label\"] = df[\"label\"].astype(int)\n",
+    "\n",
+    "df.to_csv(\"sampled_data.csv\", index=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>title</th>\n",
+       "      <th>text</th>\n",
+       "      <th>label</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Live at Truthdig: Robert Scheer and Thomas Fra...</td>\n",
+       "      <td>Live at Truthdig: Robert Scheer and Thomas Fra...</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>The Mirage of a Return to Manufacturing Greatn...</td>\n",
+       "      <td>Half a century ago, harvesting California’s 2....</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>British PM expected to offer to fill post-Brex...</td>\n",
+       "      <td>(Reuters) - The British government has told Ge...</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>Checkmating Obama</td>\n",
+       "      <td>Originally published by the Jerusalem Post . \\...</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>Thirty-eight injured in police charges in Cata...</td>\n",
+       "      <td>MADRID (Reuters) - Emergency services have att...</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                                               title  \\\n",
+       "0  Live at Truthdig: Robert Scheer and Thomas Fra...   \n",
+       "1  The Mirage of a Return to Manufacturing Greatn...   \n",
+       "2  British PM expected to offer to fill post-Brex...   \n",
+       "3                                  Checkmating Obama   \n",
+       "4  Thirty-eight injured in police charges in Cata...   \n",
+       "\n",
+       "                                                text  label  \n",
+       "0  Live at Truthdig: Robert Scheer and Thomas Fra...      0  \n",
+       "1  Half a century ago, harvesting California’s 2....      1  \n",
+       "2  (Reuters) - The British government has told Ge...      1  \n",
+       "3  Originally published by the Jerusalem Post . \\...      0  \n",
+       "4  MADRID (Reuters) - Emergency services have att...      1  "
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df.head()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "torch",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

sampled_data.csv

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