| |
| from typing import Tuple, List |
| import re |
| import numpy as np |
| import pandas as pd |
|
|
| import tensorflow as tf |
| from tensorflow import keras |
| from keras.utils import pad_sequences |
| from keras.preprocessing.text import Tokenizer |
| from gensim.models.doc2vec import Doc2Vec |
|
|
| import transformers |
| from transformers import pipeline, BertTokenizer |
|
|
| import fasttext |
|
|
| |
| from preprocessing import Preprocessor |
| from utils import read_data |
|
|
|
|
| |
| X_train, X_test, y_train, y_test = read_data() |
|
|
| |
| preprocessor = Preprocessor() |
|
|
| |
| doc2vec_model_embeddings = Doc2Vec.load( |
| "F:/Graduation Project/Project/models/best_doc2vec_embeddings") |
| doc2vec_model = keras.models.load_model( |
| "F:/Graduation Project/Project/models/best_doc2vec_model.h5") |
| tfidf_model = keras.models.load_model( |
| "F:/Graduation Project/Project/models/best_tfidf_model.h5") |
| cnn_model = keras.models.load_model( |
| "F:/Graduation Project/Project/models/best_cnn_model.h5") |
| glove_model = keras.models.load_model( |
| "F:/Graduation Project/Project/models/best_glove_model.h5") |
| lstm_model = keras.models.load_model( |
| "F:/Graduation Project/Project/models/best_lstm_model.h5") |
| bert_model = keras.models.load_model( |
| "F:/Graduation Project/Project/models/best_bert_model.h5", custom_objects={"TFBertModel": transformers.TFBertModel}) |
| fasttext_model = fasttext.load_model( |
| "F:/Graduation Project/Project/models/best_fasttext_model.bin") |
| summarization_model = pipeline( |
| "summarization", model="facebook/bart-large-cnn") |
|
|
|
|
| |
| def extract_case_information(case_content: str): |
| content_list = case_content.split("\n") |
| petitioner = re.findall(r"petitioner:(.+)", content_list[0])[0] |
| respondent = re.findall(r"respondent:(.+)", content_list[1])[0] |
| facts = re.findall(r"facts:(.+)", content_list[2])[0] |
|
|
| return petitioner, respondent, facts |
|
|
|
|
| def generate_random_sample() -> Tuple[str, str, str, int]: |
| """ |
| Randomly fetch a random case from `X_test` to test it. |
| |
| Returns: |
| -------- |
| A tuple contains the following: |
| - petitioner : str |
| Contains petitioner name. |
| - respondent : str |
| Contains respondent name. |
| - facts : str |
| Contains case facts. |
| - label : int |
| Represents the winning index(0 = petitioner, 1 = respondent). |
| """ |
|
|
| random_idx = np.random.randint(low=0, high=len(X_test)) |
|
|
| petitioner = X_test["first_party"].iloc[random_idx] |
| respondent = X_test["second_party"].iloc[random_idx] |
| facts = X_test["Facts"].iloc[random_idx] |
| label = y_test.iloc[random_idx][0] |
|
|
| return petitioner, respondent, facts, label |
|
|
|
|
| def generate_highlighted_words(facts: str, petitioner_words: List[str], respondent_words: List[str]): |
| """ |
| Highlight `petitioner_words` and `respondent_words` for model |
| interpretation. |
| |
| Parameters: |
| ----------- |
| - facts : str |
| Facts of a specific case. |
| - petitioner_words : List[str] |
| Contains all words that model pays attention |
| to be a petetioner words. |
| - respondent_words : List[str] |
| Contains all words that model pays attention |
| to be a respondent words. |
| |
| Returns: |
| -------- |
| - rendered_text : str |
| Contains the `facts` but with adding |
| highlighting mechanism to visualize it using CSS in HTML format. |
| |
| Example: |
| -------- |
| >>> facts_ = 'Mohammed shot Aly after a hot negotiation happened between |
| ... them about the profits of their company' |
| >>> petitioner_words_ = ['shot', 'hot'] |
| >>> respondent_words_ = ['profits'] |
| >>> generate_highlighted_words(facts, petitioner_words_, respondent_words_) |
| |
| >>> output: |
| <div class='text-facts'> Mohammed <span class='highlight-petitioner'>shot</span> |
| Aly after a <span class='highlight-petitioner'>hot</span> negotiation happened |
| between them about <span class='highlight-respondent'>profits</span> of their |
| company </div> |
| """ |
|
|
| rendered_text = '<div class="text-facts"> ' |
|
|
| for word in facts.split(): |
| if word in petitioner_words: |
| highlight_word = ' <span class="highlight-petitioner"> ' + word + " </span> " |
| rendered_text += highlight_word |
|
|
| elif word in respondent_words: |
| highlight_word = ' <span class="highlight-respondent"> ' + word + " </span> " |
| rendered_text += highlight_word |
|
|
| else: |
| rendered_text += " " + word |
|
|
| rendered_text += " </div>" |
|
|
| return rendered_text |
|
|
|
|
| class VectorizerGenerator: |
| """Responsible for creation and generation of tokenizers and text |
| vectorizers for JudgerAIs' models""" |
|
|
| def __init__(self) -> None: |
| pass |
|
|
| def generate_tf_idf_vectorizer(self) -> keras.layers.TextVectorization: |
| """ |
| Generating best text vectroizer of the tf-idf model (3rd combination). |
| |
| Returns: |
| ------- |
| - text_vectorizer : keras.layers.TextVectorization |
| Represents the case facts' vectorizer that converts case facts to |
| numerical tensors. |
| """ |
|
|
| first_party_names = X_train["first_party"] |
| second_party_names = X_train["second_party"] |
| facts = X_train["Facts"] |
|
|
| anonymized_facts = preprocessor.anonymize_data( |
| first_party_names, second_party_names, facts) |
|
|
| text_vectorizer, _ = preprocessor.convert_text_to_vectors_tf_idf( |
| anonymized_facts) |
|
|
| return text_vectorizer |
|
|
| def generate_cnn_vectorizer(self) -> keras.layers.TextVectorization: |
| """ |
| Generating best text vectroizer of the cnn model (2nd combination). |
| |
| Returns: |
| ------- |
| - text_vectorizer : keras.layers.TextVectorization |
| Represents the case facts' vectorizer that converts case facts to |
| numerical tensors. |
| """ |
|
|
| balanced_df = preprocessor.balance_data(X_train["Facts"], y_train) |
| X_train_balanced = balanced_df["Facts"] |
|
|
| text_vectorizer, _ = preprocessor.convert_text_to_vectors_cnn( |
| X_train_balanced) |
|
|
| return text_vectorizer |
|
|
| def generate_glove_tokenizer(self) -> keras.preprocessing.text.Tokenizer: |
| """ |
| Generating best glove tokenizer of the GloVe model (2nd combination). |
| |
| Returns: |
| ------- |
| - glove_tokenizer : keras.preprocessing.text.Tokenizer |
| Represents the case facts' tokenizer that converts case facts to |
| numerical tensors. |
| """ |
|
|
| balanced_df = preprocessor.balance_data(X_train["Facts"], y_train) |
| X_train_balanced = balanced_df["Facts"] |
|
|
| glove_tokenizer, _ = preprocessor.convert_text_to_vectors_glove( |
| X_train_balanced) |
|
|
| return glove_tokenizer |
|
|
| def generate_lstm_tokenizer(self) -> keras.preprocessing.text.Tokenizer: |
| """ |
| Generating best text tokenizer of the LSTM model (1st combination). |
| |
| Returns: |
| ------- |
| - lstm_tokenizer : keras.preprocessing.text.Tokenizer |
| Represents the case facts' tokenizer that converts case facts to |
| numerical tensors. |
| """ |
|
|
| lstm_tokenizer = Tokenizer(num_words=18430) |
| lstm_tokenizer.fit_on_texts(X_train) |
|
|
| return lstm_tokenizer |
|
|
| def generate_bert_tokenizer(self) -> transformers.BertTokenizer: |
| """ |
| Generating best bert tokenizer of the BERT model (1st combination). |
| |
| Returns: |
| ------- |
| - bert_tokenizer : transformers.BertTokenizer |
| Represents the case facts' tokenizer that converts case facts to |
| input ids tensors. |
| """ |
|
|
| bert_tokenizer = BertTokenizer.from_pretrained('bert-base-cased') |
| return bert_tokenizer |
|
|
|
|
| class DataPreparator: |
| """Responsible for preparing the case facts aka converting case facts to |
| numerical vectors using `VectorizerGenerator` object.""" |
|
|
| def __init__(self) -> None: |
| self.vectorizer_generator = VectorizerGenerator() |
|
|
| def prepare_doc2vec(self, facts: str) -> pd.DataFrame: |
| """ |
| Responsible for converting `facts` string to numerical vector |
| using `doc2vec_model_embeddings`. |
| |
| Parameters: |
| ---------- |
| - facts : str |
| Represents the case facts. |
| |
| Returns: |
| ------- |
| - facts_vector : pd.DataFrame |
| A row DataFrame represents the 50-d vector of the `facts`. |
| """ |
|
|
| facts = pd.Series(facts) |
| facts_processed = preprocessor.preprocess_data(facts) |
| facts_vectors = preprocessor.convert_text_to_vectors_doc2vec( |
| facts_processed, train=False, embeddings_doc2vec=doc2vec_model_embeddings) |
|
|
| return facts_vectors |
|
|
| def _anonymize_facts(self, first_party_name: str, second_party_name: str, facts: str) -> str: |
| """ |
| Anonymize case `facts` by replacing `first_party_name` & `second_party_name` with |
| generic tag "__PARTY__". |
| |
| Parameters: |
| ----------- |
| - first_party_name : str |
| Represents the petitioner name. |
| - second_party_name : str |
| Represents the respondent name. |
| - facts : str |
| Represents the case facts. |
| |
| Returns: |
| ------- |
| - anonymized_facts : str |
| Represents `facts` after anonymization. |
| """ |
|
|
| anonymized_facts = preprocessor._anonymize_case_facts( |
| first_party_name, second_party_name, facts) |
|
|
| return anonymized_facts |
|
|
| def prepare_tf_idf(self, anonymized_facts: str) -> tf.Tensor: |
| """ |
| Responsible for converting `facts` string to numerical vector |
| using tf-idf `vectorizer_generator` in the 3rd combination. |
| |
| Parameters: |
| ----------- |
| - anonymized_facts : str |
| Represents the case facts after anonymization. |
| |
| Returns: |
| ------- |
| - facts_vector : tf.Tensor |
| A Tensor of 10000-d represents `facts`. |
| """ |
|
|
| anonymized_facts = pd.Series(anonymized_facts) |
| tf_idf_vectorizer = self.vectorizer_generator.generate_tf_idf_vectorizer() |
|
|
| facts_vector = preprocessor.convert_text_to_vectors_tf_idf( |
| anonymized_facts, train=False, text_vectorizer=tf_idf_vectorizer) |
|
|
| return facts_vector |
|
|
| def prepare_cnn(self, facts: str) -> tf.Tensor: |
| """ |
| Responsible for converting `facts` string to numerical vector |
| using cnn `vectorizer_generator` in the 2nd combination. |
| |
| Parameters: |
| ----------- |
| - facts : str |
| Represents the case facts. |
| |
| Returns: |
| ------- |
| - facts_vector : tf.Tensor |
| A Tensor of 2000-d represents `facts`. |
| """ |
| facts = pd.Series(facts) |
|
|
| cnn_vectorizer = self.vectorizer_generator.generate_cnn_vectorizer() |
|
|
| facts_vector = preprocessor.convert_text_to_vectors_cnn( |
| facts, train=False, text_vectorizer=cnn_vectorizer) |
|
|
| return facts_vector |
|
|
| def prepare_glove(self, facts: str) -> np.ndarray: |
| """ |
| Responsible for converting `facts` string to numerical vector |
| using glove `vectorizer_generator` in the 2nd combination. |
| |
| Parameters: |
| ----------- |
| - facts : str |
| Represents the case facts. |
| |
| Returns: |
| ------- |
| - facts_vector : np.ndarray |
| A nd.ndarray of 50-d represents `facts`. |
| """ |
|
|
| facts = pd.Series(facts) |
|
|
| glove_tokneizer = self.vectorizer_generator.generate_glove_tokenizer() |
|
|
| facts_vector = preprocessor.convert_text_to_vectors_glove( |
| facts, train=False, glove_tokenizer=glove_tokneizer) |
|
|
| return facts_vector |
|
|
| def prepare_lstm(self, facts: str) -> np.ndarray: |
| """ |
| Responsible for converting `facts` string to numerical vector |
| using lstm `vectorizer_generator` in the 1st combination. |
| |
| Parameters: |
| ----------- |
| - facts : str |
| Represents the case facts. |
| |
| Returns: |
| ------- |
| - facts_vector_padded : np.ndarray |
| A nd.ndarray of 974-d represents `facts`. |
| """ |
|
|
| facts = pd.Series(facts) |
| lstm_tokenizer = self.vectorizer_generator.generate_lstm_tokenizer() |
| facts_vector = lstm_tokenizer.texts_to_sequences(facts) |
| facts_vector_padded = pad_sequences(facts_vector, 974) |
|
|
| return facts_vector_padded |
|
|
| def prepare_bert(self, facts: str) -> tf.Tensor: |
| """ |
| Responsible for converting `facts` string to numerical vector |
| using bert `vectorizer_generator` in the 1st combination. |
| |
| Parameters: |
| ----------- |
| - facts : str |
| Represents the case facts. |
| |
| Returns: |
| ------- |
| - tf.Tensor |
| A tf.Tensor of 256-d represents `facts` input ids. |
| """ |
|
|
| bert_tokenizer = self.vectorizer_generator.generate_bert_tokenizer() |
| facts_vector_dict = bert_tokenizer.encode_plus( |
| facts, |
| max_length=256, |
| truncation=True, |
| padding='max_length', |
| add_special_tokens=True, |
| return_tensors='tf' |
| ) |
|
|
| return facts_vector_dict["input_ids"] |
|
|
|
|
| class Predictor: |
| """Responsible for get predictions of JudgerAIs' models""" |
|
|
| def __init__(self) -> None: |
| self.data_preparator = DataPreparator() |
|
|
| def predict_doc2vec(self, facts: str) -> np.ndarray: |
| """ |
| Get prediction of `facts` using `doc2vec_model`. |
| |
| Parameters: |
| ---------- |
| - facts : str |
| Represents the case facts. |
| |
| Returns: |
| -------- |
| - pet_res_scores : np.ndarray |
| An array contains 2 elements, one for probability of petitioner winning |
| and the second for the probability of respondent winning. |
| """ |
|
|
| facts_vector = self.data_preparator.prepare_doc2vec(facts) |
| predictions = doc2vec_model.predict(facts_vector) |
|
|
| pet_res_scores = [] |
| for i in predictions: |
| temp = i[0] |
| pet_res_scores.append(np.array([1 - temp, temp])) |
|
|
| return np.array(pet_res_scores) |
|
|
| def predict_tf_idf(self, anonymized_facts: str) -> np.ndarray: |
| """ |
| Get prediction of `facts` using `tfidf_model`. |
| |
| Parameters: |
| ----------- |
| - anonymized_facts : str |
| Represents the case facts after anonymization. |
| |
| Returns: |
| -------- |
| - pet_res_scores : np.ndarray |
| An array contains 2 elements, one for probability of petitioner winning |
| and the second for the probability of respondent winning. |
| """ |
|
|
| facts_vector = self.data_preparator.prepare_tf_idf(anonymized_facts) |
| predictions = tfidf_model.predict(facts_vector) |
|
|
| pet_res_scores = [] |
| for i in predictions: |
| temp = i[0] |
| pet_res_scores.append(np.array([1 - temp, temp])) |
|
|
| return np.array(pet_res_scores) |
|
|
| def predict_cnn(self, facts: str) -> np.ndarray: |
| """ |
| Get prediction of `facts` using `cnn_model`. |
| |
| Parameters: |
| ---------- |
| - facts : str |
| Represents the case facts. |
| |
| Returns: |
| -------- |
| - pet_res_scores : np.ndarray |
| An array contains 2 elements, one for probability of petitioner winning |
| and the second for the probability of respondent winning. |
| """ |
|
|
| facts_vector = self.data_preparator.prepare_cnn(facts) |
| predictions = cnn_model.predict(facts_vector) |
|
|
| pet_res_scores = [] |
| for i in predictions: |
| temp = i[0] |
| pet_res_scores.append(np.array([1 - temp, temp])) |
|
|
| return np.array(pet_res_scores) |
|
|
| def predict_glove(self, facts: str) -> np.ndarray: |
| """ |
| Get prediction of `facts` using `glove_model`. |
| |
| Parameters: |
| ---------- |
| - facts : str |
| Represents the case facts. |
| |
| Returns: |
| -------- |
| - pet_res_scores : np.ndarray |
| An array contains 2 elements, one for probability of petitioner winning |
| and the second for the probability of respondent winning. |
| """ |
|
|
| facts_vector = self.data_preparator.prepare_glove(facts) |
| predictions = glove_model.predict(facts_vector) |
|
|
| pet_res_scores = [] |
| for i in predictions: |
| temp = i[0] |
| pet_res_scores.append(np.array([1 - temp, temp])) |
|
|
| return np.array(pet_res_scores) |
|
|
| def predict_lstm(self, facts: str) -> np.ndarray: |
| """ |
| Get prediction of `facts` using `lstm_model`. |
| |
| Parameters: |
| ---------- |
| - facts : str |
| Represents the case facts. |
| |
| Returns: |
| -------- |
| - pet_res_scores : np.ndarray |
| An array contains 2 elements, one for probability of petitioner winning |
| and the second for the probability of respondent winning. |
| """ |
|
|
| facts_vector = self.data_preparator.prepare_lstm(facts) |
| predictions = lstm_model.predict(facts_vector) |
|
|
| pet_res_scores = [] |
| for i in predictions: |
| temp = i[0] |
| pet_res_scores.append(np.array([1 - temp, temp])) |
|
|
| return np.array(pet_res_scores) |
|
|
| def predict_bert(self, facts: str) -> np.ndarray: |
| """ |
| Get prediction of `facts` using `bert_model`. |
| |
| Parameters: |
| ---------- |
| - facts : str |
| Represents the case facts. |
| |
| Returns: |
| -------- |
| - predictions : np.ndarray |
| An array contains 2 elements, one for probability of petitioner winning |
| and the second for the probability of respondent winning. |
| """ |
|
|
| facts_vector = self.data_preparator.prepare_bert(facts) |
| predictions = bert_model.predict(facts_vector) |
|
|
| return predictions |
|
|
| def predict_fasttext(self, facts: str) -> np.ndarray: |
| """ |
| Get prediction of `facts` using `fasttext`. |
| |
| Parameters: |
| ---------- |
| - facts : str |
| Represents the case facts. |
| |
| Returns: |
| -------- |
| - pet_res_scores : np.ndarray |
| An array contains 2 elements, one for probability of petitioner winning |
| and the second for the probability of respondent winning. |
| """ |
|
|
| prediction = fasttext_model.predict(facts)[1] |
| prediction = np.array([prediction]) |
|
|
| pet_res_scores = [] |
| for i in prediction: |
| temp = i[0] |
| pet_res_scores.append(np.array([1 - temp, temp])) |
|
|
| return np.array(pet_res_scores) |
|
|
| def summarize_facts(self, facts: str) -> str: |
| summarized_case_facts = summarization_model(facts)[0]['summary_text'] |
| return summarized_case_facts |
|
|
