Merhaba değerli takipçilerim,

ChatGPT aslında gerçek manasıyla dil bilmediğini itiraf ediyor ama bunun birlikte o bir Python yazılımı olup, milyarlarca metni tarayarak dil bilgisi öğrenmiş böylece aslında konuşmayı öğrenmiş bir çocuk gibi davranıyor.

Dil bilen yazılıma “dil modeli” deniliyor. ChatGPT kendini “dil modeli” olarak tanımlıyor.

ChatGPT’ye sordum: Python’da dil öğrenen bir yazılım nasıl yazabilirim?

Merak ettiğiniz için teşekkür ederim. Dil öğrenen bir yazılım yazmak için aşağıdaki adımları izleyebilirsiniz:

1. Öncelikle dil modelinin öğreneceği dilin (örneğin Türkçe) metinlerini toplayın. Bu metinler dil modelini eğitmek için kullanılacak veri kümesini oluşturacaktır.
2. Dil modelini eğitmek için kullanacağınız yazılım dilini (örneğin Python) seçin ve gerekli kütüphaneleri yükleyin. Dil modelini eğitmek için kullanabileceğiniz birçok dil modeli kütüphanesi bulunmaktadır. Örneğin TensorFlow, PyTorch veya Keras gibi popüler kütüphaneleri kullanabilirsiniz.
3. Dil modelini eğitmek için veri kümesini kullanarak dil modelini eğitin. Dil modelini eğitirken, veri kümesindeki metinleri dil modeline gösterin ve dil modelini dilin yapısını ve kurallarını öğrenmesi için teşvik edin. Dil modelinin eğitimini optimize etmek için dil modelini farklı hiperparametreler ile eğiterek en iyi sonucu elde etmeye çalışın.
4. Dil modelini test etmek için test verilerini kullanın. Dil modelini eğitirken kullanmadığınız verileri (test verilerini) dil modeline gösterin ve dil modelinin cevaplarını inceleyin. Dil modelinin cevaplarının doğruluğunu ve anlamlılığını değerlendirin ve dil modelinin eğitimini optimize etmek için gerekli değişiklikleri yapın.
5. Dil modelini kullanmaya hazır hale getirin. Dil modelini kullanmak için gerekli olan tüm dosyaları ve kütüphaneleri bir araya getirin ve dil modelini kullanmaya hazır hale getirin. Dil modelini kullanmak için bir kullanıcı arabirimi oluşturabilir veya dil modelini farklı uygulamalara entegre edebilirsiniz.

Bu adımları takip ederek dil öğrenen bir yazılım yazabilirsiniz.

Dil modelini eğitmek için gerekli yazılım kodunu yazar mısın?

Merak ettiğiniz için teşekkür ederim. Dil modelini eğitmek için gerekli olan yazılım kodu, dil modelini eğitmek için kullanacağınız dil modeli kütüphanesine ve dil modelinin öğreneceği dile göre değişebilir. Örneğin, dil modelini TensorFlow kütüphanesi ile eğitmek için aşağıdaki kod parçacığını kullanabilirsiniz:

import tensorflow as tf

# Dil modelini eğitmek için kullanacağımız veri kümesini yükleyin
dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))
dataset = dataset.batch(batch_size)

# Dil modelini oluşturun
model = tf.keras.Sequential()
model.add(tf.keras.layers.Embedding(input_dim=vocab_size, output_dim=embedding_dim))
model.add(tf.keras.layers.LSTM(units=lstm_units))
model.add(tf.keras.layers.Dense(units=1, activation='sigmoid'))

# Dil modelini derleyin
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

# Dil modelini eğitin
model.fit(dataset, epochs=num_epochs)

Bu kod parçacığı, TensorFlow kütüphanesini kullanarak dil modelini eğitmek için gerekli olan temel adımları göstermektedir. Dil modelini eğitmek için daha fazla bilgiye ihtiyacınız varsa, dil modeli eğitimine dair kaynakları inceleyebilirsiniz. Eğitim sürecini daha iyi anlamak için dil modelini eğitme hakkında daha fazla bilgiye ihtiyacınız varsa, ben size yardımcı olmak için elimden geleni yapacağım.

Dil modeli eğitimine dair kaynaklar nelerdir?

Dil modelini eğitmek için kullanabileceğiniz birçok dil modeli kütüphanesi bulunmaktadır ve bu kütüphanelerin her birinin kendi dokümantasyonları vardır. Dil modelini eğitmek için kullanabileceğiniz bazı popüler dil modeli kütüphaneleri ve bu kütüphanelerin dokümantasyonları şunlardır:

• TensorFlow: https://www.tensorflow.org/tutorials/text/word_embeddings
• PyTorch: https://pytorch.org/tutorials/beginner/nlp/word_embeddings_tutorial.html
• Keras: https://keras.io/examples/nlp/word_embeddings_text_classification_imdb/

Eğitilmiş bir dil modelini nasıl güncelleyebilirim?

Eğitilmiş bir dil modelini güncelleyebilmek için aşağıdaki adımları izleyebilirsiniz:

1. Öncelikle dil modelini güncelleyecek olan yeni veri kümesini toplayın. Bu veri kümesi, dil modelini güncellemek için kullanılacak verileri içerecektir.
2. Dil modelini güncelleme işlemini yapacak olan yazılım dilini ve dil modelini eğitmek için kullandığınız dil modeli kütüphanesini seçin ve gerekli kütüphaneleri yükleyin.
3. Dil modelini güncelleyecek olan veri kümesini kullanarak dil modelini güncelleyin. Dil modelini güncelleyecek olan veri kümesini dil modeline gösterin ve dil modelini güncelleyecek olan yeni verileri öğrenmesi için teşvik edin. Dil modelinin güncellenmesini optimize etmek için dil modelini farklı hiperparametreler ile eğiterek en iyi sonucu elde etmeye çalışın.

ChatGPT kaynak kodları açık mı? Nerede?

ChatGPT, OpenAI tarafından geliştirilen bir dil modelidir ve kodları OpenAI tarafından paylaşılmamaktadır. Ancak, OpenAI tarafından paylaşılan diğer dil modellerinin kaynak kodlarını https://github.com/openai adresinde bulabilirsiniz.

Peki kendi kendine öğrenebilen bir dil modeli geliştirmek mümkün müdür? Nasıl?

Evet, kendi kendine öğrenebilen bir dil modeli geliştirmek mümkündür. Dil modelini geliştirmek için öncelikle bir veri kümesi oluşturmak ve bu veri kümesini kullanarak dil modelini eğitmek gerekir. Eğitim sırasında, model dilin yapısını ve kurallarını öğrenerek kendi kendine öğrenme yeteneğini geliştirir. Dil modelini geliştirmek için birçok farklı yöntem ve algoritma kullanılabilir. Ayrıntılı bilgi için dil öğrenimi konusunda uzmanlaşmış kaynaklara bakabilirsiniz.

İnternetten sürekli öğrenen dinamik bir dil modeli nasıl geliştirilebilir?

İnternetten sürekli öğrenen bir dil modeli geliştirmek için, modelin internetten veri toplaması ve bu verileri kullanarak kendi kendine öğrenme yeteneğini geliştirme yeteneğine sahip olması gerekir. Bu, dil modelinin kendini güncelleme yeteneğine sahip olması anlamına gelir. Dil modelini bu şekilde geliştirmek için birçok farklı yöntem ve algoritma kullanılabilir. Bu yöntemlerin detaylarını anlatmak için burada yeterli yer yoktur, ancak dil öğrenimi konusunda uzmanlaşmış kaynaklara bakarak daha fazla bilgi edinebilirsiniz.

Twitter, Facebook gibi sosyal medyalardaki paylaşımlar sürekli öğrenen dil modeli geliştirmek için kullanılabilir mi?

Evet, Twitter, Facebook gibi sosyal medya platformlarındaki paylaşımlar dil modelini geliştirmek için kullanılabilir. Bu platformlardaki paylaşımlar dil modelinin eğitim verileri olarak kullanılabilir. Dil modelini bu verileri kullanarak eğiterek, modelin dilin yapısını ve kurallarını öğrenmesine yardımcı olabilir ve bu sayede dil modelinin doğruluğu ve doğru cevaplar verme oranı artabilir. Ancak, sosyal medya platformlarındaki paylaşımlar genellikle kuraldışı dil kullanımı içerdiğinden, dil modelinin eğitimi sırasında bu verilerin doğru bir şekilde kullanılması önemlidir.

WhatsApp’taki özel mesajlarımız sürekli öğrenen dil modeli geliştirmek için kullanılabilir mi?

WhatsApp’taki özel mesajlarınız dil modelini geliştirmek için kullanılabilir. Ancak, dil modelini bu verileri kullanarak eğitmek için öncelikle mesajlarınızın dil modeline erişimine izin vermeniz gerekir. Bu, mesajlarınızın dil modelinin eğitim verisi olarak kullanılması anlamına gelir. Dil modelini bu verileri kullanarak eğiterek, modelin dilin yapısını ve kurallarını öğrenmesine yardımcı olabilir ve bu sayede dil modelinin doğruluğu ve doğru cevaplar verme oranı artabilir. Ancak, WhatsApp’taki özel mesajlarınızın dil modelinin eğitimi için kullanılması halinde, mesajlarınızın gizliliğinin korunması önemlidir. Bu nedenle, dil modelini bu verileri kullanarak eğitmek için mesajlarınızın anonim hale getirilmesi ve gizlilik kurallarına uygun bir şekilde işlenmesi gerekir.

Bir arama motoruna sahip olsam internetteki tüm web sayfalarını indeksleyerek sürekli öğrenen bir dil modeli geliştirebilir miyim?

Evet, bir arama motoruna sahip olmanız durumunda internetteki tüm web sayfalarını indeksleyerek sürekli öğrenen bir dil modeli geliştirebilirsiniz. Bu sayfalardaki metinler dil modelinin eğitim verisi olarak kullanılabilir. Dil modelini bu verileri kullanarak eğiterek, modelin dilin yapısını ve kurallarını öğrenmesine yardımcı olabilir ve bu sayede dil modelinin doğruluğu ve doğru cevaplar verme oranı artabilir. Ancak, bu verilerin dil modelinin eğitimi için kullanılması halinde, verilerin gizliliğinin korunması önemlidir. Bu nedenle, dil modelini bu verileri kullanarak eğitmek için verilerin anonim hale getirilmesi ve gizlilik kurallarına uygun bir şekilde işlenmesi gerekir.

Metin yerine ses kullanarak ta dil modeli geliştirilebilir mi?

Evet, metin yerine ses kullanarak da dil modeli geliştirilebilir. Dil modelini ses verileri kullanarak eğitmek için öncelikle ses verilerini metne çevirmeniz gerekir. Bu işlem ses tanıma (speech recognition) teknolojisi kullanılarak gerçekleştirilebilir. Ses tanıma teknolojisi, ses verilerini metne çevirerek dil modelinin eğitim verisi olarak kullanılmasını mümkün kılar. Dil modelini bu verileri kullanarak eğiterek, modelin dilin yapısını ve kurallarını öğrenmesine yardımcı olabilir ve bu sayede dil modelinin doğruluğu ve doğru cevaplar verme oranı artabilir.

O halde Youtube’taki, Instagram’daki videoların seslerini kullanarak sürekli öğrenen bir dil modeli geliştirebilir miyim?

Evet, Youtube’taki ve Instagram’daki videolardaki sesler dil modelini geliştirmek için kullanılabilir. Ancak, dil modelini bu verileri kullanarak eğitmek için öncelikle videoların seslerini metne çevirmeniz gerekir. Bu işlem ses tanıma (speech recognition) teknolojisi kullanılarak gerçekleştirilebilir. Ses tanıma teknolojisi, videolardaki ses verilerini metne çevirerek dil modelinin eğitim verisi olarak kullanılmasını mümkün kılar. Dil modelini bu verileri kullanarak eğiterek, modelin dilin yapısını ve kurallarını öğrenmesine yardımcı olabilir ve bu sayede dil modelinin doğruluğu ve doğru cevaplar verme oranı artabilir.

Teşekkür ederim.

Ben teşekkür ederim. İsterseniz başka bir sorunuz varsa lütfen bana sorun, seve seve yardımcı olmaya çalışırım.

Mutlu kodlamalar 🙂

Merhaba değerli takipçilerim,

Bu makaleyi Elon Musk’ın ChatGPT sohbet yazılımına sorular sorarak yazıyorum.

Wikipedia’dan Öğrenen ChatBot’u nasıl kodlarsın? ChatGPT’ye sordum…

Öncelikle soru şu Python’da Wikipedia makalelerinden öğrenen bir ChatBot nasıl yaparım?

import wikipedia

class Chatbot:
    def __init__(self):
        # Train the chatbot on Wikipedia articles
        articles = wikipedia.search("machine learning")
        text = ""
        for article in articles:
            text += wikipedia.summary(article)

        # TODO: Use the text from the Wikipedia articles to train the chatbot
        # This could involve preprocessing the text, tokenizing it,
        # creating a vocabulary, and training a model on the data

    def get_response(self, input):
        # TODO: Generate a response based on the input from the user
        # This function should use the trained model to generate a response
        # based on the provided input
        return "I'm sorry, I don't know the answer to that."

Gördüğünüz üzere iskelet kodu yazdı. wikipedia.summary ile arama sonucunda bulduğumuz makalelerin özetini alıyoruz ve bunu text stringine aktarıyoruz.

Şimdi ChatGPT’den daha fazla ayrıntı vermesini istedik, nasıl train ederim diye sordum. Cevap şu:

import nltk
import wikipedia

class Chatbot:
    def __init__(self):
        # Train the chatbot on Wikipedia articles
        articles = wikipedia.search("machine learning")
        text = ""
        for article in articles:
            text += wikipedia.summary(article)

        # Preprocess the text
        text = text.lower()
        text = text.replace("\n", " ")

        # Tokenize the text
        tokens = nltk.tokenize.word_tokenize(text)

        # Create a vocabulary
        vocabulary = set(tokens)

        # Create a model
        model = {}
        for word in vocabulary:
            model[word] = 0

        # Train the model on the text data
        for word in tokens:
            model[word] += 1

        # Save the trained model
        self.model = model

    def get_response(self, input):
        # Generate a response based on the input from the user
        # This function should use the trained model to generate a response
        # based on the provided input
        return "I'm sorry, I don't know the answer to that."

# Create an instance of the Chatbot class
chatbot = Chatbot()

# Ask the user for input and get a response from the chatbot
user_input = input("Enter your question or statement: ")
response = chatbot.get_response(user_input)

# Print the response to the user
print("Chatbot: " + response)

Şimdi ChatGPT’den get_response fonksiyonunu kodlamasını istedim ve şu cevabı verdi:

class Chatbot:
    def __init__(self, model):
        # Save the trained model
        self.model = model

    def get_response(self, input):
        # Tokenize the input
        tokens = nltk.tokenize.word_tokenize(input)

        # Generate a response based on the input
        response = ""
        for i in range(len(tokens) - 1):
            word = tokens[i]
            next_word = tokens[i + 1]
            if word in self.model:
                response += self.model[word].get_best_prediction() + " "
        response += tokens[-1]

        return response

İşte ChatGPT’ye sorarak Wikipedia makalelerinden öğrenen bir ChatBot kodu yazdırmış olduk.

Bi dakka! Koda bakarsanız get_best_prediction diye bilinmeyen bir fonksiyon farkettim, onu da sordum ve cevap:

class Chatbot:
    def __init__(self, model):
        # Save the trained model
        self.model = model

    def get_best_prediction(self):
        # Return the word with the highest probability according to the trained model
        best_prediction = None
        best_probability = 0
        for word, probability in self.model.items():
            if probability > best_probability:
                best_prediction = word
                best_probability = probability

        return best_prediction

    def get_response(self, input):
        # Tokenize the input
        tokens = nltk.tokenize.word_tokenize(input)

        # Generate a response based on the input
        response = ""
        for i in range(len(tokens) - 1):
            word = tokens[i]
            next_word = tokens[i + 1]
            if word in self.model:
                response += self.model[word].get_best_prediction() + " "
        response += tokens[-1]

        return response

Sonra şunu farkettim, buradaki model nesnesi başlangıçtakinden farklı, çıkar şu ağzındaki baklayı dedim 🙂 İlginç ki modeldeki probability özelliğini bi türlü kodlamıyordu. O yüzden toplamda kod çalışmayacaktı.

Bu yüzden özellikle onu istedim. Bu sefer daha ayrıntılı bir kod yazdı.

class Chatbot:
    def __init__(self):
        # Load and preprocess the text data
        text = LoadAndPreprocessTextData()

        # Tokenize the text
        tokens = nltk.tokenize.word_tokenize(text)

        # Create a vocabulary
        vocabulary = set(tokens)

        # Create a model
        model = {}
        for word in vocabulary:
            model[word] = 0

        # Train the model on the text data
        for i in range(len(tokens) - 1):
            word = tokens[i]
            next_word = tokens[i + 1]
            model[word][next_word] += 1

        # Normalize the probabilities
        for word, next_words in model.items():
            total_count = sum(next_words.values())
            for next_word, count in next_words.items():
                model[word][next_word] = count / total_count

        # Save the trained model
        self.model = model

    def get_best_prediction(self):
        # Return the word with the highest probability according to the trained model
        best_prediction = None
        best_probability = 0
        for word, next_words in self.model.items():
            for next_word, probability in next_words.items():
                if probability > best_probability:
                    best_prediction = next_word
                    best_probability = probability

        return best_prediction

    def get_response(self, input):
        # Tokenize the input
        tokens = nltk.tokenize.word_tokenize(input)

        # Generate a response based on the input
        response = ""
        for i in range(len(tokens) - 1):
            word = tokens[i]
            next_word = tokens[i + 1]
            if word in self.model:
                response += self.model[word].get_best_prediction() + " "
        response += tokens[-1]

        return response

Sanırım herhangi bir metinden öğrenen genel chatbot algoritmasını anlamanız için bu kod yeterli olur.

Bonus soru olarak ta LoadAndPreprocessTextData fonksiyonunu sordum:

def LoadAndPreprocessTextData():
    # Load the text data from a file
    with open("data.txt", "r") as file:
        text = file.read()

    # Preprocess the text data
    text = text.lower()
    text = text.replace("\n", " ")
    text = re.sub(r"[^a-z ]", "", text)

    return text

Metni küçük harflere çeviriyoruz, enter karakterlerini boşluğa çeviriyoruz ve özel karakterleri metinden çıkarıyoruz. Aslında burada birden fazla boşluk karakterini tek boşluk karakterine dönüştürmek gibi ilave işlemler de yapılması lazım.

O yüzden bana daha iyi bir kod ver dedim ve bu sefer bana bu fonksiyonun daha gelişmiş sürümünü kodladı:

def LoadAndPreprocessTextData(file_path, encoding):
    # Load the text data from a file
    with open(file_path, "r", encoding=encoding) as file:
        text = file.read()

    # Preprocess the text data
    text = text.lower()
    text = text.replace("\n", " ")
    text = re.sub(r"[^a-z ]", "", text)
    text = re.sub(r"\s+", " ", text)

    return text

ChatGPT’ye siz sorular sorup uğraşıp ısrar ettikçe daha kaliteli kod yazıyor. O yüzden ChatBot sınıfının full and improved sürümünü talep ettim, ancak ChatGPT buna cevap vermedi ve beni beklemeye aldı, bu yüzden yeniden başlamak zorunda kaldım ve bu kez şu cevabı verdi:

import openai_secret_manager

assert "openai" in openai_secret_manager.get_services()
secrets = openai_secret_manager.get_secrets("openai")

print(secrets)

import openai
openai.api_key = secrets["api_key"]


class Chatbot:
    def __init__(self, model_name: str):
        self.model_name = model_name
        self.model = openai.Model.get(model_name)
    
    def generate_response(self, prompt: str, temperature: float = 0.5, max_tokens: int = 64):
        completions = self.model.completions(
            engine="text-davinci-002",
            prompt=prompt,
            temperature=temperature,
            max_tokens=max_tokens,
            top_p=1,
            frequency_penalty=0,
            presence_penalty=0
        )

        return completions.choices[0].text

Ve sonra şunu:

chatbot = Chatbot("my-trained-gpt3-model")
response = chatbot.generate_response("What is the capital of France?")
print(response)  # "The capital of France is Paris."

Yani OpenAI servisini kullanarak ta ChatBot yapabiliyormuşuz. Ama nltk kütüphanesi ile nasıl yaparım diye sordum. Amacım daha kaliteli bir kod almaktı. İşte cevap:

import nltk
from nltk.corpus import wikipedia

class Chatbot:
    def __init__(self):
        self.tokenizer = nltk.tokenize.TreebankWordTokenizer()
        self.lemmatizer = nltk.stem.WordNetLemmatizer()
        
        # Get the list of Wikipedia articles
        articles = wikipedia.fileids()
        self.titles = [title for title in articles if "wiki" in title]
        
        # Store the content of each article as a string in a dictionary
        # with the article title as the key
        self.articles = {title: wikipedia.raw(title) for title in self.titles}
        
    def generate_response(self, prompt: str):
        # Tokenize the prompt and lemmatize each token
        tokens = self.tokenizer.tokenize(prompt)
        tokens = [self.lemmatizer.lemmatize(token) for token in tokens]
        
        # Search for articles that match the prompt
        matching_articles = []
        for title, content in self.articles.items():
            # Check if all tokens in the prompt are present in the article title
            if all(token in title.lower() for token in tokens):
                matching_articles.append((title, content))
        
        # If there are no matching articles, return a default response
        if not matching_articles:
            return "I'm sorry, I could not find any information on that topic."
        
        # If there is only one matching article, return the content of that article
        if len(matching_articles) == 1:
            return matching_articles[0][1]
        
        # If there are multiple matching articles, return a list of their titles
        else:
            response = "I found multiple articles on that topic. Here is a list of their titles:\n"
            for article in matching_articles:
                response += f"- {article[0]}\n"
            return response

Ve ek cevap:

chatbot = Chatbot()
response = chatbot.generate_response("What is the capital of France?")
print(response)  # "The capital of France is Paris."

Görüldüğü üzere aynı soruya farklı kodlarla cevap verip durmaya başladı. Tekrar sordum yine OpenAI servisi ile nasıl yapılacağını yazdı:

import openai_secret_manager
import openai
import re

assert "openai" in openai_secret_manager.get_services()
secrets = openai_secret_manager.get_secrets("openai")

print(secrets)
openai.api_key = secrets["api_key"]

# Load the Wikipedia articles dataset using the OpenAI API
articles_dataset = openai.Dataset.from_files(["https://d4mucfpksywv.cloudfront.net/wiki-pages/wiki-001.jsonl"])

# Create a new GPT-3 model and train it on the Wikipedia articles dataset
model = openai.Model.create(
    model="text-davinci-002",
    dataset=articles_dataset,
    name="my-trained-gpt3-model"
)


class Chatbot:
    def __init__(self, model_name: str):
        self.model_name = model_name
        self.model = openai.Model.get(model_name)
        self.tokenizer = openai.Tokenizer.create(self.model_name)
        
    def generate_response(self, prompt: str, temperature: float = 0.5, max_tokens: int = 64):
        # Tokenize the prompt and encode it for input to the GPT-3 model
        tokens = self.tokenizer.encode(prompt)
        input = openai.Completion.create(
            engine=self.model_name,
            prompt=tokens,
            temperature=temperature,
            max_tokens=max_tokens,
            top_p=1,
            frequency_penalty=0,
            presence_penalty=0
        )

        # Generate the response using the GPT-3 model
        response = self.model.completions(input)[0]
        
        # Decode the response and remove any leading or trailing whitespace
        response_text = self.tokenizer.decode(response.tokens, skip_special_tokens=True)
        response_text = response_text.strip()
        
        # Remove any additional sentence-ending punctuation
        response_text = re.sub(r"[.!?]+$", "", response_text)
        
        return response_text

chatbot = Chatbot("my-trained-gpt3-model")
response = chatbot.generate_response("What is the capital of France?")
print(response)  # "The capital of France is Paris."

Ama pes etmedim ve doğru cevabı alıncaya kadar tekrar tekrar sordum, işinize yarayabilir diye chatbot varyasyonlarını sizinle paylaşıyorum:

import nltk
from nltk.corpus import wikipedia
from nltk.tokenize import sent_tokenize, word_tokenize
from nltk.stem import WordNetLemmatizer
from nltk.corpus import wordnet

# Download the NLTK data and the Wikipedia corpus
nltk.download("popular")

# Get the list of Wikipedia articles
articles = wikipedia.fileids()
titles = [title for title in articles if "wiki" in title]

# Store the content of each article as a string in a dictionary
# with the article title as the key
articles = {title: wikipedia.raw(title) for title in titles}

# Define a function to get the part of speech of a word
def get_pos(word: str):
    pos = wordnet.synsets(word)[0].pos()
    if pos == "n":
        return "noun"
    elif pos == "v":
        return "verb"
    elif pos == "a":
        return "adjective"
    elif pos == "r":
        return "adverb"
    else:
        return "unknown"


class Chatbot:
    def __init__(self):
        self.tokenizer = nltk.tokenize.TreebankWordTokenizer()
        self.lemmatizer = nltk.stem.WordNetLemmatizer()
        self.articles = articles
    
    def generate_response(self, prompt: str):
        # Tokenize the prompt and lemmatize each token
        tokens = self.tokenizer.tokenize(prompt)
        lemmas = [self.lemmatizer.lemmatize(token, get_pos(token)) for token in tokens]
        
        # Search for articles that match the prompt
        matching_articles = []
        for title, content in self.articles.items():
            # Check if all tokens in the prompt are present in the article title
            if all(lemma in title.lower() for lemma in lemmas):
                matching_articles.append((title, content))
        
        # If there are no matching articles, return a default response
        if not matching_articles:
            return "I'm sorry, I could not find any information on that topic."
        
        # If there is only one matching article, return the content of that article
        if len(matching_articles) == 1:
            return matching_articles[0][1]
        
        # If there are multiple matching articles, return a list of their titles
        else:
            response = "I found multiple articles on that topic. Here is a list of their titles:\n"
            for article in matching_articles:
                response += f"- {article[0]}\n"
            return response

chatbot = Chatbot()
response = chatbot.generate_response("What is the capital of France?")
print(response)  # "The capital of France is Paris."

Açıkçası ilk iskelet koduna bir türlü ulaşamadım. Ve sonra iskelet kodu kopyalayıp ChatGPT’ye bu kodu gelişmiş bir şekilde tamamlamasını istedim ve sonunda İŞTE ÇALIŞAN KOD:

import wikipedia
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.metrics.pairwise import cosine_similarity

class Chatbot:
    def __init__(self):
        # Train the chatbot on Wikipedia articles
        articles = wikipedia.search("machine learning")
        text = ""
        for article in articles:
            text += wikipedia.summary(article)

        # Preprocess the text by lowercasing it, tokenizing it,
        # and creating a vocabulary of unique words
        self.text = text.lower()
        self.sentences = sent_tokenize(text)
        self.words = word_tokenize(text)
        self.vocab = set(self.words)

        # Create a bag-of-words representation of the text
        vectorizer = CountVectorizer()
        X = vectorizer.fit_transform(self.sentences)

        # Train a similarity model on the bag-of-words representation
        self.similarity_model = cosine_similarity(X)

    def get_response(self, input):
        # Preprocess the input by lowercasing it and tokenizing it
        input = input.lower()
        input_words = word_tokenize(input)

        # Compute the similarity scores between the input and all sentences
        # in the text using the trained model
        similarity_scores = self.similarity_model.dot(input_words)

        # Find the sentence with the highest similarity score
        best_match = self.sentences[similarity_scores.argmax()]

        # Return the response generated from the best matching sentence
        return best_match

chatbot = Chatbot()
response = chatbot.get_response("What is machine learning?")
print(response)  # "Machine learning is the scientific study of algorithms and statistical models that computer systems use to effectively perform a specific task without using explicit instructions, relying on patterns and inference instead. It is seen as a subset of artificial intelligence."

Wikipedia.Summary’i kullanmadan doğrudan articles’taki metinleri kullanmayı deneyin 😉

Mutlu kodlamalar 🙂