"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"%matplotlib inline\n",
"\n",
"import matplotlib.pyplot as plt\n",
"import seaborn as sns\n",
"\n",
"plt.figure(figsize=(8, 5))\n",
"\n",
"sns.set(font_scale=1.2)\n",
"\n",
"sns.heatmap(trans_matrix_df, annot=True, square=True, annot_kws={\"fontsize\": 12}, cmap=\"Blues\")\n",
"\n",
"plt.title(\"Transition Matrix\")\n",
"\n",
"plt.show()"
]
},
{
"cell_type": "code",
"execution_count": 145,
"metadata": {},
"outputs": [],
"source": [
"import math\n",
"from fractions import Fraction\n",
"\n",
"\n",
"def round_down(x, a):\n",
" return math.floor(x / a) * a\n",
"\n",
"\n",
"def get_emission_prob_dict(\n",
" sentences: list[str] = train_sentences,\n",
" labels: list[int] = y_train,\n",
" tags: dict = unique_labels,\n",
"):\n",
" \"\"\"\n",
" Given a bunch of sentences and their labels, get the emission probability of each word given each tag\n",
"\n",
" Parameters:\n",
" sentences (list): The list of sentences\n",
" labels (list): The list of labels\n",
" tags (dict): The dictionary of tags\n",
"\n",
" Returns:\n",
" dict: The dictionary of emission probabilities\n",
" \"\"\"\n",
" tags = list(tags.keys())\n",
" word_tag_count = {}\n",
" # Add tag\n",
" word_tag_count[\"\"] = {tag: 0 for tag in tags}\n",
"\n",
" tag_count = {tag: 0 for tag in tags}\n",
"\n",
" # Count n times a word has tag\n",
" for i in range(len(sentences)):\n",
" for word, label in zip(sentences[i].split(\" \"), labels[i]):\n",
" if word not in word_tag_count:\n",
" word_tag_count[word] = {tag: 0 for tag in tags}\n",
" word_tag_count[word][tags[label]] += 1\n",
" tag_count[tags[label]] += 1\n",
"\n",
" words_to_remove = []\n",
"\n",
" # combining least represented words under \n",
" for word in word_tag_count:\n",
" # if word not frequent enough add it to \n",
" if sum(word_tag_count[word].values()) < 3 and not word == \"\":\n",
" for tag in word_tag_count[word]:\n",
" word_tag_count[\"\"][tag] += word_tag_count[word][tag]\n",
" words_to_remove.append(word)\n",
" continue\n",
"\n",
" word_tag_count = {\n",
" key: word_tag_count[key] for key in word_tag_count if key not in words_to_remove\n",
" }\n",
"\n",
" # Calculate the prob of a word given tag\n",
" for word in word_tag_count:\n",
" if word == \"\":\n",
" print(word_tag_count[word])\n",
" for tag in word_tag_count[word]:\n",
" if word_tag_count[word][tag] == 0:\n",
" word_tag_count[word][tag] = 0\n",
" continue\n",
" word_tag_count[word][tag] = word_tag_count[word][tag] / tag_count[tag]\n",
"\n",
" return word_tag_count"
]
},
{
"cell_type": "code",
"execution_count": 146,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"['je', 'veux', 'part', 'de', 'montpelli', 'à', 'paris', '.', '']"
]
},
"execution_count": 146,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"sentence_test = \"Je veux partir de Montpellier à Paris.\"\n",
"\n",
"s_t = process_sentence(\n",
" sentence_test, stemming=True, rm_stopwords=False, return_tokens=True\n",
") + [\"\"]\n",
"\n",
"s_t"
]
},
{
"cell_type": "code",
"execution_count": 147,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"
"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"fig = plt.figure(figsize=(5, 5))\n",
"ax = fig.add_subplot(projection=\"3d\")\n",
"\n",
"xx = em_prob[:, 0]\n",
"yy = em_prob[:, 1]\n",
"zz = em_prob[:, 2]\n",
"\n",
"xlabel = list(em_prob_df.columns)[0]\n",
"ylabel = list(em_prob_df.columns)[1]\n",
"zlabel = list(em_prob_df.columns)[2]\n",
"\n",
"# Words with the highest probability on each axis\n",
"x_highest_i = np.argmax(em_prob[:, 0])\n",
"y_highest_i = np.argmax(em_prob[:, 1])\n",
"z_highest_i = np.argmax(em_prob[:, 2])\n",
"\n",
"for i in enumerate([x_highest_i, y_highest_i, z_highest_i]):\n",
" ax.text(\n",
" xx[i[1]],\n",
" yy[i[1]],\n",
" zz[i[1]],\n",
" f\"'{em_prob_df.index[i[1]]}'\\n({xx[i[1]]:.2f}, {yy[i[1]]:.2f}, {zz[i[1]]:.2f})\",\n",
" fontsize=12,\n",
" ha=\"center\",\n",
" va=\"center\",\n",
" )\n",
"\n",
"ax.scatter(xx, yy, zz)\n",
"\n",
"ax.get_xaxis().set_ticklabels([])\n",
"ax.get_yaxis().set_ticklabels([])\n",
"ax.get_zaxis().set_ticklabels([])\n",
"\n",
"ax.set_xlabel(xlabel)\n",
"ax.set_ylabel(ylabel)\n",
"ax.set_zlabel(zlabel)\n",
"\n",
"# Move zlabel closer to plot\n",
"ax.zaxis.labelpad = -10\n",
"\n",
"plt.show()"
]
},
{
"cell_type": "code",
"execution_count": 151,
"metadata": {},
"outputs": [],
"source": [
"def get_start_prob(labels: list[int] = y_train, tags: dict = unique_labels):\n",
" \"\"\"\n",
" Get the start probability of each tag\n",
"\n",
" Parameters:\n",
" labels (list): The list of labels\n",
" tags (dict): The dictionary of tags\n",
"\n",
" Returns:\n",
" dict: The dictionary of start probabilities\n",
" \"\"\"\n",
" tags = list(tags.keys())\n",
" start_prob = {tag: 0 for tag in tags}\n",
" for label in labels:\n",
" start_prob[tags[label[0]]] += 1\n",
" total_count = sum(start_prob.values())\n",
" for tag in start_prob:\n",
" start_prob[tag] /= total_count\n",
" return start_prob"
]
},
{
"cell_type": "code",
"execution_count": 152,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([1., 0., 0.])"
]
},
"execution_count": 152,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"startprob = get_start_prob()\n",
"\n",
"startprob = np.array(list(startprob.values()))\n",
"\n",
"startprob"
]
},
{
"cell_type": "code",
"execution_count": 153,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
Start Probability
\n",
"
\n",
" \n",
" \n",
"
\n",
"
O
\n",
"
1.0
\n",
"
\n",
"
\n",
"
LOC-DEP
\n",
"
0.0
\n",
"
\n",
"
\n",
"
LOC-ARR
\n",
"
0.0
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" Start Probability\n",
"O 1.0\n",
"LOC-DEP 0.0\n",
"LOC-ARR 0.0"
]
},
"execution_count": 153,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"startprob_df = pd.DataFrame(\n",
" startprob, index=unique_labels.keys(), columns=[\"Start Probability\"]\n",
")\n",
"\n",
"startprob_df"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Since we already have the model parameters, we don't need to use the automatic model estimation with `fit()`. Therefore, we will pass the probabilities directly to the model and move on to the predictions.\n"
]
},
{
"cell_type": "code",
"execution_count": 154,
"metadata": {},
"outputs": [],
"source": [
"from hmmlearn.hmm import CategoricalHMM\n",
"\n",
"vocab = list(em_prob_dict.keys())\n",
"\n",
"hmm = CategoricalHMM(n_components=n_tags, n_iter=100)\n",
"\n",
"hmm.n_features = len(vocab)\n",
"hmm.startprob_ = startprob\n",
"hmm.transmat_ = trans_matrix.T\n",
"hmm.emissionprob_ = em_prob.T"
]
},
{
"cell_type": "code",
"execution_count": 155,
"metadata": {},
"outputs": [],
"source": [
"def encode_sentence(sentence: str, vocab: list[str]):\n",
" \"\"\"\n",
" Encode a sentence into a list of integers\n",
"\n",
" Parameters:\n",
" sentence (str): The sentence to encode\n",
" vocab (list): The vocabulary\n",
"\n",
" Returns:\n",
" list: The list of integers\n",
" \"\"\"\n",
" return [\n",
" vocab.index(word) if word in vocab else vocab.index(\"\")\n",
" for word in sentence.split(\" \")\n",
" ]"
]
},
{
"cell_type": "code",
"execution_count": 159,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"quel: O\n",
"trajet: O\n",
"fair: O\n",
"aller: O\n",
"perpignan: LOC-DEP\n",
"montpelli: LOC-ARR\n"
]
}
],
"source": [
"from app.travel_resolver.libs.nlp.data_processing import process_sentence\n",
"\n",
"vocab = list(em_prob_dict.keys())\n",
"\n",
"test_sentence = \"Quel trajet faire pour aller de Perpignan à Montpellier\"\n",
"\n",
"test_sentence = process_sentence(test_sentence, stemming=True, rm_stopwords=True)\n",
"\n",
"test_sentence_encoded = encode_sentence(test_sentence, vocab)\n",
"\n",
"test_sentence_encoded = np.array(test_sentence_encoded).reshape(-1, 1)\n",
"\n",
"predicted_labels = hmm.predict(test_sentence_encoded)\n",
"\n",
"for word, label in zip(test_sentence.split(\" \"), predicted_labels):\n",
" print(f\"{word}: {list(unique_labels.keys())[label]}\")"
]
},
{
"cell_type": "code",
"execution_count": 160,
"metadata": {},
"outputs": [],
"source": [
"test_sentences_encoded = [\n",
" encode_sentence(sentence, vocab) for sentence in test_sentences\n",
"]\n",
"test_sentences_lengths = [len(sentence) for sentence in test_sentences_encoded]\n",
"\n",
"\n",
"test_sentences_encoded_flat = [\n",
" item for sublist in test_sentences_encoded for item in sublist\n",
"]\n",
"test_sentences_encoded = np.array(test_sentences_encoded_flat).reshape(-1, 1)\n",
"\n",
"predicted_labels_test = hmm.predict(test_sentences_encoded, test_sentences_lengths)"
]
},
{
"cell_type": "code",
"execution_count": 161,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"F1 Score: 0.6749156355455568\n"
]
}
],
"source": [
"from sklearn.metrics import accuracy_score, f1_score\n",
"\n",
"y_test_flat = [item for sublist in y_test for item in sublist]\n",
"\n",
"f1 = f1_score(y_test_flat, predicted_labels_test, average=\"micro\", labels=[1, 2])\n",
"\n",
"print(f\"F1 Score: {f1}\")"
]
},
{
"cell_type": "code",
"execution_count": 163,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"conf matrix [[1432 0 2]\n",
" [ 0 103 117]\n",
" [ 1 26 197]]\n"
]
},
{
"data": {
"text/plain": [
"Text(0.5, 1.0, 'Confusion Matrix on test data')"
]
},
"execution_count": 163,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"from sklearn.metrics import confusion_matrix\n",
"\n",
"conf_matrix = confusion_matrix(y_test_flat, predicted_labels_test)\n",
"\n",
"print(\"conf matrix\", conf_matrix)\n",
"\n",
"conf_matrix = conf_matrix / conf_matrix.sum(axis=1)\n",
"\n",
"conf_matrix_df = pd.DataFrame(conf_matrix, columns=tags, index=tags)\n",
"\n",
"\n",
"plt.figure(figsize=(8, 5))\n",
"\n",
"sns.set(font_scale=1)\n",
"\n",
"sns.heatmap(\n",
" conf_matrix_df, annot=True, square=True, annot_kws={\"fontsize\": 12}, cmap=\"Blues\"\n",
")\n",
"\n",
"plt.xlabel(\"Predicted\")\n",
"plt.ylabel(\"True\")\n",
"plt.title(\"Confusion Matrix on test data\")"
]
},
{
"cell_type": "code",
"execution_count": 164,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"from sklearn.metrics import RocCurveDisplay\n",
"from sklearn.preprocessing import LabelBinarizer\n",
"\n",
"class_of_interest = \"LOC-DEP\"\n",
"class_id = list(unique_labels.keys()).index(class_of_interest)\n",
"\n",
"label_binarizer = LabelBinarizer().fit(y_test_flat)\n",
"y_test_onehot = label_binarizer.transform(y_test_flat)\n",
"y_pred_onehot = label_binarizer.transform(predicted_labels_test)\n",
"\n",
"display = RocCurveDisplay.from_predictions(\n",
" y_test_onehot[:, class_id],\n",
" y_pred_onehot[:, class_id],\n",
" name=f\"{class_of_interest} vs Rest\",\n",
" plot_chance_level=True,\n",
")\n",
"\n",
"_ = display.ax_.set(\n",
" xlabel=\"False Positive Rate\",\n",
" ylabel=\"True Positive Rate\",\n",
")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Evaluating new sentences\n",
"\n",
"In this section, we will be evaluating the model capacity on sentences that hasn't contributed to the model's probabilities.\n",
"\n",
"The corpus is formed from an initial dataset of 20 unique blueprint sentences that were used to generate a 1000 sentences with different \"Departures\" and \"Arrivals\".\n"
]
},
{
"cell_type": "code",
"execution_count": 165,
"metadata": {},
"outputs": [],
"source": [
"new_sentences, new_labels, new_vocab, new_unique_labels = from_bio_file_to_examples(\n",
" \"./data/bio/fr.bio/800_eval_small_samples.bio\"\n",
")"
]
},
{
"cell_type": "code",
"execution_count": 166,
"metadata": {},
"outputs": [],
"source": [
"sls_new_sentences = []\n",
"sls_new_labels = []\n",
"\n",
"for sentence, label in zip(new_sentences, new_labels):\n",
" p_sentence, p_label = process_sentence(\n",
" sentence, stemming=True, labels_to_adapt=label, rm_stopwords=True\n",
" )\n",
" sls_new_sentences.append(p_sentence)\n",
" sls_new_labels.append(p_label)"
]
},
{
"cell_type": "code",
"execution_count": 167,
"metadata": {},
"outputs": [],
"source": [
"sls_new_sentences_encoded = [\n",
" encode_sentence(sentence, vocab) for sentence in sls_new_sentences\n",
"]\n",
"\n",
"sls_new_sentences_length = [len(sentence) for sentence in sls_new_sentences_encoded]\n",
"\n",
"\n",
"sls_new_sentences_flat = [\n",
" item for sublist in sls_new_sentences_encoded for item in sublist\n",
"]\n",
"\n",
"sls_new_sentences_encoded = np.array(sls_new_sentences_flat).reshape(-1, 1)\n",
"\n",
"new_sentences_pred = hmm.predict(sls_new_sentences_encoded, sls_new_sentences_length)"
]
},
{
"cell_type": "code",
"execution_count": 168,
"metadata": {},
"outputs": [],
"source": [
"y_real = [item for sublist in sls_new_labels for item in sublist]"
]
},
{
"cell_type": "code",
"execution_count": 169,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"F1: 0.3812801101169993\n"
]
}
],
"source": [
"f1_score_new = f1_score(y_real, new_sentences_pred, average=\"micro\", labels=[1, 2])\n",
"\n",
"print(f\"F1: {f1_score_new}\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can see the sharp decrease from the other corpus, and that's the limitation of HMM, they can go as far as their they know - by know I the known observations and emission probs - .\n"
]
},
{
"cell_type": "code",
"execution_count": 170,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[3314, 186, 820],\n",
" [ 0, 241, 608],\n",
" [ 1, 237, 590]])"
]
},
"execution_count": 170,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"consufion_matrix_new = confusion_matrix(y_real, new_sentences_pred)\n",
"\n",
"consufion_matrix_new"
]
},
{
"cell_type": "code",
"execution_count": 171,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Counter({0: 4320, 1: 849, 2: 828})"
]
},
"execution_count": 171,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from collections import Counter\n",
"\n",
"Counter(y_real)"
]
},
{
"cell_type": "code",
"execution_count": 172,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Text(0.5, 1.0, 'Confusion Matrix HMM on new data')"
]
},
"execution_count": 172,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"from sklearn.metrics import confusion_matrix\n",
"\n",
"conf_matrix = confusion_matrix(y_real, new_sentences_pred)\n",
"\n",
"conf_matrix = np.round(conf_matrix / conf_matrix.sum(axis=0), 2)\n",
"\n",
"conf_matrix_df = pd.DataFrame(conf_matrix, columns=tags, index=tags)\n",
"\n",
"plt.figure(figsize=(8, 5))\n",
"\n",
"sns.set(font_scale=1)\n",
"\n",
"sns.heatmap(\n",
" conf_matrix_df, annot=True, square=True, annot_kws={\"fontsize\": 12}, cmap=\"Blues\"\n",
")\n",
"\n",
"plt.xlabel(\"Predicted Labels\")\n",
"plt.ylabel(\"True Labels\")\n",
"plt.title(\"Confusion Matrix HMM on new data\")"
]
},
{
"cell_type": "code",
"execution_count": 135,
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"Even though the 'startprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 's'\n",
"Even though the 'transmat_' attribute is set, it will be overwritten during initialization because 'init_params' contains 't'\n",
"Even though the 'emissionprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 'e'\n",
"Even though the 'startprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 's'\n",
"Even though the 'transmat_' attribute is set, it will be overwritten during initialization because 'init_params' contains 't'\n",
"Even though the 'emissionprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 'e'\n",
"Even though the 'startprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 's'\n",
"Even though the 'transmat_' attribute is set, it will be overwritten during initialization because 'init_params' contains 't'\n",
"Even though the 'emissionprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 'e'\n",
"Even though the 'startprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 's'\n",
"Even though the 'transmat_' attribute is set, it will be overwritten during initialization because 'init_params' contains 't'\n",
"Even though the 'emissionprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 'e'\n",
"Even though the 'startprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 's'\n",
"Even though the 'transmat_' attribute is set, it will be overwritten during initialization because 'init_params' contains 't'\n",
"Even though the 'emissionprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 'e'\n",
"Even though the 'startprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 's'\n",
"Even though the 'transmat_' attribute is set, it will be overwritten during initialization because 'init_params' contains 't'\n",
"Even though the 'emissionprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 'e'\n",
"Even though the 'startprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 's'\n",
"Even though the 'transmat_' attribute is set, it will be overwritten during initialization because 'init_params' contains 't'\n",
"Even though the 'emissionprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 'e'\n",
"Even though the 'startprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 's'\n",
"Even though the 'transmat_' attribute is set, it will be overwritten during initialization because 'init_params' contains 't'\n",
"Even though the 'emissionprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 'e'\n",
"Even though the 'startprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 's'\n",
"Even though the 'transmat_' attribute is set, it will be overwritten during initialization because 'init_params' contains 't'\n",
"Even though the 'emissionprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 'e'\n",
"Even though the 'startprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 's'\n",
"Even though the 'transmat_' attribute is set, it will be overwritten during initialization because 'init_params' contains 't'\n",
"Even though the 'emissionprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 'e'\n",
"Even though the 'startprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 's'\n",
"Even though the 'transmat_' attribute is set, it will be overwritten during initialization because 'init_params' contains 't'\n",
"Even though the 'emissionprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 'e'\n",
"Even though the 'startprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 's'\n",
"Even though the 'transmat_' attribute is set, it will be overwritten during initialization because 'init_params' contains 't'\n",
"Even though the 'emissionprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 'e'\n",
"Even though the 'startprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 's'\n",
"Even though the 'transmat_' attribute is set, it will be overwritten during initialization because 'init_params' contains 't'\n",
"Even though the 'emissionprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 'e'\n",
"Even though the 'startprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 's'\n",
"Even though the 'transmat_' attribute is set, it will be overwritten during initialization because 'init_params' contains 't'\n",
"Even though the 'emissionprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 'e'\n",
"Even though the 'startprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 's'\n",
"Even though the 'transmat_' attribute is set, it will be overwritten during initialization because 'init_params' contains 't'\n",
"Even though the 'emissionprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 'e'\n",
"Even though the 'startprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 's'\n",
"Even though the 'transmat_' attribute is set, it will be overwritten during initialization because 'init_params' contains 't'\n",
"Even though the 'emissionprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 'e'\n",
"Even though the 'startprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 's'\n",
"Even though the 'transmat_' attribute is set, it will be overwritten during initialization because 'init_params' contains 't'\n",
"Even though the 'emissionprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 'e'\n",
"Even though the 'startprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 's'\n",
"Even though the 'transmat_' attribute is set, it will be overwritten during initialization because 'init_params' contains 't'\n",
"Even though the 'emissionprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 'e'\n",
"Even though the 'startprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 's'\n",
"Even though the 'transmat_' attribute is set, it will be overwritten during initialization because 'init_params' contains 't'\n",
"Even though the 'emissionprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 'e'\n",
"Even though the 'startprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 's'\n",
"Even though the 'transmat_' attribute is set, it will be overwritten during initialization because 'init_params' contains 't'\n",
"Even though the 'emissionprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 'e'\n",
"Even though the 'startprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 's'\n",
"Even though the 'transmat_' attribute is set, it will be overwritten during initialization because 'init_params' contains 't'\n",
"Even though the 'emissionprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 'e'\n",
"Even though the 'startprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 's'\n",
"Even though the 'transmat_' attribute is set, it will be overwritten during initialization because 'init_params' contains 't'\n",
"Even though the 'emissionprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 'e'\n",
"Even though the 'startprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 's'\n",
"Even though the 'transmat_' attribute is set, it will be overwritten during initialization because 'init_params' contains 't'\n",
"Even though the 'emissionprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 'e'\n",
"Even though the 'startprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 's'\n",
"Even though the 'transmat_' attribute is set, it will be overwritten during initialization because 'init_params' contains 't'\n",
"Even though the 'emissionprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 'e'\n",
"Even though the 'startprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 's'\n",
"Even though the 'transmat_' attribute is set, it will be overwritten during initialization because 'init_params' contains 't'\n",
"Even though the 'emissionprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 'e'\n",
"Even though the 'startprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 's'\n",
"Even though the 'transmat_' attribute is set, it will be overwritten during initialization because 'init_params' contains 't'\n",
"Even though the 'emissionprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 'e'\n",
"Even though the 'startprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 's'\n",
"Even though the 'transmat_' attribute is set, it will be overwritten during initialization because 'init_params' contains 't'\n",
"Even though the 'emissionprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 'e'\n",
"Even though the 'startprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 's'\n",
"Even though the 'transmat_' attribute is set, it will be overwritten during initialization because 'init_params' contains 't'\n",
"Even though the 'emissionprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 'e'\n",
"Even though the 'startprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 's'\n",
"Even though the 'transmat_' attribute is set, it will be overwritten during initialization because 'init_params' contains 't'\n",
"Even though the 'emissionprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 'e'\n",
"Even though the 'startprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 's'\n",
"Even though the 'transmat_' attribute is set, it will be overwritten during initialization because 'init_params' contains 't'\n",
"Even though the 'emissionprob_' attribute is set, it will be overwritten during initialization because 'init_params' contains 'e'\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"[0.11692084241103849, 0.15783704786262331, 0.14619289340101524, 0.1215783860646996, 0.14670308232539991, 0.14045906132237068, 0.15143974404550303, 0.12706995606623858, 0.12127894156560089, 0.11530249110320284, 0.11458333333333333, 0.16469691193290126, 0.1560379918588874, 0.15489422732162064, 0.15068015347052668, 0.18445518780215694, 0.15480304077401522, 0.13828689370485037, 0.1728101466508125, 0.16194625998547568, 0.16495629038388446, 0.1774387796065837, 0.15412058508740634, 0.15793357933579336, 0.14457831325301204, 0.15610113594723343, 0.11690140845070422, 0.1413665432514305, 0.17109375, 0.1608598962194218]\n"
]
}
],
"source": [
"from sklearn.utils import resample\n",
"\n",
"f1_scores = []\n",
"\n",
"for _ in range(30):\n",
" # Resample the training data with replacement\n",
" train_sentences_resampled, y_train_resampled = resample(\n",
" sls_new_sentences, sls_new_labels, replace=True\n",
" )\n",
"\n",
" train_sentences_resampled_encoded = [\n",
" encode_sentence(sentence, vocab) for sentence in train_sentences_resampled\n",
" ]\n",
"\n",
" train_sentences_resampled_flat = [\n",
" item for sublist in train_sentences_resampled_encoded for item in sublist\n",
" ]\n",
"\n",
" # Train the HMM on the resampled data\n",
" hmm.fit(\n",
" np.array(train_sentences_resampled_flat).reshape(-1, 1),\n",
" lengths=[len(sentence) for sentence in y_train_resampled],\n",
" )\n",
"\n",
" # Predict on the test data\n",
" predicted_labels_test_resampled = hmm.predict(\n",
" test_sentences_encoded, test_sentences_lengths\n",
" )\n",
"\n",
" # Compute the F1 score\n",
" f1_resampled = f1_score(\n",
" y_test_flat, predicted_labels_test_resampled, average=\"micro\", labels=[1, 2]\n",
" )\n",
" f1_scores.append(f1_resampled)\n",
"\n",
"print(f1_scores)"
]
},
{
"cell_type": "code",
"execution_count": 137,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[0.11692084241103849,\n",
" 0.15783704786262331,\n",
" 0.14619289340101524,\n",
" 0.1215783860646996,\n",
" 0.14670308232539991,\n",
" 0.14045906132237068,\n",
" 0.15143974404550303,\n",
" 0.12706995606623858,\n",
" 0.12127894156560089,\n",
" 0.11530249110320284,\n",
" 0.11458333333333333,\n",
" 0.16469691193290126,\n",
" 0.1560379918588874,\n",
" 0.15489422732162064,\n",
" 0.15068015347052668,\n",
" 0.18445518780215694,\n",
" 0.15480304077401522,\n",
" 0.13828689370485037,\n",
" 0.1728101466508125,\n",
" 0.16194625998547568,\n",
" 0.16495629038388446,\n",
" 0.1774387796065837,\n",
" 0.15412058508740634,\n",
" 0.15793357933579336,\n",
" 0.14457831325301204,\n",
" 0.15610113594723343,\n",
" 0.11690140845070422,\n",
" 0.1413665432514305,\n",
" 0.17109375,\n",
" 0.1608598962194218]"
]
},
"execution_count": 137,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"f1_scores"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import pickle\n",
"\n",
"with open(\"hmm_f1_results\", \"wb\") as f:\n",
" pickle.dump(f1_scores, f)"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "venv",
"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.12.4"
}
},
"nbformat": 4,
"nbformat_minor": 2
}