Main.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Data Collocation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# taamolat data set\n",
    "taamolat_directory  = 'Authors Dataset/taamolat/'\n",
    "TAAMOLAT_NUMBER_OF_AUTHORS = 7\n",
    "TAAMOLAT_NUMBER_OF_SAMPLES_PER_AUTHOR = 10\n",
    "\n",
    "# alaraby data set\n",
    "alaraby_directory = 'Authors Dataset/alaraby/'\n",
    "ALARABY_NUMBER_OF_AUTHORS = 9\n",
    "ALARABY_NUMBER_OF_SAMPLES_PER_AUTHOR = 10"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Function for return the list of authors names for a specific dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_authors_names(directory_name, number_of_authors):\n",
    "    import configparser\n",
    "\n",
    "    # Create a ConfigParser object\n",
    "    config = configparser.ConfigParser()\n",
    "\n",
    "    # save the authors names in a list\n",
    "    authors = []\n",
    "    for i in range(number_of_authors):\n",
    "        # Read the properties file with the correct encoding (e.g., 'utf-8')\n",
    "        with open(f'{directory_name}a{i}/a{i}_0.properties', encoding='utf-8') as f:\n",
    "            # Add a default section header to the file\n",
    "            content = '[default]\\n' + f.read()\n",
    "            config.read_string(content)\n",
    "\n",
    "        # Get the author name\n",
    "        # Get the value of the 'author_name' key\n",
    "        author_name = config.get('default', 'author_name')\n",
    "        authors.append(author_name)\n",
    "\n",
    "    return authors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "taamolat_authors_english = get_authors_names(taamolat_directory, TAAMOLAT_NUMBER_OF_AUTHORS)\n",
    "# manually add the arabic names of the authors of the taamolat dataset\n",
    "taamolat_authors_names = ['محمد عواد', 'محمد زينوبة', 'يونس جعدي', 'نور الدين رافع', 'عبير قلوطي', 'معتز خطيب', 'إبراهيم نصر الله']\n",
    "taamolat_authors = [ i for i in range(TAAMOLAT_NUMBER_OF_AUTHORS) ]\n",
    "alaraby_authors_names = get_authors_names(alaraby_directory, ALARABY_NUMBER_OF_AUTHORS)\n",
    "alaraby_authors = [ i for i in range(TAAMOLAT_NUMBER_OF_AUTHORS, ALARABY_NUMBER_OF_AUTHORS + TAAMOLAT_NUMBER_OF_AUTHORS) ]\n",
    "\n",
    "# print(taamolat_authors[0], taamolat_authors_names[0])\n",
    "# print(alaraby_authors[0], alaraby_authors_names[0])\n",
    "\n",
    "# print(taamolat_authors)\n",
    "# print(alaraby_authors)\n",
    "\n",
    "all_authors_names = taamolat_authors_names + alaraby_authors_names\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Read the paragraphs of the authors "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get each paragraph with its author\n",
    "def get_paragraphs_with_authors(directory_name, number_of_authors, number_of_samples_per_author, authors_names):\n",
    "    paragraphs = []\n",
    "    for i in range(number_of_authors):\n",
    "        for j in range(number_of_samples_per_author):\n",
    "            with open(f'{directory_name}a{i}/sample{j}.txt', encoding='utf-8') as file:\n",
    "                current_paragraph = ''\n",
    "    \n",
    "                for line in file:\n",
    "                    line = line.strip()\n",
    "                \n",
    "                    if line:  # If the line is not empty\n",
    "                        current_paragraph += line + ' '\n",
    "                    elif current_paragraph:  # If an empty line is encountered and there is a current paragraph\n",
    "                        paragraphs.append((current_paragraph.strip(), authors_names[i]))\n",
    "                        current_paragraph = ''\n",
    "\n",
    "                if current_paragraph:  # Append the last paragraph if it exists after reaching the end of the file\n",
    "                    paragraphs.append((current_paragraph.strip(), authors_names[i]))\n",
    "    return paragraphs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "taamolat_data = get_paragraphs_with_authors(taamolat_directory, TAAMOLAT_NUMBER_OF_AUTHORS, TAAMOLAT_NUMBER_OF_SAMPLES_PER_AUTHOR, taamolat_authors)\n",
    "alaraby_data = get_paragraphs_with_authors(alaraby_directory, ALARABY_NUMBER_OF_AUTHORS, ALARABY_NUMBER_OF_SAMPLES_PER_AUTHOR, alaraby_authors)\n",
    "\n",
    "# for paragraph in taamolat_data:\n",
    "#     print(paragraph)\n",
    "#     print()\n",
    "\n",
    "# for paragraph in alaraby_data:\n",
    "#     print(paragraph)\n",
    "#     print()\n",
    "\n",
    "\n",
    "# combine the two datasets\n",
    "data_set = taamolat_data + alaraby_data\n",
    "# make sure that the data is shuffled\n",
    "import random\n",
    "random.shuffle(data_set)\n",
    "\n",
    "number_of_samples = len(data_set)\n",
    "\n",
    "\n",
    "# for paragraph in data_set:\n",
    "#     print(paragraph)\n",
    "#     print()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Preprocessing The data sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "يشار الا ههاغالاالان اللغه العربيه\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# Normalization: remove diacritics from the text & Punctuation mark removal & Numbers & Non-arabic & alef, teh \n",
    "def normalization(text):\n",
    "    import re\n",
    "    import tnkeeh\n",
    "    from pyarabic.araby import strip_tashkeel, normalize_alef, normalize_teh\n",
    "    text = re.sub(r'[^\\u0621-\\u064A\\s]', '', text)\n",
    "    text = strip_tashkeel(text)\n",
    "    text = normalize_alef(text)\n",
    "    text = normalize_teh(text)\n",
    "    tnkeeh_obj = tnkeeh.Tnkeeh(\n",
    "    remove_special_chars=True,\n",
    "    remove_english=True, normalize=True, remove_diacritics=True,\n",
    "    remove_tatweel=True, remove_html_elements=True,\n",
    "    remove_links=True, remove_twitter_meta=True\n",
    "    )\n",
    "    text = tnkeeh_obj.clean_raw_text(text)[0]\n",
    "    \n",
    "    return text\n",
    "\n",
    "text = \"يْشَارْ إِلَasfgى ةهأغإلأألأَنْ اللُّغَ15+62ة الْعَ?!#@$#^رْبِيَّة\"\n",
    "text = normalization(text)\n",
    "print(text)\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "درس\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# stemming\n",
    "def stemming(word):\n",
    "    from nltk.stem.isri import ISRIStemmer # special stemmer for arabic\n",
    "    # Create an instance of the ISRI Arabic Stemmer\n",
    "\n",
    "    stemmer = ISRIStemmer()\n",
    "    return stemmer.stem(word)\n",
    "\n",
    "text = 'المدرسة'\n",
    "result = stemming(text)\n",
    "print(result)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "# POS tagging\n",
    "def pos_tagging(text):\n",
    "\n",
    "    # from farasa.pos import FarasaPOSTagger\n",
    "    # tagger = FarasaPOSTagger()\n",
    "    # tags = tagger.tag_segments(text, combine_subtokens=True)\n",
    "    # return tags\n",
    "\n",
    "    # import json\n",
    "    # import requests\n",
    "    # api_key = \"mgmfGsWLmIFJznbMaC\"\n",
    "\n",
    "    # url = 'https://farasa.qcri.org/webapi/pos/'\n",
    "    # payload = {'text': text, 'api_key': api_key}\n",
    "    # data = requests.post(url, data=payload)\n",
    "    # result = json.loads(data.text)\n",
    "\n",
    "    # result = result['text']\n",
    "\n",
    "    # words_pos_tags = []\n",
    "    # for obj in result:\n",
    "    #     words_pos_tags.append((obj['surface'], obj['POS']))\n",
    "\n",
    "    # # remove the first and last elements of the list\n",
    "    # words_pos_tags = words_pos_tags[1:-1]\n",
    "\n",
    "    # return words_pos_tags\n",
    "    pass\n",
    "\n",
    "\n",
    "text = 'يُشار إلى أن اللغة العربية'\n",
    "result = pos_tagging(text)\n",
    "print(result)\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['يُشار', 'إلى', 'أن', 'اللغة', 'العربية']\n"
     ]
    }
   ],
   "source": [
    "# tokenization\n",
    "def tokenization(text):\n",
    "    from pyarabic.araby import tokenize\n",
    "    \n",
    "    text = tokenize(text)\n",
    "    return text\n",
    "\n",
    "text = 'يُشار إلى أن اللغة العربية'\n",
    "\n",
    "result = tokenization(text)\n",
    "print(result)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arabic Stop Words"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from nltk.corpus import stopwords\n",
    "\n",
    "stop_words_file_name = 'stop_words.txt'\n",
    "stop_words = []\n",
    "with open(stop_words_file_name, encoding='utf-8') as file:\n",
    "    for line in file:\n",
    "        line = line.strip()\n",
    "        stop_words.append(line)\n",
    "\n",
    "stop_words = list(set(stop_words))\n",
    "stop_words += stopwords.words('arabic')\n",
    "\n",
    "# print(stop_words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def remove_stop_words(words, stop_words=stop_words):\n",
    "    \n",
    "    result = [] \n",
    "    removed_indexes = []\n",
    "    for i in range(len(words)):\n",
    "        if words[i] in stop_words:\n",
    "            removed_indexes.append(i)\n",
    "        else:\n",
    "            result.append(words[i])\n",
    "        \n",
    "    removed_indexes.sort(reverse=True) # for save remove of pos tagging \n",
    "    return result, removed_indexes\n",
    "\n",
    "# remove_stop_words(['هذا', 'هو', 'من', 'الكلمات', 'المستبعدة', 'من', 'التحليل'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Preprocessing: at the beginning we made normlization for the text, then make tokenization for remove the stop words and apply stemming on the words without stop words, \n",
    "after that find the pos tagging on the normalized text with stop words to make corrcot results, the remove the pos tags of the stop words, and just save the stemming words with thier pos tagging"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# def preprocessing(text):\n",
    "#     normalization_text = normalization(text)\n",
    "#     segments = tokenization(normalization_text)\n",
    "\n",
    "#     # remove stop words from the the text after normalization\n",
    "#     words, removed_indexes = remove_stop_words(segments)\n",
    "#     number_of_words = len(words)\n",
    "    \n",
    "#     # find the pos tags for the words in the original text after normalization\n",
    "#     tags = pos_tagging(normalization_text)\n",
    "   \n",
    "\n",
    "#     # remove the tags of the stop words\n",
    "#     for index in removed_indexes:\n",
    "#         tags.pop(index)\n",
    "\n",
    "#     # stemming for the words in the original text after tokenization without stop words\n",
    "#     for i in range(number_of_words):\n",
    "#         words[i] = stemming(words[i])\n",
    "\n",
    "#     sample = []\n",
    "\n",
    "#     # combine the stemming words with their pos tags\n",
    "#     for i in range(number_of_words):\n",
    "#         sample.append((words[i], tags[i][1]))\n",
    "\n",
    "    \n",
    "#     return sample\n",
    "\n",
    "\n",
    "def preprocessing(text):\n",
    "    normalization_text = normalization(text)\n",
    "    segments = tokenization(normalization_text)\n",
    "\n",
    "    # remove stop words from the the text after tokenization\n",
    "    words, _ = remove_stop_words(segments)\n",
    "    number_of_words = len(words)\n",
    "    \n",
    "    \n",
    "    # stemming for the words in the original text after tokenization without stop words\n",
    "    for i in range(number_of_words):\n",
    "        words[i] = stemming(words[i])\n",
    "\n",
    " \n",
    "    return words\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# text = \"أهلاً بكم! هذه الجملة تحتاج للتنظيف. 123\"\n",
    "\n",
    "# result = preprocessing(text)\n",
    "# print(result)\n",
    "# for word in result:\n",
    "#     print(word)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Preprocessing our dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(number_of_samples):\n",
    "    data_set[i] = (preprocessing(data_set[i][0]), data_set[i][1]) # (words, author)\n",
    "\n",
    "# print(data_set)\n",
    "# for sample in data_set:\n",
    "#     print(sample)\n",
    "#     print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Features Extraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "class TFIDFExtractor:\n",
    "    def __init__(self):\n",
    "        from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "        self.vectorizer = TfidfVectorizer()\n",
    "        self.feature_names = None\n",
    "        self.author_names = None\n",
    "\n",
    "    def fit_transform(self, corpus):\n",
    "        # Extract the sentences from the corpus\n",
    "        sentences = [sample[0] for sample in corpus]\n",
    "\n",
    "        # Extract the authors from the corpus\n",
    "        authors = [sample[1] for sample in corpus]\n",
    "\n",
    "        # Convert the sentences to strings\n",
    "        sentences = [' '.join(sentence) for sentence in sentences]\n",
    "\n",
    "        # Fit and transform the sentences\n",
    "        tfidf_matrix = self.vectorizer.fit_transform(sentences)\n",
    "\n",
    "        # Get the feature names (unique words) as columns\n",
    "        self.feature_names = self.vectorizer.get_feature_names()\n",
    "\n",
    "        # Get the author names as rows\n",
    "        self.author_names = authors\n",
    "\n",
    "        return tfidf_matrix.toarray()\n",
    "\n",
    "    def transform(self, corpus):\n",
    "        # Extract the sentences from the corpus\n",
    "        sentences = [sample[0] for sample in corpus]\n",
    "\n",
    "        # Convert the sentences to strings\n",
    "        sentences = [' '.join(sentence) for sentence in sentences]\n",
    "\n",
    "        # Transform the sentences\n",
    "        tfidf_matrix = self.vectorizer.transform(sentences)\n",
    "\n",
    "        return tfidf_matrix.toarray()\n",
    "\n",
    "    def get_feature_names(self):\n",
    "        return self.feature_names\n",
    "    \n",
    "    def get_author_names(self):\n",
    "        return self.author_names\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TF-IDF\n",
    "tf_idf = TFIDFExtractor()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "class WordEmbeddingExtractor:\n",
    "    def __init__(self, vector_size=100, window=10, min_count=1, workers=4, sg=0):\n",
    "        self.vector_size = vector_size\n",
    "        self.window = window\n",
    "        self.min_count = min_count\n",
    "        self.workers = workers\n",
    "        self.sg = sg\n",
    "        self.model = None\n",
    "        self.feature_names = None\n",
    "        self.author_names = None\n",
    "\n",
    "    def fit_transform(self, corpus):\n",
    "        from gensim.models import FastText\n",
    "        import numpy as np\n",
    "        # Extract the sentences from the corpus\n",
    "        sentences = [sample[0] for sample in corpus]\n",
    "\n",
    "        # Extract the authors from the corpus\n",
    "        authors = [sample[1] for sample in corpus]\n",
    "\n",
    "        # Train FastText model\n",
    "        self.model = FastText(sentences, vector_size=self.vector_size, window=self.window,\n",
    "                              min_count=self.min_count, workers=self.workers, sg=self.sg)\n",
    "\n",
    "        # Get the feature names (labeled dimensions) for FastText\n",
    "        self.feature_names = [f't{i}' for i in range(self.vector_size)]\n",
    "\n",
    "        # Get the author names as rows\n",
    "        self.author_names = authors\n",
    "\n",
    "        # Create feature vectors for each sentence\n",
    "        feature_vectors = []\n",
    "        for sentence in sentences:\n",
    "            vectors = [self.model.wv[word] for word in sentence if word in self.model.wv]\n",
    "            if vectors:\n",
    "                sentence_vector = np.mean(vectors, axis=0)\n",
    "            else:\n",
    "                sentence_vector = np.zeros(self.vector_size)\n",
    "            feature_vectors.append(sentence_vector)\n",
    "\n",
    "        # Convert feature vectors to NumPy array\n",
    "        feature_vectors = np.array(feature_vectors)\n",
    "\n",
    "        return feature_vectors\n",
    "\n",
    "    def transform(self, corpus):\n",
    "        import numpy as np\n",
    "        # Extract the sentences from the corpus\n",
    "        sentences = [sample[0] for sample in corpus]\n",
    "\n",
    "        # Create feature vectors for each sentence\n",
    "        feature_vectors = []\n",
    "        for sentence in sentences:\n",
    "            vectors = [self.model.wv[word] for word in sentence if word in self.model.wv]\n",
    "            if vectors:\n",
    "                sentence_vector = np.mean(vectors, axis=0)\n",
    "            else:\n",
    "                sentence_vector = np.zeros(self.vector_size)\n",
    "            feature_vectors.append(sentence_vector)\n",
    "\n",
    "        # Convert feature vectors to NumPy array\n",
    "        feature_vectors = np.array(feature_vectors)\n",
    "\n",
    "        return feature_vectors\n",
    "\n",
    "    def get_feature_names(self):\n",
    "        return self.feature_names\n",
    "    \n",
    "    def get_author_names(self):\n",
    "        return self.author_names\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "fast_text = WordEmbeddingExtractor(vector_size=100, window=10, min_count=1, workers=4, sg=0)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Combine features vectors (TF-IDF + FastText)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\swata\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.9_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python39\\site-packages\\sklearn\\utils\\deprecation.py:87: FutureWarning: Function get_feature_names is deprecated; get_feature_names is deprecated in 1.0 and will be removed in 1.2. Please use get_feature_names_out instead.\n",
      "  warnings.warn(msg, category=FutureWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6276\n"
     ]
    }
   ],
   "source": [
    "tf_idf_matrix = tf_idf.fit_transform(data_set)\n",
    "tf_idf_feature_names, authors_list = tf_idf.get_feature_names(), tf_idf.get_author_names()\n",
    "word_embedding_matrix = fast_text.fit_transform(data_set)\n",
    "word_embedding_feature_names, authors_list = fast_text.get_feature_names(), fast_text.get_author_names()\n",
    "\n",
    "\n",
    "\n",
    "# Combine the feature names\n",
    "combined_feature_names = tf_idf_feature_names + word_embedding_feature_names\n",
    "\n",
    "def combine_feature_vectors(x, y):\n",
    "    import numpy as np\n",
    "    # Combine the feature vectors\n",
    "    return np.concatenate((x, y), axis=1)\n",
    "\n",
    "# Combine the TF-IDF matrix and FastText feature vectors\n",
    "combined_features_vectors = combine_feature_vectors(tf_idf_matrix, word_embedding_matrix)\n",
    "\n",
    "\n",
    "# Create a list of tuples for feature vector-author mapping\n",
    "features_vectors_matrix = list(zip(combined_features_vectors, authors_list))\n",
    "\n",
    "print(len(features_vectors_matrix[0][0]))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Processing Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "# Split the data into training and testing sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(combined_features_vectors, authors_list, test_size=0.2, random_state=42)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluation(model, X_test, y_test):\n",
    "    from sklearn.metrics import precision_score, recall_score, f1_score, accuracy_score\n",
    "    # Predict the labels for the test data\n",
    "    y_pred = model.predict(X_test)\n",
    "\n",
    "    # Calculate the precision\n",
    "    precision = precision_score(y_test, y_pred, average='macro')\n",
    "\n",
    "    # Calculate the recall\n",
    "    recall = recall_score(y_test, y_pred, average='macro')\n",
    "\n",
    "    # Calculate the F1 score\n",
    "    f1 = f1_score(y_test, y_pred, average='macro')\n",
    "\n",
    "    # Calculate the accuracy\n",
    "    accuracy = accuracy_score(y_test, y_pred)\n",
    "\n",
    "    return precision, recall, f1, accuracy\n",
    "\n",
    "    \n",
    "\n",
    "   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SVM Precision: 0.8880\n",
      "SVM Recall: 0.7488\n",
      "SVM F1 score: 0.7917\n",
      "SVM Accuracy: 0.7868\n"
     ]
    }
   ],
   "source": [
    "from sklearn.svm import SVC\n",
    "\n",
    "# Create and train the SVM model with the RBF kernel\n",
    "svm_model = SVC(kernel='linear')\n",
    "svm_model.fit(X_train, y_train)\n",
    "\n",
    "# Make predictions on the test set\n",
    "y_pred = svm_model.predict(X_test)\n",
    "\n",
    "# Evaluate the model\n",
    "precision, recall, f1, accuracy = evaluation(svm_model, X_test, y_test)\n",
    "\n",
    "print(f'SVM Precision: {precision:.4f}')\n",
    "print(f'SVM Recall: {recall:.4f}')\n",
    "print(f'SVM F1 score: {f1:.4f}')\n",
    "print(f'SVM Accuracy: {accuracy:.4f}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Logistic Regression Precision: 0.7886\n",
      "Logistic Regression Recall: 0.5501\n",
      "Logistic Regression F1 score: 0.5754\n",
      "Logistic Regression Accuracy: 0.6646\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\swata\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.9_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python39\\site-packages\\sklearn\\linear_model\\_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "C:\\Users\\swata\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.9_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python39\\site-packages\\sklearn\\metrics\\_classification.py:1318: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n"
     ]
    }
   ],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "\n",
    "# Create and train the logistic regression model\n",
    "logreg_model = LogisticRegression()\n",
    "logreg_model.fit(X_train, y_train)\n",
    "\n",
    "# Make predictions on the test set\n",
    "y_pred_logreg = logreg_model.predict(X_test)\n",
    "\n",
    "# Evaluate the model\n",
    "precision, recall, f1, accuracy = evaluation(logreg_model, X_test, y_test)\n",
    "\n",
    "print(f'Logistic Regression Precision: {precision:.4f}')\n",
    "print(f'Logistic Regression Recall: {recall:.4f}')\n",
    "print(f'Logistic Regression F1 score: {f1:.4f}')\n",
    "print(f'Logistic Regression Accuracy: {accuracy:.4f}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Random Forest Precision: 0.6661\n",
      "Random Forest Recall: 0.5136\n",
      "Random Forest F1 score: 0.5354\n",
      "Random Forest Accuracy: 0.5549\n"
     ]
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "\n",
    "# Create and train the random forest model\n",
    "rf_model = RandomForestClassifier()\n",
    "rf_model.fit(X_train, y_train)\n",
    "\n",
    "# Make predictions on the test set\n",
    "y_pred_rf = rf_model.predict(X_test)\n",
    "\n",
    "# Evaluate the model\n",
    "precision, recall, f1, accuracy = evaluation(rf_model, X_test, y_test)\n",
    "\n",
    "print(f'Random Forest Precision: {precision:.4f}')\n",
    "print(f'Random Forest Recall: {recall:.4f}')\n",
    "print(f'Random Forest F1 score: {f1:.4f}')\n",
    "print(f'Random Forest Accuracy: {accuracy:.4f}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "KNN Precision: 0.8102\n",
      "KNN Recall: 0.7817\n",
      "KNN F1 score: 0.7797\n",
      "KNN Accuracy: 0.7743\n"
     ]
    }
   ],
   "source": [
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "\n",
    "\n",
    "# Create and train the KNN model\n",
    "knn_model = KNeighborsClassifier()\n",
    "knn_model.fit(X_train, y_train)\n",
    "\n",
    "# Make predictions on the test set\n",
    "y_pred_knn = knn_model.predict(X_test)\n",
    "\n",
    "# Evaluate the model\n",
    "precision, recall, f1, accuracy = evaluation(knn_model, X_test, y_test)\n",
    "\n",
    "print(f'KNN Precision: {precision:.4f}')\n",
    "print(f'KNN Recall: {recall:.4f}')\n",
    "print(f'KNN F1 score: {f1:.4f}')\n",
    "print(f'KNN Accuracy: {accuracy:.4f}')\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MLP Precision: 0.9024\n",
      "MLP Recall: 0.7961\n",
      "MLP F1 score: 0.8236\n",
      "MLP Accuracy: 0.8213\n"
     ]
    }
   ],
   "source": [
    "from sklearn.neural_network import MLPClassifier  # FOR CREATE NEURAL NETWORK MODEL\n",
    "\n",
    "# Create and train the MLP model\n",
    "mlp_model = MLPClassifier()\n",
    "mlp_model.fit(X_train, y_train)\n",
    "\n",
    "# Make predictions on the test set\n",
    "y_pred_mlp = mlp_model.predict(X_test)\n",
    "\n",
    "# Evaluate the model\n",
    "precision, recall, f1, accuracy = evaluation(mlp_model, X_test, y_test)\n",
    "\n",
    "print(f'MLP Precision: {precision:.4f}')\n",
    "print(f'MLP Recall: {recall:.4f}')\n",
    "print(f'MLP F1 score: {f1:.4f}')\n",
    "print(f'MLP Accuracy: {accuracy:.4f}')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def confusion_matrix_plot(true_labels, predicted_labels):\n",
    "    import seaborn as sns\n",
    "    import matplotlib.pyplot as plt\n",
    "    from sklearn.metrics import confusion_matrix\n",
    "\n",
    "    # Compute confusion matrix\n",
    "    cm = confusion_matrix(true_labels, predicted_labels)\n",
    "\n",
    "    # Plot the confusion matrix as a heatmap\n",
    "    plt.figure(figsize=(8, 6))\n",
    "    sns.heatmap(cm, annot=True, fmt=\"d\", cmap=\"Blues\", cbar=False)\n",
    "    plt.xlabel(\"Predicted Labels\")\n",
    "    plt.ylabel(\"True Labels\")\n",
    "    plt.title(\"Confusion Matrix\")\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "confusion_matrix_plot(y_test, y_pred_mlp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "# evaluation of all models\n",
    "def evaluation():\n",
    "    import numpy as np\n",
    "    import matplotlib.pyplot as plt\n",
    "\n",
    "    # Model names\n",
    "    models = ['SVM', 'Logistic Regression', 'Random Forest', 'KNN', 'MLP']\n",
    "\n",
    "    # Evaluation metrics\n",
    "    precision = [0.8869, 0.7839, 0.6656, 0.7834, 0.9001]\n",
    "    recall = [0.7649, 0.5731, 0.4586, 0.7266, 0.8197]\n",
    "    f1_scores = [0.7993, 0.5900, 0.4610, 0.7367, 0.8471]\n",
    "    accuracy = [0.7931, 0.6520, 0.5329, 0.7335, 0.8339]\n",
    "\n",
    "    # Sort the models based on F1 scores\n",
    "    sorted_data = sorted(zip(models, f1_scores, precision, recall, accuracy), key=lambda x: x[1], reverse=True)\n",
    "    models, f1_scores, precision, recall, accuracy = zip(*sorted_data)\n",
    "\n",
    "    # Set the width of the bars\n",
    "    bar_width = 0.15\n",
    "\n",
    "    # Set the positions of the bars on the x-axis\n",
    "    r1 = np.arange(len(models))\n",
    "    r2 = [x + bar_width for x in r1]\n",
    "    r3 = [x + bar_width for x in r2]\n",
    "    r4 = [x + bar_width for x in r3]\n",
    "\n",
    "    # Plotting\n",
    "    plt.figure(figsize=(12, 6))\n",
    "    plt.bar(r1, precision, color='b', width=bar_width, edgecolor='white', label='Precision')\n",
    "    plt.bar(r2, recall, color='g', width=bar_width, edgecolor='white', label='Recall')\n",
    "    plt.bar(r3, f1_scores, color='r', width=bar_width, edgecolor='white', label='F1 Score')\n",
    "    plt.bar(r4, accuracy, color='c', width=bar_width, edgecolor='white', label='Accuracy')\n",
    "\n",
    "    # Add xticks and labels\n",
    "    plt.xlabel('Models')\n",
    "    plt.ylabel('Scores')\n",
    "    plt.title('Evaluation Metrics of Different Models')\n",
    "    plt.xticks([r + bar_width*1.5 for r in range(len(models))], models, rotation=45)\n",
    "\n",
    "    # Add a legend\n",
    "    plt.legend()\n",
    "\n",
    "    # Show the plot\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "\n",
    "evaluation()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def modeling(text, model):\n",
    "    processed_text = preprocessing(text)\n",
    "    tf_idf_vector = tf_idf.transform([(processed_text, 0)])\n",
    "    word_embedding_vector = fast_text.transform([(processed_text, 0)])\n",
    "    combined_features_vector = combine_feature_vectors(tf_idf_vector, word_embedding_vector)\n",
    "    return model.predict(combined_features_vector)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For check different texts from same authors or not"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "01c9c2e611ed4d1c8cc24b5bf6510e6f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Label(value='Text 1:')"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2f94ab7af95842e2b95ea804ee410797",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Textarea(value='', layout=Layout(width='400px'), rows=5)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "fbcf328e10bf41909bf3ab4494bd4a3e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Label(value='Text 2:')"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f3bb6e6066a6499db1247bd822cacde6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Textarea(value='', layout=Layout(width='400px'), rows=5)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7baeb04e0d8940139ab725acc87aa955",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Dropdown(description='Model:', options=('SVM Model', 'KNN Model', 'Random Forest Model', 'Logistic Regression …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "baea86851c34491b9c9801ffb406eb55",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Button(description='Process', style=ButtonStyle())"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "71cf308ac13744be81255766989165a8",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Label(value='Result:', layout=Layout(width='1000px'))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import ipywidgets as widgets\n",
    "from IPython.display import display\n",
    "\n",
    "# Define the available models\n",
    "models = {\n",
    "    'SVM Model': svm_model,\n",
    "    'KNN Model': knn_model,\n",
    "    'Random Forest Model': rf_model,\n",
    "    'Logistic Regression Model': logreg_model,\n",
    "    'MLP Model': mlp_model\n",
    "}\n",
    "\n",
    "# Create the dropdown widget\n",
    "model_dropdown = widgets.Dropdown(options=models.keys(), description='Model:')\n",
    "\n",
    "def process_text(btn):\n",
    "    input_text1 = input_field1.value.strip()  # Get input text from the first text field\n",
    "    input_text2 = input_field2.value.strip()  # Get input text from the second text field\n",
    "\n",
    "    # Get the selected model\n",
    "    selected_model = models[model_dropdown.value]\n",
    "\n",
    "    text1_result = modeling(input_text1, selected_model)[0]  # Get the result for the first text\n",
    "    text2_result = modeling(input_text2, selected_model)[0] # Get the result for the second text\n",
    "\n",
    "\n",
    "    author1 = all_authors_names[text1_result]\n",
    "    author2 = all_authors_names[text2_result]\n",
    "\n",
    "    # Display the results\n",
    "    result_label.value = f'Result: {\"Same Author\" if author1 == author2 else \"Different Authors \"} Text 1 is written by {author1} and Text 2 is written by {author2}'\n",
    "\n",
    "\n",
    "# Create the labels\n",
    "label1 = widgets.Label(value='Text 1:')\n",
    "label2 = widgets.Label(value='Text 2:')\n",
    "result_label = widgets.Label(value='Result:', layout=widgets.Layout(width='1000px'))\n",
    "\n",
    "# Create the input fields\n",
    "input_field1 = widgets.Textarea(value='', rows=5, layout=widgets.Layout(width='400px'))\n",
    "input_field2 = widgets.Textarea(value='', rows=5, layout=widgets.Layout(width='400px'))\n",
    "\n",
    "# Create the button\n",
    "button = widgets.Button(description='Process')\n",
    "button.on_click(process_text)\n",
    "\n",
    "# Display the GUI elements\n",
    "display(label1, input_field1, label2, input_field2, model_dropdown, button, result_label)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2fa40b5ca9934bf19707fe914813ca9f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Label(value='Text:')"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "dc26f62321894be7b5fa48c8850c1ab9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Textarea(value='', layout=Layout(width='400px'), rows=5)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4bff3c408f494c7eb537fd17ea663a57",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Dropdown(description='Model:', options=('SVM Model', 'KNN Model', 'Random Forest Model', 'Logistic Regression …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f7a8eb5d515b4d4680b1a196e9b1a45b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Button(description='Process', style=ButtonStyle())"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "50615468a3a94e84ad3b76e5bc5ff7ef",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Label(value='Result:', layout=Layout(width='1000px'))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import ipywidgets as widgets\n",
    "from IPython.display import display\n",
    "\n",
    "# Define the available models\n",
    "models = {\n",
    "    'SVM Model': svm_model,\n",
    "    'KNN Model': knn_model,\n",
    "    'Random Forest Model': rf_model,\n",
    "    'Logistic Regression Model': logreg_model,\n",
    "    'MLP Model': mlp_model\n",
    "}\n",
    "\n",
    "# Create the dropdown widget\n",
    "model_dropdown = widgets.Dropdown(options=models.keys(), description='Model:')\n",
    "\n",
    "def process_text(btn):\n",
    "    input_text1 = input_field1.value.strip()  # Get input text from the first text field\n",
    "\n",
    "     # Get the selected model\n",
    "    selected_model = models[model_dropdown.value]\n",
    "\n",
    "    text1_result = modeling(input_text1, selected_model)[0]  # Get the result for the first text\n",
    "\n",
    "\n",
    "    author1 = all_authors_names[text1_result]\n",
    "\n",
    "    # Display the results\n",
    "    result_label.value = f'Result: the Text is written by {author1}'\n",
    "\n",
    "\n",
    "# Create the labels\n",
    "label1 = widgets.Label(value='Text:')\n",
    "\n",
    "result_label = widgets.Label(value='Result:', layout=widgets.Layout(width='1000px'))\n",
    "\n",
    "# Create the input fields\n",
    "input_field1 = widgets.Textarea(value='', rows=5, layout=widgets.Layout(width='400px'))\n",
    "\n",
    "# Create the button\n",
    "button = widgets.Button(description='Process')\n",
    "button.on_click(process_text)\n",
    "\n",
    "# Display the GUI elements\n",
    "display(label1, input_field1, model_dropdown, button, result_label)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.9.13"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}