Upload datasets.ipynb

datasets.ipynb

@@ -0,0 +1,767 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Kütüphaneler eklenmesi"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\gitProjects\\yeni\\.venv\\lib\\site-packages\\tqdm\\auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n"
+     ]
+    }
+   ],
+   "source": [
+    "from datasets import load_dataset\n",
+    "import pandas as pd \n",
+    "from pymongo import MongoClient\n",
+    "from transformers import BertTokenizer, BertForMaskedLM, DPRContextEncoderTokenizer,DPRContextEncoder;\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Parquet dosyalarının dataframe olarak yüklenmesi(okuma yapabilmek için)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Parquet dosyalarını DataFrame olarak yükleyin\n",
+    "train_df1 = pd.read_parquet('C:\\\\gitProjects\\\\yeni\\\\wikipedia-tr\\\\data\\\\train-00000-of-00002-ed6b025df7a1f653.parquet')\n",
+    "train_df2 = pd.read_parquet('C:\\\\gitProjects\\\\yeni\\\\wikipedia-tr\\\\data\\\\train-00001-of-00002-0aa63953f8b51c17.parquet')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# İki DataFrame'i birleştirin\n",
+    "merged_train = pd.concat([train_df1, train_df2], ignore_index=True)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Örneğin %80 train, %20 test olarak ayırın\n",
+    "train_data = merged_train.sample(frac=0.8, random_state=42)\n",
+    "test_data = merged_train.drop(train_data.index)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "\n",
+    "# Dosya yolları\n",
+    "train_dir = 'C:\\\\gitProjects\\\\yeni\\\\datasets\\\\train_Egitim'\n",
+    "test_dir = 'C:\\\\gitProjects\\\\yeni\\\\datasets\\\\test_Egitim'\n",
+    "train_file_path = os.path.join(train_dir, 'merged_train.parquet')\n",
+    "test_file_path = os.path.join(test_dir, 'merged_test.parquet')\n",
+    "\n",
+    "# Dizinlerin var olup olmadığını kontrol etme, gerekirse oluşturma\n",
+    "os.makedirs(train_dir, exist_ok=True)\n",
+    "os.makedirs(test_dir, exist_ok=True)\n",
+    "\n",
+    "# Veriyi .parquet formatında kaydetme\n",
+    "train_data.to_parquet(train_file_path)\n",
+    "test_data.to_parquet(test_file_path)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Dataframe deki bilgileri görme "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "             id                                                url  \\\n",
+      "515773  3525037  https://tr.wikipedia.org/wiki/P%C5%9F%C4%B1qo%...   \n",
+      "517811  3532700      https://tr.wikipedia.org/wiki/Craterolophinae   \n",
+      "436350  3203545           https://tr.wikipedia.org/wiki/Notocrabro   \n",
+      "223281  1765445    https://tr.wikipedia.org/wiki/Ibrahim%20Sissoko   \n",
+      "100272   575462        https://tr.wikipedia.org/wiki/Salah%20Cedid   \n",
+      "\n",
+      "                  title                                               text  \n",
+      "515773    Pşıqo Ahecaqo  Pşıqo Ahecaqo (), Çerkes siyasetçi, askeri kom...  \n",
+      "517811  Craterolophinae  Craterolophinae, Depastridae familyasına bağlı...  \n",
+      "436350       Notocrabro  Notocrabro Crabronina oymağına bağlı bir cinst...  \n",
+      "223281  Ibrahim Sissoko  İbrahim Sissoko (d. 30 Kasım 1991), Fildişi Sa...  \n",
+      "100272      Salah Cedid  Salah Cedid (1926-1993) (Arapça: صلاح جديد) Su...  \n",
+      "    id                                             url        title  \\\n",
+      "5   35       https://tr.wikipedia.org/wiki/Karl%20Marx    Karl Marx   \n",
+      "13  48         https://tr.wikipedia.org/wiki/Ruhi%20Su      Ruhi Su   \n",
+      "15  53        https://tr.wikipedia.org/wiki/Bilgisayar   Bilgisayar   \n",
+      "18  59          https://tr.wikipedia.org/wiki/Edebiyat     Edebiyat   \n",
+      "19  64  https://tr.wikipedia.org/wiki/M%C3%BChendislik  Mühendislik   \n",
+      "\n",
+      "                                                 text  \n",
+      "5   Karl Marx (; 5 Mayıs 1818, Trier – 14 Mart 188...  \n",
+      "13  Mehmet Ruhi Su (1 Ocak 1912, Van - 20 Eylül 19...  \n",
+      "15  Bilgisayar, aritmetik veya mantıksal işlem diz...  \n",
+      "18  Edebiyat, yazın veya literatür; olay, düşünce,...  \n",
+      "19  Mühendis, insanların her türlü ihtiyacını karş...  \n"
+     ]
+    }
+   ],
+   "source": [
+    "print(train_data.head())\n",
+    "print(test_data.head())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "MongoDb'ye bağlama ve bilgi çekme "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " Veriler başarıyla Collection(Database(MongoClient(host=['localhost:27017'], document_class=dict, tz_aware=False, connect=True), 'EgitimDatabase'), 'train') MongoDb koleksiyonuna indirildi.\n",
+      " Veriler başarıyla Collection(Database(MongoClient(host=['localhost:27017'], document_class=dict, tz_aware=False, connect=True), 'EgitimDatabase'), 'test') MongoDb koleksiyonuna indirildi.\n"
+     ]
+    }
+   ],
+   "source": [
+    "import pandas as pd\n",
+    "from pymongo import MongoClient\n",
+    "\n",
+    "def get_mongodb(database_name='EgitimDatabase', train_collection_name='train', test_collection_name='test', host='localhost', port=27017):\n",
+    "    \"\"\"\n",
+    "    MongoDB connection and collection selection for train and test collections.\n",
+    "    \"\"\"\n",
+    "    client = MongoClient(f'mongodb://{host}:{port}/')\n",
+    "    \n",
+    "    # Veritabanını seçin\n",
+    "    db = client[database_name]\n",
+    "    \n",
+    "    # Train ve test koleksiyonlarını seçin\n",
+    "    train_collection = db[train_collection_name]\n",
+    "    test_collection = db[test_collection_name]\n",
+    "    \n",
+    "    return train_collection, test_collection\n",
+    "\n",
+    "# Function to load dataset into MongoDB\n",
+    "def dataset_read(train_file_path,test_file_path):\n",
+    "    data_train = pd.read_parquet(train_file_path, columns=['id', 'url', 'title', 'text'])\n",
+    "    data_test = pd.read_parquet(test_file_path, columns=['id', 'url', 'title', 'text'])\n",
+    "    data_dict_train = data_train.to_dict(\"records\")\n",
+    "    data_dict_test = data_test.to_dict(\"records\")\n",
+    "\n",
+    "\n",
+    "\n",
+    "    # Get the MongoDB collections\n",
+    "    train_collection, test_collection = get_mongodb(database_name='EgitimDatabase')\n",
+    "\n",
+    " \n",
+    "\n",
+    "    # Insert data into MongoDB\n",
+    "    train_collection.insert_many(data_dict_train)\n",
+    "    test_collection.insert_many(data_dict_test)\n",
+    "\n",
+    "\n",
+    "    print(f\" Veriler başarıyla {train_collection} MongoDb koleksiyonuna indirildi.\")\n",
+    "    print(f\" Veriler başarıyla {test_collection} MongoDb koleksiyonuna indirildi.\")\n",
+    "    return train_collection,test_collection\n",
+    "\n",
+    "# Train ve test datasetlerini MongoDB'ye yüklemek için fonksiyonu çağır\n",
+    "train_file_path = 'C:\\\\gitProjects\\\\bert\\\\datasets\\\\train_Egitim\\\\merged_train.parquet'\n",
+    "test_file_path = 'C:\\\\gitProjects\\\\bert\\\\datasets\\\\test_Egitim\\\\merged_test.parquet'\n",
+    "\n",
+    "train_collection, test_collection = dataset_read(train_file_path, test_file_path)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "MongoDb üzerinden title ve text verilerinin çekilmesi "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
+    "from sentence_transformers import SentenceTransformer\n",
+    "\n",
+    "#bert base modeli \n",
+    "model = SentenceTransformer(\"emrecan/bert-base-turkish-cased-mean-nli-stsb-tr\")\n",
+    "\n",
+    "#text dosyasını koleksiyon üzerinden çekme \n",
+    "# Database sınıfı: Veritabanı bağlantıları ve verileri çekme işlevleri\n",
+    "# Database sınıfı: Veritabanı bağlantıları ve verileri çekme işlevleri\n",
+    "class Database:\n",
+    "    @staticmethod\n",
+    "    def get_mongodb():\n",
+    "        # MongoDB bağlantı bilgilerini döndürecek şekilde tanımlanmıştır.\n",
+    "        return 'mongodb://localhost:27017/', 'EgitimDatabase', 'train'\n",
+    "\n",
+    "    @staticmethod\n",
+    "    def get_input_titles():\n",
+    "        mongo_url, db_name, collection_name = Database.get_mongodb()\n",
+    "        client = MongoClient(mongo_url)\n",
+    "        db = client[db_name]\n",
+    "        collection = db[collection_name]\n",
+    "        query = {\"title\": {\"$exists\": True}}\n",
+    "        cursor = collection.find(query, {\"title\": 1, \"_id\": 0})\n",
+    "        # Başlıkları listeye aldık\n",
+    "        title_from_db = [doc['title'] for doc in cursor]\n",
+    "        title_count = len(title_from_db)\n",
+    "        return title_from_db, title_count\n",
+    "    \n",
+    "    @staticmethod\n",
+    "    def get_input_texts():\n",
+    "        mongo_url, db_name, collection_name = Database.get_mongodb()\n",
+    "        client = MongoClient(mongo_url)\n",
+    "        db = client[db_name]\n",
+    "        collection = db[collection_name]\n",
+    "        query = {\"text\": {\"$exists\": True}}\n",
+    "        cursor = collection.find(query, {\"text\": 1, \"_id\": 0})\n",
+    "        text_from_db = [doc['text'] for doc in cursor]\n",
+    "        text_count= len(text_from_db)\n",
+    "        return text_from_db,text_count\n",
+    "\n",
+    "\n",
+    "# Veritabanından başlıklar ve metinler alınır\n",
+    "titles, title_count = Database.get_input_titles()\n",
+    "texts = Database.get_input_texts()\n",
+    "\n",
+    "#sonuçların belirlenmesi\n",
+    "documents = titles + texts\n",
+    "print(f\"Başlıklar: {titles}\")\n",
+    "print(f\"Başlık sayısı: {title_count}\")\n",
+    "#print(f\"Metinler: {texts}\")\n",
+    "print(f\"Metin sayısı: {len(texts)}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "TF-IDF HESAPLAMA"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pymongo import MongoClient\n",
+    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
+    "from textblob import TextBlob as tb\n",
+    "import numpy as np\n",
+    "import math\n",
+    "\n",
+    "class Database:\n",
+    "    @staticmethod\n",
+    "    def get_mongodb():\n",
+    "        return 'mongodb://localhost:27017/', 'EgitimDatabase', 'train'\n",
+    "\n",
+    "    @staticmethod\n",
+    "    def get_input_documents(limit=3):\n",
+    "        mongo_url, db_name, collection_name = Database.get_mongodb()\n",
+    "        client = MongoClient(mongo_url)\n",
+    "        db = client[db_name]\n",
+    "        collection = db[collection_name]\n",
+    "        cursor = collection.find().limit(limit)\n",
+    "        documents = [doc for doc in cursor]\n",
+    "        document_count = len(documents)\n",
+    "        return documents, document_count\n",
+    "\n",
+    "class Tf:\n",
+    "    @staticmethod\n",
+    "    def tf(word, blob):\n",
+    "        return blob.words.count(word) / len(blob.words)\n",
+    "\n",
+    "    @staticmethod\n",
+    "    def n_containing(word, bloblist):\n",
+    "        return sum(1 for blob in bloblist if word in blob.words)\n",
+    "\n",
+    "    @staticmethod\n",
+    "    def idf(word, bloblist):\n",
+    "        return math.log(len(bloblist) / (1 + Tf.n_containing(word, bloblist)))\n",
+    "\n",
+    "    @staticmethod\n",
+    "    def tfidf(word, blob, bloblist):\n",
+    "        return Tf.tf(word, blob) * Tf.idf(word, bloblist)\n",
+    "\n",
+    "    @staticmethod\n",
+    "    def get_input_documents(limit=3):\n",
+    "        return Database.get_input_documents(limit)\n",
+    "\n",
+    "# Kullanım örneği\n",
+    "documents, document_count = Tf.get_input_documents(limit=3)\n",
+    "\n",
+    "# Dokümanları işleyerek TF-IDF hesaplama\n",
+    "\n",
+    "blobs = [tb(doc.get('text', '')) for doc in documents]  # veya 'title' kullanarak başlıkları işleyebilirsiniz\n",
+    "all_words = set(word for blob in blobs for word in blob.words)\n",
+    "\n",
+    "tfidf_scores = {}\n",
+    "for word in all_words:\n",
+    "    tfidf_scores[word] = [Tf.tfidf(word, blob, blobs) for blob in blobs]\n",
+    "\n",
+    "print(\"TF-IDF Skorları:\")\n",
+    "for word, scores in tfidf_scores.items():\n",
+    "    print(f\"Kelime: {word}, Skorlar: {scores}\")\n",
+    "\n",
+    "\n",
+    "\n",
+    "\n",
+    "\"\"\"turkish_stop_words = set([\n",
+    "        'ad', 'adım', 'ah', 'ama', 'an', 'ancak', 'araba', 'aralar', 'aslında', \n",
+    "     'b', 'bazı', 'belirli', 'ben', 'bence', 'bunu', 'burada', 'biz', 'bu', 'buna', 'çünkü', \n",
+    "    'da', 'de', 'demek', 'den', 'derken', 'değil', 'daha', 'dolayı',  'edilir', 'eğer', 'en', 'fakat', \n",
+    "    'genellikle', 'gibi', 'hem', 'her', 'herhangi', 'hiç', 'ise', 'işte', 'itibaren', 'iyi', 'kadar', \n",
+    "    'karşı', 'ki', 'kime', 'kısaca', 'mu', 'mü', 'nasıl', 'ne', 'neden', 'niye', 'o', 'olabilir', 'oluşur', \n",
+    "    'önce', 'şu', 'sadece', 'se', 'şey', 'şimdi', 'tabi', 'tüm', 've', 'ya', 'ya da', 'yani', 'yine'\n",
+    "])\n",
+    "def calculate_tfidf(documents):\n",
+    "    vectorizer = TfidfVectorizer(stop_words=turkish_stop_words, max_features=10000)  # max_features ile özellik sayısını sınırlıyoruz\n",
+    "    tfidf_matrix = vectorizer.fit_transform(documents)\n",
+    "    feature_names = vectorizer.get_feature_names_out()\n",
+    "    return tfidf_matrix, feature_names\n",
+    "\n",
+    "#feature_names lerin belirlenmesi grekir \n",
+    "tfidf_matrix, feature_names=calculate_tfidf(documents)\n",
+    "\n",
+    "\n",
+    "\n",
+    "# En yüksek TF-IDF skorlarına sahip anahtar kelimeleri çıkarın\n",
+    "#sıkışık format kullanmarak tf-ıdf matrisini işleme \n",
+    "def get_top_n_keywords_sparse(n=10):\n",
+    "\n",
+    "    # TF-IDF hesaplayıcı oluşturun\n",
+    "    vectorizer = TfidfVectorizer()\n",
+    "\n",
+    "    # Başlıklar ve metinler ile TF-IDF matrisini oluşturun\n",
+    "    texts = Database.get_input_texts()\n",
+    "    titles = Database.get_input_titles()\n",
+    "    \n",
+    "\n",
+    "    #title ve text değerlerini alarak vektörleştirdik.\n",
+    "    tfidf_matrix = vectorizer.fit_transform(documents)\n",
+    "\n",
+    "    # Özellik adlarını (kelimeleri) alın\n",
+    "\n",
+    "    feature_names = vectorizer.get_feature_names_out()\n",
+    "\n",
+    "    # TF-IDF sonuçlarını DataFrame'e dönüştürün\n",
+    "    df = pd.DataFrame(tfidf_matrix.toarray(), columns=feature_names)\n",
+    "    print(df)\n",
+    "    keywords = {}\n",
+    "    for i in range(tfidf_matrix.shape[0]):\n",
+    "        row = tfidf_matrix[i].toarray().flatten() #list yapısından çıkarma \n",
+    "        sorted_indices = row.argsort()[::-1]  # Büyükten küçüğe sıralama\n",
+    "        top_indices = sorted_indices[:n]\n",
+    "        top_keywords = [feature_names[idx] for idx in top_indices]\n",
+    "        keywords[i] = top_keywords\n",
+    "    return keywords\"\"\"\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "#---------------------------------------------------------------------------------------------------------------------------------\n",
+    "#transformers kütüphanesine ait generation fonksiyonu özellikleri ,PyTorch generate() is implemented in GenerationMixin. \n",
+    "\n",
+    "\n",
+    "\"\"\"from transformers import GenerationConfig\n",
+    "\n",
+    "# Download configuration from huggingface.co and cache.\n",
+    "generation_config = GenerationConfig.from_pretrained(\"openai-community/gpt2\")\n",
+    "\n",
+    "# E.g. config was saved using *save_pretrained('./test/saved_model/')*\n",
+    "generation_config.save_pretrained(\"./test/saved_model/\")\n",
+    "generation_config = GenerationConfig.from_pretrained(\"./test/saved_model/\")\n",
+    "\n",
+    "# You can also specify configuration names to your generation configuration file\n",
+    "generation_config.save_pretrained(\"./test/saved_model/\", config_file_name=\"my_configuration.json\")\n",
+    "generation_config = GenerationConfig.from_pretrained(\"./test/saved_model/\", \"my_configuration.json\")\n",
+    "\n",
+    "# If you'd like to try a minor variation to an existing configuration, you can also pass generation\n",
+    "# arguments to `.from_pretrained()`. Be mindful that typos and unused arguments will be ignored\n",
+    "generation_config, unused_kwargs = GenerationConfig.from_pretrained(\n",
+    "    \"openai-community/gpt2\", top_k=1, foo=False, do_sample=True, return_unused_kwargs=True\n",
+    ")\n",
+    "generation_config.top_k\n",
+    "\n",
+    "unused_kwargs\n",
+    "\"\"\"\n",
+    "\n",
+    "\n",
+    "#tf-ıdf hesaplama (anahtar kelimeler için) #Bir kelimenin TF IDF puanı ne kadar yüksekse, kelime bulunduğu belgeyle o kadar alakalıdır.\n",
+    "\n",
+    "turkish_stop_words = set([\n",
+    "    'a', 'abide', 'abi', 'abla', 'ad', 'adım', 'ah', 'ama', 'an', 'ancak', 'araba', 'aralar', 'aslında', \n",
+    "    'aşşağı', 'az', 'b', 'bazı', 'belirli', 'ben', 'bence', 'bunu', 'burada', 'biz', 'bu', 'buna', 'çünkü', \n",
+    "    'da', 'de', 'demek', 'den', 'derken', 'değil', 'daha', 'dolayı', 'e', 'edilir', 'eğer', 'en', 'fakat', \n",
+    "    'genellikle', 'gibi', 'hem', 'her', 'herhangi', 'hiç', 'i', 'ise', 'işte', 'itibaren', 'iyi', 'kadar', \n",
+    "    'karşı', 'ki', 'kime', 'kısaca', 'mu', 'mü', 'nasıl', 'ne', 'neden', 'niye', 'o', 'olabilir', 'oluşur', \n",
+    "    'önce', 'şu', 'sadece', 'sana', 'se', 'şey', 'şimdi', 'tabi', 'tüm', 've', 'ya', 'ya da', 'yani', 'yine'\n",
+    "])\n",
+    "\n",
+    "# TF-IDF hesaplayıcı oluşturun ve Türkçe durak kelimelerini dahil edin\n",
+    "vectorizer = TfidfVectorizer(stop_words=turkish_stop_words)\n",
+    "\n",
+    "\n",
+    "\"\"\"IDF, derlemedeki belge sayısının,\n",
+    "incelenen anahtar kelimeyi içeren topluluktaki belge sayısına \n",
+    "bölünmesiyle elde edilen algoritmadır. \n",
+    "Yani ters belge sıklığı bir terimin önemini ölçer,\n",
+    "toplam belge sayısının, terimi içeren belge sayısına bölünmesiyle elde edilir.\n",
+    "külliyat yani incelenen tüm belgelerin adedi 10 ise ve test edilen anahtar kelime,\n",
+    "külliyattaki üç belgede görünüyorsa, bu durumda IDF değeri 0.52’dir (log (10/3)).\"\"\"\n",
+    "#TF-IDF puanı; Naive Bayes ve Destek Vektör Makineleri gibi algoritmalara aktarılabilir. Böylece kelime sayısı gibi daha temel yöntemlerin sonuçları büyük ölçüde iyileştirilebilir.\n",
+    "#IDF = log ( Dokuman Sayısı / Terimin Geçtiği Dokuman Sayısı )\n",
+    "#dokuman sayısılarını almakla başlayacağız.\n",
+    "#  : titlelerın sayısı / terimler ise \n",
+    "\n",
+    "document_number=416434\n",
+    "\"\"\"Sonuç olarak TF IDF’nin, SEO’da pratik ve önemli bir kullanım alanına sahip olduğunu söylenebilir,\n",
+    " özellikle yüksek kaliteli içeriğin optimize edilmesinde ve oluşturulmasında yararlıdır. \n",
+    " Ancak TF IDF, içerik optimizasyonu için tek başına kullanıldığında ciddi sınırlamalarla karşı karşıya kalır:\"\"\"\n",
+    "\n",
+    "# TF-IDF hesaplayıcı oluşturun\n",
+    "vectorizer = TfidfVectorizer()\n",
+    "\n",
+    "# Başlıklar ve metinler ile TF-IDF matrisini oluşturun\n",
+    "texts = Database.get_input_texts()\n",
+    "titles,title_count = Database.get_input_titles()\n",
+    "documents = titles + texts  # Başlıklar ve metinleri birleştir\n",
+    "\n",
+    "#title ve text değerlerini alarak vektörleştirdik.\n",
+    "tfidf_matrix = vectorizer.fit_transform(documents)\n",
+    "\n",
+    "# Özellik adlarını (kelimeleri) alın\n",
+    "\n",
+    "feature_names = vectorizer.get_feature_names_out()\n",
+    "\n",
+    "# TF-IDF sonuçlarını DataFrame'e dönüştürün\n",
+    "df = pd.DataFrame(tfidf_matrix.toarray(), columns=feature_names)\n",
+    "\n",
+    "\n",
+    "\"\"\"def get_top_n_keywords(df, n=10):\n",
+    "    keywords = {}\n",
+    "    for i, row in df.iterrows():\n",
+    "        sorted_row = row.sort_values(ascending=False)\n",
+    "        top_keywords = sorted_row.head(n).index\n",
+    "        keywords[i] = top_keywords.tolist()\n",
+    "    return keywords\"\"\"\n",
+    "\n",
+    "# En yüksek TF-IDF skorlarına sahip anahtar kelimeleri çıkarın\n",
+    "#sıkışık format kullanmarak tf-ıdf matrisini işleme \n",
+    "def get_top_n_keywords_sparse(n=10):\n",
+    "\n",
+    "    # TF-IDF hesaplayıcı oluşturun\n",
+    "    vectorizer = TfidfVectorizer()\n",
+    "\n",
+    "    # Başlıklar ve metinler ile TF-IDF matrisini oluşturun\n",
+    "    texts = Database.get_input_texts()\n",
+    "    titles = Database.get_input_titles()\n",
+    "    \n",
+    "\n",
+    "    #title ve text değerlerini alarak vektörleştirdik.\n",
+    "    tfidf_matrix = vectorizer.fit_transform(documents)\n",
+    "\n",
+    "    # Özellik adlarını (kelimeleri) alın\n",
+    "\n",
+    "    feature_names = vectorizer.get_feature_names_out()\n",
+    "\n",
+    "    # TF-IDF sonuçlarını DataFrame'e dönüştürün\n",
+    "    df = pd.DataFrame(tfidf_matrix.toarray(), columns=feature_names)\n",
+    "    print(df)\n",
+    "    keywords = {}\n",
+    "    for i in range(tfidf_matrix.shape[0]):\n",
+    "        row = tfidf_matrix[i].toarray().flatten() #list yapısından çıkarma \n",
+    "        sorted_indices = row.argsort()[::-1]  # Büyükten küçüğe sıralama\n",
+    "        top_indices = sorted_indices[:n]\n",
+    "        top_keywords = [feature_names[idx] for idx in top_indices]\n",
+    "        keywords[i] = top_keywords\n",
+    "    return keywords\n",
+    "\n",
+    "\n",
+    "top_keywords = get_top_n_keywords_sparse(tfidf_matrix, feature_names)\n",
+    "print(top_keywords)\n",
+    "print(f\"Başlıklar: {titles}\")\n",
+    "print(f\"Başlık sayısı: {title_count}\")\n",
+    "print(f\"Metinler: {texts}\")\n",
+    "print(f\"Metin sayısı: {len(texts)}\")\n",
+    "print(f\"Birleştirilmiş Belgeler: {documents[:5]}\")  # İlk birkaç belgeyi kontrol etme\n",
+    "\n",
+    "def calculate_tfidf(docs):\n",
+    "    vectorizer = TfidfVectorizer(stop_words=turkish_stop_words)\n",
+    "    tfidf_matrix = vectorizer.fit_transform(docs)\n",
+    "    feature_names = vectorizer.get_feature_names_out()\n",
+    "    return tfidf_matrix, feature_names\n",
+    "\n",
+    "# İşlem için dökümanları parçalayarak kullanın\n",
+    "def process_documents_in_batches(docs, batch_size=1000, top_n=5):\n",
+    "    all_keywords = {}\n",
+    "    for start in range(0, len(docs), batch_size):\n",
+    "        end = min(start + batch_size, len(docs))\n",
+    "        batch_docs = docs[start:end]\n",
+    "        tfidf_matrix, feature_names = calculate_tfidf(batch_docs)\n",
+    "        batch_keywords = get_top_n_keywords_sparse(tfidf_matrix, feature_names, n=top_n)\n",
+    "        all_keywords.update(batch_keywords)\n",
+    "    return all_keywords\n",
+    "\n",
+    "#buraya mango db üzerindeki tüm dökümanlar gelmewli \n",
+    "keywords= process_documents_in_batches(documents,batch_size=1000,top_n=5)\n",
+    "\n",
+    "documents = titles + texts  # Başlıklar ve metinleri birleştir\n",
+    "print(f\"en yüksek tf-ıdf skoruna sahip anahtar kelimeler:{keywords}\")\n",
+    "\n",
+    "\n",
+    "# Belgeleri TF-IDF matrisine dönüştürün\n",
+    "\"\"\"tfidf_matrix = vectorizer.fit_transform(documents)\n",
+    "\n",
+    "# Özellik adlarını (kelimeleri) alın\n",
+    "feature_names = vectorizer.get_feature_names_out()\n",
+    "\n",
+    "# TF-IDF sonuçlarını DataFrame'e dönüştürün\n",
+    "df = pd.DataFrame(tfidf_matrix.toarray(), columns=feature_names)\n",
+    "\n",
+    "print(df)\"\"\"\n",
+    "\n",
+    "#text ve title a göre keywords belirlenmesi\n",
+    "\n",
+    "#------------------------------------------------------------------------------\n",
+    "\n",
+    "\n",
+    "#sbert ile alt başlıkların oluşturulması\n",
+    "\n",
+    "#kümelenme ile alt başlıkların belirlenmesi \n",
+    "\n",
+    "#-------------------------------------------------------------------------------\n",
+    "\n",
+    "#anahatar kelime ve alt başlıkların veri tabnaına eklnemesi "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#benzerlik hesaplaması için kullanılacak \n",
+    "from sentence_transformers import SentenceTransformer"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Similarity Sentences "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#prompt oluştururak generate etmek için hazırlık"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Bert Modeliyle tokenizer atama"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tokenizer= BertTokenizer.from_pretrained('bert-base-uncased')\n",
+    "model=BertForMaskedLM.from_pretrained('bert-base-uncased')\n",
+    "\n",
+    "\"\"\"BERT MODELİNİ AYARLAMA\n",
+    "\n",
+    "input_file: Modelin işlem yapacağı giriş dosyasının yolunu belirtir. Bu dosya, metin verilerini içermelidir.\n",
+    "-----------------------------------------------------------------------------------------------------------------\n",
+    "output_file: Modelin çıktılarının kaydedileceği dosyanın yolunu belirtir.\n",
+    "------------------------------------------------------------------------------------------------------------------\n",
+    "layers: Hangi BERT katmanlarının kullanılacağını belirler. Örneğin, \"-1,-2,-3,-4\" son dört katmanı ifade eder.\n",
+    "----------------------------------------------------------------------------------------------------------------------\n",
+    "bert_config_file: Önceden eğitilmiş BERT modelinin yapılandırma dosyasının yolu. Bu dosya modelin mimarisini belirler.\n",
+    "--------------------------------------------------------------------------------------------------------------------------\n",
+    "max_seq_length: Giriş sekanslarının maksimum uzunluğu. Sekanslar bu uzunluktan uzunsa kesilir, kısa ise sıfır ile doldurulur.\n",
+    "--------------------------------------------------------------------------------------------------------------------------------\n",
+    "init_checkpoint: Başlangıç ağırlıkları. Genellikle önceden eğitilmiş bir BERT modelinin ağırlıkları buradan yüklenir.\n",
+    "----------------------------------------------------------------------------------------------------------------------------\n",
+    "vocab_file: BERT modelinin eğitildiği kelime dağarcığının (vocabulary) dosya yolu. Modelin kelime parçacıklarını tanıması için gereklidir.\n",
+    "--------------------------------------------------------------------------------------------------------------------------------------------------\n",
+    "do_lower_case: Giriş metinlerinin küçük harfe mi dönüştürüleceğini belirler. Küçük harfli model için True, büyük harfli model için False olmalıdır.\n",
+    "-----------------------------------------------------------------------------------------------------------------------------------------------------------\n",
+    "batch_size: Tahminler sırasında kullanılacak veri kümesi boyutu.\n",
+    "--------------------------------------------------------------------------------------------------------------------------------------\n",
+    "use_tpu: TPU (Tensor Processing Unit) kullanılıp kullanılmayacağını belirler. True ise TPU, False ise GPU/CPU kullanılır.\n",
+    "--------------------------------------------------------------------------------------------------------------------------------\n",
+    "master: TPU kullanılıyorsa, TPU'nun ana makinesinin adresi.\n",
+    "---------------------------------------------------------------------------------------------------------------------------------------\n",
+    "num_tpu_cores: TPU kullanılacaksa, toplam TPU çekirdek sayısını belirtir.\n",
+    "-----------------------------------------------------------------------------------------------------------------------------------------\n",
+    "use_one_hot_embeddings: TPUs'da genellikle True olarak ayarlanır çünkü bu, tf.one_hot fonksiyonunu kullanarak embedding lookup işlemlerini hızlandırır. GPU/CPU kullanılıyorsa False tercih edilir.\"\"\"\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "t5 Modeli"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from transformers import pipeline\n",
+    "from dotenv import load_dotenv\n",
+    "import os \n",
+    "# Load model directly\n",
+    "from transformers import AutoTokenizer, AutoModelForSeq2SeqLM\n",
+    "\n",
+    "\n",
+    "#tokenizer ve modelin yüklenmesi\n",
+    "tokenizer = AutoTokenizer.from_pretrained(\"google/flan-t5-small\")\n",
+    "model = AutoModelForSeq2SeqLM.from_pretrained(\"google/flan-t5-small\")\n",
+    "prompt = \"Write an article about Machine Learning in Healthcare focusing on Introduction to ML and Applications in Healthcare.\"\n",
+    "#api anahtarını çevresel değişken al\n",
+    "api_key= os.getenv('HUGGINGFACE_API_KEY')\n",
+    "#env dosyasını yükleme\n",
+    "load_dotenv()\n",
+    "\n",
+    "#---------------------------------------------------------------------------------\n",
+    "if api_key is None:\n",
+    "    raise ValueError(\"Apı anahtarı .env dosyasında bulunamadı\")\n",
+    "\n",
+    "# Başlıkları oluştur\n",
+    "headers = {\"Authorization\": f\"Bearer {api_key}\"}\n",
+    "\n",
+    "inputs=tokenizer(prompt, return_tensors=\"pt\")\n",
+    "input_sequence = \"[CLS] Machine Learning in Healthcare [SEP] Introduction to ML [SEP] Applications in Healthcare [SEP] machine learning, healthcare, AI [SEP]\"\n",
+    "#deneme data parçası\n",
+    "data = {\n",
+    "    \"title\": \"Machine Learning in Healthcare\",\n",
+    "    \"sub_headings\": [\"Introduction to ML\", \"Applications in Healthcare\"],\n",
+    "    \"keywords\": [\"machine learning\", \"healthcare\", \"AI\"]\n",
+    "}\n",
+    "\n",
+    "# Girdiyi oluşturma\n",
+    "prompt = (\n",
+    "    f\"Title: {data['title']}\\n\"\n",
+    "    f\"Sub-headings: {', '.join(data['sub_headings'])}\\n\"\n",
+    "    f\"Keywords: {', '.join(data['keywords'])}\\n\"\n",
+    "    f\"Content: {input_sequence}\\n\"\n",
+    "    \"Please generate a detailed article based on the above information.\"\n",
+    ")\n",
+    "\n",
+    "#metin üretimi \n",
+    "output_sequences = model.generate(\n",
+    "    inputs['input_ids'],\n",
+    "    max_length=300,  # Üretilecek metnin maksimum uzunluğu\n",
+    "    min_length=150,  # Üretilecek metnin minimum uzunluğu\n",
+    "    num_return_sequences=1,  # Döndürülecek metin sayısı\n",
+    "    do_sample=True,  # Örneklemeye izin ver\n",
+    "    top_k=50,  # Top-k sampling kullan\n",
+    "    top_p=0.95,  # Top-p sampling kullan\n",
+    "    repetition_penalty=1.2,  # Anlamsız tekrarları önlemek için ceza\n",
+    "    eos_token_id=tokenizer.eos_token_id  # Tam cümlelerin oluşturulmasını sağla\n",
+    ")\n",
+    "\n",
+    "\n",
+    "# Üretilen metni token'lardan çözüp string'e çevir\n",
+    "generated_text = tokenizer.decode(output_sequences[0], skip_special_tokens=True)\n",
+    "\n",
+    "print(generated_text)\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "base",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}