From bb5726e292ce2fd177e89b71ff765f93615ae54e Mon Sep 17 00:00:00 2001 From: adamjanovsky Date: Thu, 2 Mar 2023 13:05:37 +0100 Subject: reference-analysis: add language detection --- .../reference_annotations/data_preprocessing.ipynb | 42 ++- .../cc/reference_annotations/prediction.ipynb | 283 ++++++++++++++------- pyproject.toml | 2 +- requirements/dev_requirements.txt | 4 - requirements/nlp_requirements.txt | 21 +- requirements/requirements.txt | 4 - requirements/test_requirements.txt | 4 - 7 files changed, 230 insertions(+), 130 deletions(-) diff --git a/notebooks/cc/reference_annotations/data_preprocessing.ipynb b/notebooks/cc/reference_annotations/data_preprocessing.ipynb index 76d16326..e5a55c71 100644 --- a/notebooks/cc/reference_annotations/data_preprocessing.ipynb +++ b/notebooks/cc/reference_annotations/data_preprocessing.ipynb @@ -29,6 +29,7 @@ "from sec_certs.utils.parallel_processing import process_parallel\n", "import pandas as pd\n", "import json\n", + "import langdetect\n", "\n", "nlp = spacy.load(\"en_core_web_sm\")\n", "from pathlib import Path\n", @@ -128,7 +129,13 @@ "\n", " return pd.concat(\n", " [load_single_df(train_path, \"train\"), load_single_df(valid_path, \"valid\"), load_single_df(test_path, \"test\")]\n", - " )[[\"dgst\", \"referenced_cert_id\", \"source\", \"label\", \"comment\"]]" + " )[[\"dgst\", \"referenced_cert_id\", \"source\", \"label\", \"comment\"]]\n", + "\n", + "def preprocess_sentence(x):\n", + " pass\n", + "\n", + "def preprocess_sentences(sentences: list[str]):\n", + " return [preprocess_sentence(x) for x in sentences]" ] }, { @@ -141,15 +148,15 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 49, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 944/944 [01:05<00:00, 14.48it/s]\n", - "100%|██████████| 2288/2288 [00:32<00:00, 69.50it/s]\n" + "100%|██████████| 944/944 [01:07<00:00, 14.06it/s]\n", + "100%|██████████| 2288/2288 [00:36<00:00, 62.14it/s]\n" ] } ], @@ -192,7 +199,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 72, "metadata": {}, "outputs": [], "source": [ @@ -208,19 +215,26 @@ " annotations_df[[\"dgst\", \"referenced_cert_id\", \"label\"]].set_index([\"dgst\", \"referenced_cert_id\"]).label.to_dict()\n", ")\n", "\n", - "# TODO: We should investigate the cases when we match no sentence, they may be new-lines and stuff\n", - "# TODO: Add language detection\n", - "# Process\n", + "# TODO: We should investigate the cases when df.sentences.isnull(), they may be new-lines and stuff\n", + "\n", + "# Enrich the data with language of sentences, so far discard all that's not en, fr, de.\n", + "# process then\n", "df = (\n", - " df.assign(\n", - " split=df.dgst.map(split_dct),\n", + " df.loc[df.sentences.notnull()]\n", + " .explode(\"sentences\")\n", + " .assign(lang = lambda df_: df_.sentences.map(langdetect.detect))\n", + " .loc[lambda df_: df_.lang.isin({\"en\", \"fr\", \"de\"})]\n", + " .groupby([\"dgst\", \"referenced_cert_id\", \"source\", \"label\"], as_index=False, dropna=False)\n", + " .agg({\"sentences\": list, \"lang\": list})\n", + " .assign(\n", + " split=lambda df_: df_.dgst.map(split_dct),\n", " label=lambda df_: [annotations_dict.get(x) for x in zip(df_[\"dgst\"], df_[\"referenced_cert_id\"])],\n", " )\n", - " .loc[lambda df_: (df_[\"sentences\"].notnull()) & (df_[\"split\"] != \"test\")]\n", - " .groupby([\"dgst\", \"referenced_cert_id\", \"label\", \"split\"], as_index=False, dropna=False)[\"sentences\"]\n", - " .agg({\"sentences\": lambda x: set.union(*x)})\n", + " .loc[lambda df_: df_[\"split\"] != \"test\"]\n", + " .groupby([\"dgst\", \"referenced_cert_id\", \"label\", \"split\"], as_index=False, dropna=False)\n", + " .agg({\"sentences\": sum, \"lang\": sum})\n", ")\n", - "df.to_csv(REPO_ROOT / \"datasets/reference_classification_dataset.csv\", index=False)" + "df.to_csv(REPO_ROOT / \"datasets/reference_classification_dataset.csv\", index=False)\n" ] } ], diff --git a/notebooks/cc/reference_annotations/prediction.ipynb b/notebooks/cc/reference_annotations/prediction.ipynb index b88c4a60..54e9c8d4 100644 --- a/notebooks/cc/reference_annotations/prediction.ipynb +++ b/notebooks/cc/reference_annotations/prediction.ipynb @@ -40,6 +40,7 @@ "from pathlib import Path\n", "from sec_certs.model.reference_classification import ReferenceClassifierTrainer\n", "import numpy as np\n", + "from sklearn.metrics import ConfusionMatrixDisplay\n", "\n", "REPO_ROOT = Path(\"../../../\").resolve()\n", "\n", @@ -56,33 +57,40 @@ " return df_new\n", "\n", "def eval_strings(series):\n", - " return [list(literal_eval(x)) for x in series]" + " return [list(literal_eval(x)) for x in series]\n", + "\n", + "def filter_short_sentences(sentences, cert_id):\n", + " return [x for x in sentences if len(x) > len(cert_id) + 20]" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "# Prepare dataset\n", "\n", - "df = pd.read_csv(REPO_ROOT / \"datasets/reference_classification_dataset.csv\").loc[\n", - " lambda df_: (df_.label.notnull()) & (df_.label.isin({\"COMPONENT_USED\", \"RECERTIFICATION\", \"ON_PLATFORM\"}))\n", - "].assign(sentences=lambda df_: eval_strings(df_.sentences))\n", - "df.label = df.label.map(lambda x: x if x != \"ON_PLATFORM\" else \"COMPONENT_USED\")\n", + "df = (\n", + " pd.read_csv(\"/var/tmp/xjanovsk/certs/sec-certs/datasets/reference_classification_dataset.csv\")\n", + " .loc[lambda df_: (df_.label.notnull())]\n", + " .assign(sentences=lambda df_: eval_strings(df_.sentences)).loc[lambda df_: df_.label != \"SELF\"]\n", + " .drop(columns=\"lang\")\n", + ")\n", + "df.sentences = df.apply(lambda row: filter_short_sentences(row[\"sentences\"], row[\"referenced_cert_id\"]), axis=1)\n", + "df = df.loc[lambda df_: df_.sentences.map(len) > 0]\n", "\n", "# Split into train/valid\n", "df_train = df.loc[df.split == \"train\"].drop(columns=\"split\")\n", "df_valid = df.loc[df.split == \"valid\"].drop(columns=\"split\")\n", "\n", "# Use just few examples for learning\n", - "df_train = df_train.sample(n=30)" + "#df_train = df_train.sample(n=20)" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -93,16 +101,16 @@ "model_head.pkl not found on HuggingFace Hub, initialising classification head with random weights. You should TRAIN this model on a downstream task to use it for predictions and inference.\n", "Applying column mapping to training dataset\n", "***** Running training *****\n", - " Num examples = 7200\n", + " Num examples = 17040\n", " Num epochs = 1\n", - " Total optimization steps = 450\n", + " Total optimization steps = 1065\n", " Total train batch size = 16\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "26e2525767364e3eba9c9881cd1982be", + "model_id": "a9242ccbc1204603ac4f3508d83b5381", "version_major": 2, "version_minor": 0 }, @@ -116,12 +124,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "d62be3272ebd4654b2adcfedee9b9b6a", + "model_id": "56fb111f4e4b442ca6411546e89f7145", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "Iteration: 0%| | 0/450 [00:00\n", " \n", " \n", + " \n", + " 762\n", + " ab3af998dff7a2ef\n", + " ANSSI-CC-2017/47\n", + " COMPONENT_USED\n", + " [ANSSI-CC-2017/47 le 5 septembre 2017.\\n]\n", + " [0.20525086358002373, 0.18348274934762435, 0.1...\n", + " ON_PLATFORM\n", + " False\n", + " \n", " \n", "\n", "" ], "text/plain": [ - "Empty DataFrame\n", - "Columns: [dgst, referenced_cert_id, label, sentences, y_proba, y_pred, correct]\n", - "Index: []" + " dgst referenced_cert_id label \\\n", + "762 ab3af998dff7a2ef ANSSI-CC-2017/47 COMPONENT_USED \n", + "\n", + " sentences \\\n", + "762 [ANSSI-CC-2017/47 le 5 septembre 2017.\\n] \n", + "\n", + " y_proba y_pred correct \n", + "762 [0.20525086358002373, 0.18348274934762435, 0.1... ON_PLATFORM False " ] }, - "execution_count": 17, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "df_train.loc[~df_train.correct]" + "df_train.loc[~df_train.correct].head()" ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -255,72 +278,52 @@ " \n", " \n", " \n", - " 251\n", - " 2c2244c35d126bfb\n", - " BSI-DSZ-CC-0794-2011\n", - " RECERTIFICATION\n", - " [This is a re-certification based on BSI-DSZ-C...\n", - " [0.47754689036832726, 0.5224531096316728]\n", + " 13\n", + " 031667f4e242da61\n", + " CCEVS-VR-07-0054\n", + " ON_PLATFORM\n", + " [Red Hat Enterprise Linux AS (version 5)\\nfor ...\n", + " [0.08128229341724993, 0.5935885753661718, 0.08...\n", " COMPONENT_USED\n", " False\n", " \n", " \n", - " 364\n", - " 4489bfc781a82281\n", - " BSI-DSZ-CC-0817-2013\n", - " RECERTIFICATION\n", - " [This is a re-certification based on BSI-DSZ-C...\n", - " [0.11195564561722356, 0.8880443543827765]\n", + " 93\n", + " 0fe8df0e85116b61\n", + " ANSSI-CC-2010/33\n", + " COMPONENT_SHARED\n", + " [CC IDeal Citiz (sur\\ncomposants SB23YR80B et ...\n", + " [0.1298013287690078, 0.3509932910135731, 0.129...\n", " COMPONENT_USED\n", " False\n", " \n", " \n", - " 505\n", - " 647d17d44745a532\n", - " BSI-DSZ-CC-0904-2015\n", - " RECERTIFICATION\n", - " [and BSI-DSZ-CC-0904-2015-\\n, This is a re-cer...\n", - " [0.16312949852765818, 0.8368705014723418]\n", - " COMPONENT_USED\n", + " 120\n", + " 16abf8ee0697e64f\n", + " ANSSI-CC-2014/61\n", + " COMPONENT_SHARED\n", + " [sous la référence [ANSSI-CC-2014/61].\\n]\n", + " [0.31989947871327085, 0.1360383985847733, 0.13...\n", + " ON_PLATFORM\n", " False\n", " \n", " \n", - " 616\n", - " 7e58bfc14edf68e4\n", - " OCSI/CERT/TEC/01/2013/RC\n", - " RECERTIFICATION\n", - " [OCSI/CERT/TEC/01/2013/RC, versione 1.0,]\n", - " [0.2810731555375018, 0.7189268444624982]\n", + " 186\n", + " 22388445fe620ac0\n", + " ANSSI-CC-2014/20\n", + " EVALUATION_REUSED\n", + " [[ANSSI-CC-\\n2014/20]\\nRapport de certificatio...\n", + " [0.24887785969701517, 0.3029851841704751, 0.11...\n", " COMPONENT_USED\n", " False\n", " \n", " \n", - " 628\n", - " 81273108dd167b98\n", - " BSI-DSZ-CC-0523-2008\n", - " RECERTIFICATION\n", - " [Specific results from the\\nevaluation process...\n", - " [0.4308279930268643, 0.5691720069731356]\n", - " COMPONENT_USED\n", - " False\n", - " \n", - " \n", - " 709\n", - " 9664c0f0ec6401b9\n", - " BSI-DSZ-CC-0891-V2-2016\n", - " RECERTIFICATION\n", - " [This is a re-certification based on BSI-DSZ-C...\n", - " [0.4303467603163502, 0.5696532396836499]\n", - " COMPONENT_USED\n", - " False\n", - " \n", - " \n", - " 719\n", - " 983d16512ae92d46\n", - " BSI-DSZ-CC-0891-V3-2018\n", - " RECERTIFICATION\n", - " [The updated documents in compare to the forer...\n", - " [0.48619060832541505, 0.513809391674585]\n", + " 201\n", + " 24de96ea505af909\n", + " ANSSI-CC-2021/29\n", + " ON_PLATFORM\n", + " [[CER-PLF] Rapport de certification ANSSI-CC-2...\n", + " [0.11465163411016323, 0.5243168025861568, 0.07...\n", " COMPONENT_USED\n", " False\n", " \n", @@ -329,41 +332,123 @@ "" ], "text/plain": [ - " dgst referenced_cert_id label \\\n", - "251 2c2244c35d126bfb BSI-DSZ-CC-0794-2011 RECERTIFICATION \n", - "364 4489bfc781a82281 BSI-DSZ-CC-0817-2013 RECERTIFICATION \n", - "505 647d17d44745a532 BSI-DSZ-CC-0904-2015 RECERTIFICATION \n", - "616 7e58bfc14edf68e4 OCSI/CERT/TEC/01/2013/RC RECERTIFICATION \n", - "628 81273108dd167b98 BSI-DSZ-CC-0523-2008 RECERTIFICATION \n", - "709 9664c0f0ec6401b9 BSI-DSZ-CC-0891-V2-2016 RECERTIFICATION \n", - "719 983d16512ae92d46 BSI-DSZ-CC-0891-V3-2018 RECERTIFICATION \n", + " dgst referenced_cert_id label \\\n", + "13 031667f4e242da61 CCEVS-VR-07-0054 ON_PLATFORM \n", + "93 0fe8df0e85116b61 ANSSI-CC-2010/33 COMPONENT_SHARED \n", + "120 16abf8ee0697e64f ANSSI-CC-2014/61 COMPONENT_SHARED \n", + "186 22388445fe620ac0 ANSSI-CC-2014/20 EVALUATION_REUSED \n", + "201 24de96ea505af909 ANSSI-CC-2021/29 ON_PLATFORM \n", "\n", " sentences \\\n", - "251 [This is a re-certification based on BSI-DSZ-C... \n", - "364 [This is a re-certification based on BSI-DSZ-C... \n", - "505 [and BSI-DSZ-CC-0904-2015-\\n, This is a re-cer... \n", - "616 [OCSI/CERT/TEC/01/2013/RC, versione 1.0,] \n", - "628 [Specific results from the\\nevaluation process... \n", - "709 [This is a re-certification based on BSI-DSZ-C... \n", - "719 [The updated documents in compare to the forer... \n", + "13 [Red Hat Enterprise Linux AS (version 5)\\nfor ... \n", + "93 [CC IDeal Citiz (sur\\ncomposants SB23YR80B et ... \n", + "120 [sous la référence [ANSSI-CC-2014/61].\\n] \n", + "186 [[ANSSI-CC-\\n2014/20]\\nRapport de certificatio... \n", + "201 [[CER-PLF] Rapport de certification ANSSI-CC-2... \n", + "\n", + " y_proba y_pred \\\n", + "13 [0.08128229341724993, 0.5935885753661718, 0.08... COMPONENT_USED \n", + "93 [0.1298013287690078, 0.3509932910135731, 0.129... COMPONENT_USED \n", + "120 [0.31989947871327085, 0.1360383985847733, 0.13... ON_PLATFORM \n", + "186 [0.24887785969701517, 0.3029851841704751, 0.11... COMPONENT_USED \n", + "201 [0.11465163411016323, 0.5243168025861568, 0.07... COMPONENT_USED \n", "\n", - " y_proba y_pred correct \n", - "251 [0.47754689036832726, 0.5224531096316728] COMPONENT_USED False \n", - "364 [0.11195564561722356, 0.8880443543827765] COMPONENT_USED False \n", - "505 [0.16312949852765818, 0.8368705014723418] COMPONENT_USED False \n", - "616 [0.2810731555375018, 0.7189268444624982] COMPONENT_USED False \n", - "628 [0.4308279930268643, 0.5691720069731356] COMPONENT_USED False \n", - "709 [0.4303467603163502, 0.5696532396836499] COMPONENT_USED False \n", - "719 [0.48619060832541505, 0.513809391674585] COMPONENT_USED False " + " correct \n", + "13 False \n", + "93 False \n", + "120 False \n", + "186 False \n", + "201 False " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_valid.loc[~df_valid.correct].head()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "image/svg+xml": "\n\n\n \n \n \n \n 2023-03-02T13:04:53.567891\n image/svg+xml\n \n \n Matplotlib v3.6.2, https://matplotlib.org/\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ConfusionMatrixDisplay.from_predictions(df_valid.label, df_valid.y_pred, labels=df_valid.label.unique(), display_labels=df_valid.label.unique(), xticks_rotation=90, normalize=\"pred\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "COMPONENT_USED 43\n", + "RECERTIFICATION 18\n", + "EVALUATION_REUSED 11\n", + "ON_PLATFORM 8\n", + "COMPONENT_SHARED 6\n", + "PREVIOUS_VERSION 5\n", + "Name: label, dtype: int64" ] }, - "execution_count": 20, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "df_valid.loc[~df_valid.correct]" + "df_valid.label.value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# Experiments with ensemble for soft-voting on top of the base model.\n", + "# But this is dump, since the ensemble is position-specific w.r.t. sequence, while the individual sentences are not.\n", + "from sklearn.ensemble import RandomForestClassifier\n", + "\n", + "df_train[\"y_proba_base\"] = df_train.sentences.map(trainer._model.predict_proba).map(lambda x: x.flatten())\n", + "feat_len = df_train[\"y_proba_base\"].map(len).max()\n", + "df_train[\"rf_feature_vector\"] = df_train.y_proba_base.map(lambda x: np.pad(x, pad_width=(0, feat_len - len(x))))\n", + "\n", + "df_valid[\"y_proba_base\"] = df_valid.sentences.map(trainer._model.predict_proba).map(lambda x: x.flatten())\n", + "df_valid[\"rf_feature_vector\"] = df_valid.y_proba_base.map(lambda x: np.pad(x, pad_width=(0, feat_len - len(x))))\n", + "\n", + "clf = RandomForestClassifier()\n", + "clf = clf.fit(df_train.rf_feature_vector.tolist(), df_train.label)\n", + "\n", + "df_train[\"rf_predict\"] = clf.predict(df_train.rf_feature_vector.tolist())\n", + "df_valid[\"rf_predict\"] = clf.predict(df_valid.rf_feature_vector.tolist())" ] } ], diff --git a/pyproject.toml b/pyproject.toml index 6126745e..e08ac75f 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -83,7 +83,7 @@ "ipython!=8.7.0", ] test = ["pytest", "coverage", "pytest-cov"] - nlp = ["setfit"] + nlp = ["setfit", "langdetect"] [project.urls] Homepage = "https://seccerts.org" diff --git a/requirements/dev_requirements.txt b/requirements/dev_requirements.txt index 7ed5dd2f..c7780611 100644 --- a/requirements/dev_requirements.txt +++ b/requirements/dev_requirements.txt @@ -6,10 +6,6 @@ aiosignal==1.3.1 # via aiohttp alabaster==0.7.12 # via sphinx -appnope==0.1.3 - # via - # ipykernel - # ipython asttokens==2.2.1 # via stack-data async-timeout==4.0.2 diff --git a/requirements/nlp_requirements.txt b/requirements/nlp_requirements.txt index 353ab1ea..7ff4fbd2 100644 --- a/requirements/nlp_requirements.txt +++ b/requirements/nlp_requirements.txt @@ -4,10 +4,6 @@ aiohttp==3.8.4 # fsspec aiosignal==1.3.1 # via aiohttp -appnope==0.1.3 - # via - # ipykernel - # ipython asttokens==2.2.1 # via stack-data async-timeout==4.0.2 @@ -138,6 +134,8 @@ kiwisolver==1.4.4 # via matplotlib langcodes==3.3.0 # via spacy +langdetect==1.0.9 + # via sec-certs (./../pyproject.toml) lxml==4.9.2 # via # pikepdf @@ -192,6 +190,16 @@ numpy==1.24.2 # thinc # torchvision # transformers +nvidia-cublas-cu11==11.10.3.66 + # via + # nvidia-cudnn-cu11 + # torch +nvidia-cuda-nvrtc-cu11==11.7.99 + # via torch +nvidia-cuda-runtime-cu11==11.7.99 + # via torch +nvidia-cudnn-cu11==8.5.0.96 + # via torch packaging==23.0 # via # datasets @@ -332,6 +340,7 @@ six==1.16.0 # via # asttokens # html5lib + # langdetect # python-dateutil smart-open==6.3.0 # via @@ -417,6 +426,10 @@ wcwidth==0.2.6 # via prompt-toolkit webencodings==0.5.1 # via html5lib +wheel==0.38.4 + # via + # nvidia-cublas-cu11 + # nvidia-cuda-runtime-cu11 widgetsnbextension==4.0.5 # via ipywidgets xxhash==3.2.0 diff --git a/requirements/requirements.txt b/requirements/requirements.txt index 67d80236..9461aaa2 100644 --- a/requirements/requirements.txt +++ b/requirements/requirements.txt @@ -1,7 +1,3 @@ -appnope==0.1.3 - # via - # ipykernel - # ipython asttokens==2.2.1 # via stack-data attrs==22.1.0 diff --git a/requirements/test_requirements.txt b/requirements/test_requirements.txt index 43373faf..c2d69151 100644 --- a/requirements/test_requirements.txt +++ b/requirements/test_requirements.txt @@ -1,7 +1,3 @@ -appnope==0.1.3 - # via - # ipykernel - # ipython asttokens==2.2.1 # via stack-data attrs==22.1.0 -- cgit v1.3.1