The main objective of this article is to develop an end-to-end machine learning project. For a model to be truly useful, it needs to be stored and distributed. Within the scope of this article, I aim to develop a project based on a real-world scenario.

You can access the project on GitHub. You can also access the EDA and model development section on Kaggle.

• GitHub
• EDA Kaggle
• Model Development Kaggle

The following tools will be used throughout the project.

• Catboost
• Streamlit
• FastAPI
• Docker

Table of Contents
· 1. Aim of the Project and Data Set
∘ Data Set
· 2. Data Preprocessing and Model Development
· 3. Interface (Streamlit)
· 4. API (FastAPI)
· 5. Automation (Docker)
· 6. Conclusion

1. Aim of the Project and Data Set

Data Set

You can access the customer data to be used in the project from Kaggle. This dataset consists of 7043 customers with 21 columns (features). It contains customer account information, demographic information, and registered services. The target variable (Churn) provides information on whether the customer has churned.
You can also access the extended and updated dataset version from this link.

2. Data Preprocessing and Model Development

There are quite a lot of categorical variables in the dataset. By encoding these variables into numerical form, we can also use different models with different preprocessing techniques. But in this study, we will use the Catboost algorithm, which has proven its success with categorical variables. If you want to improve performance in model development, you can try various tools that provide hyperparameter optimization such as Optuna, etc.

We can start data preprocessing and model development by creating a Python file called train_model.py

################################################## Import Libraries ##################################################

import numpy as np
import pandas as pd
import os

from sklearn import metrics
from sklearn.model_selection import train_test_split, StratifiedShuffleSplit
from sklearn.metrics import (
    accuracy_score, classification_report, recall_score, confusion_matrix,
    roc_auc_score, precision_score, f1_score, roc_curve, auc
)
from sklearn.preprocessing import OrdinalEncoder

from catboost import CatBoostClassifier, Pool

################################################## Data Loading and Editing ##################################################

data_path = "../data/WA_Fn-UseC_-Telco-Customer-Churn.csv"
df = pd.read_csv(data_path)

# Convert TotalCharges to numeric, filling NaN values
df['TotalCharges'] = pd.to_numeric(df['TotalCharges'], errors='coerce')
df['TotalCharges'].fillna(df['tenure'] * df['MonthlyCharges'], inplace=True)

# Convert SeniorCitizen to object
df['SeniorCitizen'] = df['SeniorCitizen'].astype(object)

# Replace 'No phone service' and 'No internet service' with 'No' for certain columns
df['MultipleLines'] = df['MultipleLines'].replace('No phone service', 'No')
columns_to_replace = ['OnlineSecurity', 'OnlineBackup', 'DeviceProtection', 'TechSupport', 'StreamingTV', 'StreamingMovies']
for column in columns_to_replace:
    df[column] = df[column].replace('No internet service', 'No')

# Convert 'Churn' categorical variable to numeric
df['Churn'] = df['Churn'].replace({'No': 0, 'Yes': 1})

################################################## StratifiedShuffleSplit ##################################################

# Create the StratifiedShuffleSplit object
strat_split = StratifiedShuffleSplit(n_splits=1, test_size=0.2, random_state=64)

train_index, test_index = next(strat_split.split(df, df["Churn"]))

# Create train and test sets
strat_train_set = df.loc[train_index]
strat_test_set = df.loc[test_index]

X_train = strat_train_set.drop("Churn", axis=1)
y_train = strat_train_set["Churn"].copy()

X_test = strat_test_set.drop("Churn", axis=1)
y_test = strat_test_set["Churn"].copy()

################################################## CATBOOST ##################################################

# Identify categorical columns
categorical_columns = df.select_dtypes(include=['object']).columns.tolist()

# Initialize and fit CatBoostClassifier
cat_model = CatBoostClassifier(verbose=False, random_state=0, scale_pos_weight=3)
cat_model.fit(X_train, y_train, cat_features=categorical_columns, eval_set=(X_test, y_test))

# Predict on test set
y_pred = cat_model.predict(X_test)

# Calculate evaluation metrics
accuracy, recall, roc_auc, precision = [round(metric(y_test, y_pred), 4) for metric in [accuracy_score, recall_score, roc_auc_score, precision_score]]

# Create a DataFrame to store results
model_names = ['CatBoost_Model']
result = pd.DataFrame({'Accuracy': accuracy, 'Recall': recall, 'Roc_Auc': roc_auc, 'Precision': precision}, index=model_names)

# Print results
print(result)

# Save the model in the 'model' directory
model_dir = "../model"
if not os.path.exists(model_dir):
    os.makedirs(model_dir)

model_path = os.path.join(model_dir, "catboost_model.cbm")
cat_model.save_model(model_path)

Step 1: Importing Libraries
We start by importing essential libraries required for data processing, model training, and evaluation. These include libraries such as NumPy and Pandas for data manipulation, scikit-learn for machine learning functionalities, and CatBoost for building our predictive model.

Step 2: Data Loading and Editing
Next, we load the dataset from a specified path using Pandas. We perform some initial data editing steps to ensure data consistency and readiness for modeling. This involves converting certain columns to numeric data types, handling missing values, and encoding categorical variables.

Step 3: Stratified Splitting
The unbalanced nature of the dataset was observed in the EDA study. To ensure an unbiased distribution of classes in our train-test split, we employ StratifiedShuffleSplit from scikit-learn. This method preserves the proportion of classes in both training and testing sets, critical for reliable model evaluation.

Step 4: Model Training with CatBoost
Training our predictive model using CatBoost. We initialize a CatBoostClassifier with appropriate parameters, including verbosity and random state. We fit the model to the training data, specifying categorical features to ensure proper handling of categorical variables. I would like to emphasize that the model training phase has not been elaborated and it may be good to revisit this phase in your work.

Step 5: Model Evaluation
Once the model is trained, we evaluate its performance using various metrics such as accuracy, recall, ROC AUC score, and precision. These metrics provide insights into how well our model predicts customer churn.

After developing the model with your data, we need to save the model for later use.

After analyzing the data and building the machine learning model, interactive interfaces are required to increase the usability of this model. Streamlit is a good alternative for this task.

3. Interface (Streamlit)

Streamlit is an open-source application framework for machine learning and data science teams. It is often used in the prototyping phase of projects as it provides a fast interface. It is easy to use and has a strong community.

We started our project by creating a python file named streamlit-app.py to create a fast interface. The following code allows us to create an interactive interface using Streamlit and evaluate the churn probability of customers using the CatBoost model. It also allows us to understand and visualize the model’s decisions using SHAP values.

At this point in the project, I think it might be good to briefly mention SHAP.

SHAP (SHapley Additive exPlanations) is one of the explainable artificial intelligence methods developed with a game theoretic approach. It allows us to comment on the model, making it less of a black box. It tells us to what extent each attribute used in the model affects the model outcome.

Let’s continue creating the streamlit-app.py file.

import shap
import pandas as pd
import numpy as np
import streamlit as st
from matplotlib import pyplot as plt
from pyarrow import parquet as pq
from catboost import CatBoostClassifier, Pool
import joblib

# Path of the trained model and data
MODEL_PATH = "../model/cat_model.cbm" 
DATA_PATH = "../data/churn_data_regulated.parquet"

st.set_page_config(page_title="Churn Project")

@st.cache_resource
def load_data():
    data = pd.read_parquet(DATA_PATH)
    return data

def load_x_y(file_path):
    data = joblib.load(file_path)
    data.reset_index(drop=True, inplace=True)
    return data

def load_model():
    model = CatBoostClassifier()
    model.load_model(MODEL_PATH)
    return model

def calculate_shap(model, X_train, X_test):
    # Calculate SHAP values
    explainer = shap.TreeExplainer(model)
    shap_values_cat_train = explainer.shap_values(X_train)
    shap_values_cat_test = explainer.shap_values(X_test)
    return explainer, shap_values_cat_train, shap_values_cat_test

def plot_shap_values(model, explainer, shap_values_cat_train, shap_values_cat_test, customer_id, X_test, X_train):
    # Visualize SHAP values for a specific customer
    customer_index = X_test[X_test['customerID'] == customer_id].index[0]
    fig, ax_2 = plt.subplots(figsize=(6,6), dpi=200)
    shap.decision_plot(explainer.expected_value, shap_values_cat_test[customer_index], X_test[X_test['customerID'] == customer_id], link="logit")
    st.pyplot(fig)
    plt.close()

def display_shap_summary(shap_values_cat_train, X_train):
    # Create the plot summarizing the SHAP values
    shap.summary_plot(shap_values_cat_train, X_train, plot_type="bar", plot_size=(12,12))
    summary_fig, _ = plt.gcf(), plt.gca()
    st.pyplot(summary_fig)
    plt.close()

def display_shap_waterfall_plot(explainer, expected_value, shap_values, feature_names, max_display=20):
    # Create SHAP waterfall drawing
    fig, ax = plt.subplots(figsize=(6, 6), dpi=150)
    shap.plots._waterfall.waterfall_legacy(expected_value, shap_values, feature_names=feature_names, max_display=max_display, show=False)
    st.pyplot(fig)
    plt.close()

def summary(model, data, X_train, X_test):
    # Calculate SHAP values
    explainer, shap_values_cat_train, shap_values_cat_test = calculate_shap(model, X_train, X_test)

    # Summarize and visualize SHAP values
    display_shap_summary(shap_values_cat_train, X_train)

def plot_shap(model, data, customer_id, X_train, X_test):
    # Calculate SHAP values
    explainer, shap_values_cat_train, shap_values_cat_test = calculate_shap(model, X_train, X_test)
    
    # Visualize SHAP values
    plot_shap_values(model, explainer, shap_values_cat_train, shap_values_cat_test, customer_id, X_test, X_train)

    # Waterfall
    customer_index = X_test[X_test['customerID'] == customer_id].index[0]
    display_shap_waterfall_plot(explainer, explainer.expected_value, shap_values_cat_test[customer_index], feature_names=X_test.columns, max_display=20)

st.title("Telco Customer Churn Project")

def main():
    model = load_model()
    data = load_data()

    X_train = load_x_y("../data/X_train.pkl")
    X_test = load_x_y("../data/X_test.pkl")
    y_train = load_x_y("../data/y_train.pkl")
    y_test = load_x_y("../data/y_test.pkl")

    max_tenure = data['tenure'].max()
    max_monthly_charges = data['MonthlyCharges'].max()
    max_total_charges = data['TotalCharges'].max()

    # Radio buttons for options
    election = st.radio("Make Your Choice:", ("Feature Importance", "User-based SHAP", "Calculate the probability of CHURN"))
    available_customer_ids = X_test['customerID'].tolist()
    
    # If User-based SHAP option is selected
    if election == "User-based SHAP":
        # Customer ID text input
        customer_id = st.selectbox("Choose the Customer", available_customer_ids)
        customer_index = X_test[X_test['customerID'] == customer_id].index[0]
        st.write(f'Customer {customer_id}: Actual value for the Customer Churn : {y_test.iloc[customer_index]}')
        y_pred = model.predict(X_test)
        st.write(f"Customer {customer_id}: CatBoost Model's prediction for the Customer Churn : {y_pred[customer_index]}")
        plot_shap(model, data, customer_id, X_train=X_train, X_test=X_test)
    
    # If Feature Importance is selected
    elif election == "Feature Importance":
        summary(model, data, X_train=X_train, X_test=X_test)

    # If Calculate CHURN Probability option is selected
    elif election == "Calculate the probability of CHURN":
        # Retrieving data from the user
        customerID = "6464-UIAEA"
        gender = st.selectbox("Gender:", ("Female", "Male"))
        senior_citizen = st.number_input("SeniorCitizen (0: No, 1: Yes)", min_value=0, max_value=1, step=1)
        partner = st.selectbox("Partner:", ("No", "Yes"))
        dependents = st.selectbox("Dependents:", ("No", "Yes"))
        tenure = st.number_input("Tenure:", min_value=0, max_value=max_tenure, step=1)
        phone_service = st.selectbox("PhoneService:", ("No", "Yes"))
        multiple_lines = st.selectbox("MultipleLines:", ("No", "Yes"))
        internet_service = st.selectbox("InternetService:", ("No", "DSL", "Fiber optic"))
        online_security = st.selectbox("OnlineSecurity:", ("No", "Yes"))
        online_backup = st.selectbox("OnlineBackup:", ("No", "Yes"))
        device_protection = st.selectbox("DeviceProtection:", ("No", "Yes"))
        tech_support = st.selectbox("TechSupport:", ("No", "Yes"))
        streaming_tv = st.selectbox("StreamingTV:", ("No", "Yes"))
        streaming_movies = st.selectbox("StreamingMovies:", ("No", "Yes"))
        contract = st.selectbox("Contract:", ("Month-to-month", "One year", "Two year"))
        paperless_billing = st.selectbox("PaperlessBilling", ("No", "Yes"))
        payment_method = st.selectbox("PaymentMethod:", ("Electronic check", "Mailed check", "Bank transfer (automatic)", "Credit card (automatic)"))
        monthly_charges = st.number_input("Monthly Charges", min_value=0.0, max_value=max_monthly_charges, step=0.01)
        total_charges = st.number_input("Total Charges", min_value=0.0, max_value=max_total_charges, step=0.01)
        
        # Confirmation button
        confirmation_button = st.button("Confirm")

        # When the confirmation button is clicked
        if confirmation_button:
            # Convert user-entered data into a data frame
            new_customer_data = pd.DataFrame({
                "customerID": [customerID],
                "gender": [gender],
                "SeniorCitizen": [senior_citizen],
                "Partner": [partner],
                "Dependents": [dependents],
                "tenure": [tenure],
                "PhoneService": [phone_service],
                "MultipleLines": [multiple_lines],
                "InternetService": [internet_service],
                "OnlineSecurity": [online_security],
                "OnlineBackup": [online_backup],
                "DeviceProtection": [device_protection],
                "TechSupport": [tech_support],
                "StreamingTV": [streaming_tv],
                "StreamingMovies": [streaming_movies],
                "Contract": [contract],
                "PaperlessBilling": [paperless_billing],
                "PaymentMethod": [payment_method],
                "MonthlyCharges": [monthly_charges],
                "TotalCharges": [total_charges]
            })

            # Predict churn probability using the model
            churn_probability = model.predict_proba(new_customer_data)[:, 1]

            # Format churn probability
            formatted_churn_probability = "{:.2%}".format(churn_probability.item())

            big_text = f"<h1>Churn Probability: {formatted_churn_probability}</h1>"
            st.markdown(big_text, unsafe_allow_html=True)
            st.write(new_customer_data.to_dict())

if __name__ == "__main__":
    main()

Step 1: Setting Up
Streamlit app begins by importing necessary libraries, including Streamlit itself, Pandas for data manipulation, CatBoost for loading the trained model, and SHAP for visualizing model explanations.

Step 2: Data Loading and Model Loading
The app loads the preprocessed data and the trained CatBoost model. This ensures that we have the necessary data and model ready for inference.

Step 3: User Interface Components
The app provides a user interface with different options:

• Feature Importance: Allows users to view the summary of feature importance based on SHAP values.
• User-based SHAP: Enables users to select a specific customer and visualize the SHAP values for that customer, helping understand the model’s prediction rationale.
• Calculate the probability of CHURN: Lets users input their data for a hypothetical customer and calculates the probability of churn using the trained model.

Step 4: Loading and Preparing User Data
If the user selects the “Calculate the probability of CHURN” option, the app prompts them to input various customer attributes such as gender, tenure, contract type, etc. Upon confirmation, the app formats this input data into a DataFrame and feeds it into the model to predict the probability of churn for the customer.

Step 5: Displaying Results
Finally, the app presents the results to the user. For the “Calculate the probability of CHURN” option, it displays the churn probability along with the input data in a formatted manner. For other options like “Feature Importance” and “User-based SHAP”, it generates visualizations to help users interpret the model’s behavior.

You can run this code from the terminal in the folder with the file named streamlit-app.py as follows

streamlit run streamlit-app.py

We can see the application interface in the window that opens on localhost in the browser. This interface has different options such as the SHAP summary, SHAP data for a specific user, and the calculation of the churn probability of a customer based on new values entered by the user.

Feature Importance: We may want to take an overview of which features are decisive in the model’s decision-making process.

User-based SHAP: We may want to know the criteria by which a particular customer’s model result was selected. Let’s take a look at the customer in our test set with customerID 6100-QQQQHEB.

It is seen that the customer with customerID 6100-QQQHEB is Churn according to the data set. Also, the model says that this customer will be Churn according to the training set it is trained. But this information is not enough. We may want to see based on which features it says that the customer will be Churn.

The SHAP chart in the photo shows that the customer with ID 6100-QQQQHEB has a Churn probability of over 80%. The model makes this decision because the user’s InternetService feature is Fiber Optic, Contract feature is Month-to-month, and PaymentMethod feature is Electronic check. Other features also confirm this decision but are negligible.

Similar inferences can be seen in another SHAP graph.

Calculate the probability of CHURN: Through the model and streamlit interface we have created, we can ask users to give new customer values and calculate the churn probability in line with these values.

According to the values entered, the churn probability of the new customer created was 71.33%.

Besides an interactive interface, it is vital to quickly and reliably convert the model into an API. API enables the model to be used by a wider audience, integrated with other applications and made easier to use. FastAPI is a good example of all these processes.

4. API (FastAPI)

FastAPI is a Python web framework for developing fast web applications and APIs. It is especially focused on performance, speed, and security, and is very useful for API development thanks to its asynchronous programming support and Python typing support.

Within the scope of the project, uvicorn was used to launch the FastAPI application. Uvicorn is a server application for Python web servers. It provides a fast installation like FastAPI. It is also very easy to use. Alternatives such as Gunicorn, Hypercorn, and Daphne can be used instead of Uvicorn. Which server to use depends on the requirements and performance expectations of the project.

To provide a simple API to the project, we created a Python file named fast-api.py in the project folder. The following code allows to create a fast API using uvicorn and FastAPI.

The API layer is constructed as follows:

import uvicorn
import pandas as pd
from fastapi import FastAPI
from catboost import CatBoostClassifier

# Path to the model
MODEL_PATH = "../model/cat_model.cbm" 

# Function to load the trained model
def load_model():
    model = CatBoostClassifier()
    model.load_model(MODEL_PATH)
    return model

# Function to predict churn probability from data in DataFrame format
def get_churn_probability(data, model):
    # Convert incoming data into a DataFrame
    dataframe = pd.DataFrame.from_dict(data, orient='index').T
    # Make the prediction
    churn_probability = model.predict_proba(dataframe)[0][1]
    return churn_probability

# Load the model
model = load_model()

# Create the FastAPI application
app = FastAPI(title="Churn Prediction API", version="1.0")

@app.get('/')
def index():
    return {'message': 'CHURN Prediction API'}

# Define the API endpoint
@app.post('/predict/')
def predict_churn(data: dict):
    # Get the prediction
    churn_probability = get_churn_probability(data, model)
    # Return the prediction
    return {'Churn Probability': churn_probability}

# Run the application
if __name__ == '__main__':
    uvicorn.run("fast-api:app", host='127.0.0.1', port=5000)

Step 1: Setting Up
FastAPI script begins by importing necessary libraries, including FastAPI itself, Pandas for data manipulation, and CatBoost for loading the trained model.

Step 2: Loading the Model
The script defines a function load_model() to load the pre-trained CatBoost model from the specified path.

Step 3: Predicting Churn Probability
Another function get_churn_probability() is defined to predict churn probability from the input data in DataFrame format. This function converts the incoming data dictionary into a DataFrame and then uses the loaded model to predict the churn probability.

Step 4: Creating FastAPI Application
The FastAPI application is created with the title “Churn Prediction API” and version “1.0”.

Step 5: Defining API Endpoints
- The / endpoint is defined to provide a simple message indicating the availability of the CHURN Prediction API.
- The /predict/ endpoint is defined to accept POST requests with data in JSON format. It calls the predict_churn() function, which in turn uses the loaded model to predict churn probability for the provided data.

Step 6: Running the Application
Finally, the application is run using the uvicorn.run() function. It specifies the script file (fast-api) and the FastAPI instance (app), along with host and port configurations.

You can start the API inside the folder containing thefast-api.pyfile as follows:

python fast-api.py

We can see the API by going to the Host given to Uvicorn.

But to access the API we created, we need to add /docs or /redoc at the end of the extension (http://127.0.0.1:5000/docs).

The API created allows us to interactively see the churn probability of the customer we will create.

We can enter the generated customer data by clicking on Try it out under POST -> /predict/.

By pressing Execute, we evaluate the churn probability of the customer. If the API returns a successful response, we should see a result like below.

It is seen that the customer’s Churn probability is 62.8504%. Using the same customer data, we could also obtain the Churn probability via Streamlit.

Now that we have successfully built the Streamlit interface and API, it’s time to move the model to the product environment. In this process, the necessary work will be done to ensure that the model can be used comfortably on every platform and device.

5. Automation (Docker)

Docker is referred to as a containerization technology. Containers are used to run applications and their dependencies in an independent and isolated environment. A Docker container contains all the application code, libraries, and configuration files.

From this point on, we need to automate the model file that we know works in our system. So why do we need such a solution? A model that works properly on our system may not work on other systems due to issues such as compatibility. We need to standardize the model and make it work properly in the system components we build. Docker offers a good solution to avoid facing problems such as who has which packages installed on whose system, and who received an error at which stage. Besides all these, it provides portability, dependency management, isolation, and easier deployment.

In the first step, we created train_model.py file where the data preprocessing steps and the model are developed. Instead of working with this file, we will create predict.py, which contains the same process, but with an extra prediction section.

The model created in the train_model.py script needs to be saved to be used here. Edit the file path in the script below according to the file path where you saved the model.

predict.py file:

import pandas as pd
from catboost import CatBoostClassifier

# Load the trained model
MODEL_PATH = "model/cat_model.cbm" 
model = CatBoostClassifier()
model.load_model(MODEL_PATH)

def predict_churn(user_input):
    try:
        # Prepare data for prediction
        user_data = pd.DataFrame([user_input])
        
        # Make prediction
        prediction = model.predict_proba(user_data)[:, 1][0]
        
        return {"Churn Probability": float(prediction)}
    except Exception as e:
        return {"error": str(e)}

if __name__ == "__main__":
    # Ask user for input
    customerID = "6464-UIAEA"
    print("Please enter the following information:")
    gender = input("Gender (Male/Female): ").strip()
    senior_citizen = int(input("Senior Citizen (0/1): ").strip())
    partner = input("Partner (Yes/No): ").strip()
    dependents = input("Dependents (Yes/No): ").strip()
    tenure = int(input("Tenure (months): ").strip())
    phone_service = input("Phone Service (Yes/No): ").strip()
    multiple_lines = input("Multiple Lines (Yes/No): ").strip()
    internet_service = input("Internet Service (DSL/Fiber optic/No): ").strip()
    online_security = input("Online Security (Yes/No): ").strip()
    online_backup = input("Online Backup (Yes/No): ").strip()
    device_protection = input("Device Protection (Yes/No): ").strip()
    tech_support = input("Tech Support (Yes/No): ").strip()
    streaming_tv = input("Streaming TV (Yes/No): ").strip()
    streaming_movies = input("Streaming Movies (Yes/No): ").strip()
    contract = input("Contract (Month-to-month/One year/Two year): ").strip()
    paperless_billing = input("Paperless Billing (Yes/No): ").strip()
    payment_method = input("Payment Method (Electronic check/Mailed check/Bank transfer (automatic)/Credit card (automatic)): ").strip()
    monthly_charges = float(input("Monthly Charges ($): ").strip())
    total_charges = float(input("Total Charges ($): ").strip())

    new_customer_data = pd.DataFrame({
                "customerID": [customerID],
                "gender": [gender],
                "SeniorCitizen": [senior_citizen],
                "Partner": [partner],
                "Dependents": [dependents],
                "tenure": [tenure],
                "PhoneService": [phone_service],
                "MultipleLines": [multiple_lines],
                "InternetService": [internet_service],
                "OnlineSecurity": [online_security],
                "OnlineBackup": [online_backup],
                "DeviceProtection": [device_protection],
                "TechSupport": [tech_support],
                "StreamingTV": [streaming_tv],
                "StreamingMovies": [streaming_movies],
                "Contract": [contract],
                "PaperlessBilling": [paperless_billing],
                "PaymentMethod": [payment_method],
                "MonthlyCharges": [monthly_charges],
                "TotalCharges": [total_charges]
            })

    # Predict churn probability using the model
    churn_probability = model.predict_proba(new_customer_data)[:, 1]

    # Format churn probability
    formatted_churn_probability = "{:.2%}".format(churn_probability.item())

    print(f"Churn Probability: {formatted_churn_probability}")

This Python script allows the user to predict churn using the pre-trained model. It converts the user’s input into a DataFrame and gives it to the model to make a prediction. The script ends by printing the result to the screen.

Requirements should be well specified in the Dockerfile created for the deployment of the model. At this stage, we continue by creating a requirements.txt file. There are several ways to create this file. Specific libraries used when creating the model can be specified manually. Or if you used virtual environments such as virtualenv, pip freeze, pipreqs or piqar can be used as a good option. However, it should be noted that pip freeze will save all the packages in the virtual environment, not the environment variables used in your work. You can review here for the use of pip freeze.

For this work, I used pip freeze and created the requirements.txt file in the project folder:

altair==5.2.0
annotated-types==0.6.0
anyio==4.2.0
asttokens==2.4.1
attrs==23.2.0
blinker==1.7.0
cachetools==5.3.2
catboost==1.2.2
certifi==2024.2.2
charset-normalizer==3.3.2
click==8.1.7
cloudpickle==3.0.0
contourpy==1.2.0
cycler==0.12.1
decorator==5.1.1
executing==2.0.1
fastapi==0.109.2
fonttools==4.48.1
gitdb==4.0.11
GitPython==3.1.41
graphviz==0.20.1
h11==0.14.0
idna==3.6
importlib-metadata==7.0.1
ipython
jedi==0.19.1
Jinja2==3.1.3
joblib==1.3.2
jsonschema==4.21.1
jsonschema-specifications==2023.12.1
kiwisolver==1.4.5
llvmlite==0.42.0
markdown-it-py==3.0.0
MarkupSafe==2.1.5
matplotlib==3.8.3
matplotlib-inline==0.1.6
mdurl==0.1.2
numba==0.59.0
numpy==1.26.4
packaging==23.2
pandas==2.2.0
parso==0.8.3
pexpect==4.9.0
pillow==10.2.0
plotly==5.18.0
prompt-toolkit==3.0.43
protobuf==4.25.2
ptyprocess==0.7.0
pure-eval==0.2.2
pyarrow==15.0.0
pydantic==2.6.1
pydantic_core==2.16.2
pydeck==0.8.1b0
Pygments==2.17.2
pyparsing==3.1.1
python-dateutil==2.8.2
pytz==2024.1
referencing==0.33.0
requests==2.31.0
rich==13.7.0
rpds-py==0.18.0
scikit-learn==1.4.0
scipy==1.12.0
shap==0.44.1
six==1.16.0
slicer==0.0.7
smmap==5.0.1
sniffio==1.3.0
stack-data==0.6.3
starlette==0.36.3
streamlit==1.31.1
tenacity==8.2.3
threadpoolctl==3.3.0
toml==0.10.2
toolz==0.12.1
tornado==6.4
tqdm==4.66.2
traitlets==5.14.1
typing_extensions==4.9.0
tzdata==2024.1
tzlocal==5.2
urllib3==2.2.0
uvicorn==0.27.1
validators==0.22.0
watchdog==4.0.0
wcwidth==0.2.13
zipp==3.17.0

Dockerfile is a configuration file that determines the structure of Docker containers. It contains instructions such as how to run the application and which dependencies should be installed. Docker creates a container using this Dockerfile and converts this container into a file called an “image”. This “image” then becomes executable on any system.

After creating the requirements.txt file, we can create the Dockerfile:

# Use a Python-based image
FROM python:3.9-slim

# Copy requirements.txt and install dependencies
COPY requirements.txt requirements.txt
RUN pip install --no-cache-dir -r requirements.txt

# Specify working directory
WORKDIR /app

# Copy application code
COPY . .

# Run the application
CMD ["python", "src/predict.py"]

Step 1: Base Image Selection
We start by specifying the base image that provides the minimum Python environment in which the container will be created (python:3.9-slim).

Step 2: Installing Dependencies
Copy the requirements.txt file from the host machine to the container and install the dependencies listed in it using pip.

Step 3: Setting the Working Directory and Copying Application Code
Set the working directory to /app. Copy all files and directories from the host machine to the /app directory within the container.

Step 4: Running the Application
Execute the predict.py script using the Python interpreter as the default command when the container starts.

To continue at this stage of the project, after installing Docker and creating the necessary files, we can go to the directory where the Dockerfile is located and build it as follows.

docker build -t churn-prediction-app .

You can see if the Dockerfile has been successfully built with the command below:

We have done the build, we can run the image we created in the terminal.

docker run -it churn-prediction-app

We can see the result of the model by entering the customer information we want to see the churn probability in order.

Through Docker, we can see the Churn probability of the customer we created for prediction in Streamlit and FastAPI. Users who want to predict the model we have created can access this convenience by building and running the Dockerfile.

6. Conclusion

During the development of the project, a machine learning model was developed using CatBoost with customer data provided by the telecom company. To examine the model interactively, an interface was designed using Streamlit. In addition, an API was created with FastAPI to quickly access and integrate the model. Finally, optimization was achieved using Docker to make the project more scalable and deployable.

I would like to express my sincere thanks to Hasan Avcı for his support during this journey and to inzva for the opportunities they provided.

Thank you for reading and please do not hesitate to share your comments and suggestions.

LinkedIn: https://www.linkedin.com/in/ramazanolmez/
Mail: ramazanolmeez@gmail.com

You can also view the work on Kaggle.

Table of Contents
· 1. Introduction
· 2. Types of Missing Data
∘ a. Missing Completely At Random (MCAR)
∘ b. Missing At Random (MAR)
∘ c. Missing Not At Random (MNAR)
· 3. Dataset
· 4. Missing Value Analysis
· 5. Methods
∘ 5.1. Ignoring Missing Data
∘ 5.2. Delete Missing Data
∘ 5.3. Statistically Filling Missing Data (Mean-Median-Constant)
∘ 5.4. Other Filling Methods (Forward Fill — Backward Fill — Linear (Interpolation))
∘ 5.5. Advanced Imputation Techniques (Prediction of Missing Values) (KNN — Linear Regression — Random Forest Regressor)
· 6. Result

1. Introduction

Missing values are a common problem in machine learning and data science projects. Failure to handle missing data correctly can skew the results of machine learning models or reduce the model's accuracy. To overcome these obstacles, we must either carefully remove missing values or carefully complete them. Either way, our goal is to create a complete dataset that will put our analysis on a solid footing. Ignoring missing data can directly affect the performance and reliability of our models. Therefore, it is extremely important to know the different techniques for dealing with missing values and choose the right method. While dealing with missing values is not our ultimate goal, it plays a critical role in data preprocessing steps and can help to significantly improve model performance. In this article, I will explain the causes and types of missing data and the advantages and disadvantages of various methods to deal with this problem.

Missing data can be caused by merging data sources, accidents or measurement errors during data collection, lack of records, respondent unwillingness to provide information, etc.

2. Types of Missing Data

Missing data types are categorized into 3 groups in the literature:

a. Missing Completely At Random (MCAR)

In the MCAR case, there is no relationship between the missing data and the other values in the data set. In other words, the missing values are completely independent of the other data. As the missing values increase, the overall information content of the data set decreases. This can affect the accuracy and reliability of the analysis results.

b. Missing At Random (MAR)

MAR is a type of missing data where the missing data is correlated with other observed values. In this case, missing data does not occur randomly, but is missing according to a specific pattern. This pattern can be explained by a variable for which we have information about the cause of the missingness. If missing data of this type is ignored, the results of the analysis may not reflect the real situation.

c. Missing Not At Random (MNAR)

MNAR is a type of missing data where the missing data is due to unobserved data and cannot be explained by other observed data. If there is a structure or pattern in the missing data and this pattern cannot be explained by the observed data, it can be categorized as MNAR.

3. Dataset

In this article, I will use the “UCI Heart Disease Data” set available in the UCI Data Repository. This dataset aims to predict whether a patient has heart disease based on certain characteristics. You can access the dataset here;

• https://www.kaggle.com/datasets/redwankarimsony/heart-disease-data
• https://archive.ics.uci.edu/dataset/45/heart+disease

In the dataset, the target variable is given in 5 groups. These groups will be reduced to 2 (with heart disease, and without heart disease) and evaluated.

In addition, since this study does not focus on model development, I will encode the categorical variables and make the entire dataset numerical. The dataset I will use in the scope of the article looks as follows.

4. Missing Value Analysis

Visualizations and summaries are the first step in understanding missing information in a dataset. Identifying how many and what types of missing values are present in our dataset is one of the first steps when dealing with missing values. A glance at the number of missing values in the dataset can give a good idea:

However, as well as the number of missing data, another point to look at is the proportion of missing data in the whole data set. The following function can be used for this analysis:

def missing_values(df):
        # Total missing values
        mis_val = df.isnull().sum()
        
        # Percentage
        mis_val_percent = 100 * df.isnull().sum() / len(df)
        
        # Make a table with the results
        mis_val_table = pd.concat([mis_val, mis_val_percent], axis=1)
    
        mis_val_table_ren_columns = mis_val_table.rename(
        columns = {0 : 'Missing Values', 1 : '% of Total Values'})
        
        # Sort the table by percentage of missing descending
        mis_val_table_ren_columns = mis_val_table_ren_columns[
            mis_val_table_ren_columns.iloc[:,1] != 0].sort_values(
        '% of Total Values', ascending=False).round(1)
        
        # Print some summary information
        print ("Your selected dataframe has " + str(df.shape[1]) + " columns.\n"      
            "There are " + str(mis_val_table_ren_columns.shape[0]) +
              " columns that have missing values.")
        
        # Return the dataframe with missing information
        return mis_val_table_ren_columns
    
missing_values_table = missing_values(data)
missing_values_table

Although the proportion of missing values in the whole data set provides some information, it is not enough. One of the useful tools for analysis is missingno. Missingno, provides a flexible and easy-to-use toolkit that allows one to get a quick visual summary.

To see how the data correlate with each other;

sorted = data.sort_values('oldpeak')
msno.matrix(sorted)

You can also use a heat map for correlation:

msno.heatmap(data)

In this dataset, ‘trestbps’, ‘thalch’ and ‘oldpeak’ variables are highly correlated with each other. The reason behind this should be investigated, and we should take this into account when dealing with missing values.

Another point we can look at in visualization is the dendrogram.

msno.dendrogram(data)

This tree diagram groups variables with high correlation together. The variables at position 0 are not correlated with the missing variables. As I observed in the heatmap, the variables ‘thalch’, ‘trestbps’ and ‘oldpeak’ are highly correlated with each other. At the same time, these 3 variables are more correlated with ‘thal’ and ‘chol’ than ‘ca’.

5. Methods

There are multiple assignment methods we can use depending on whether the data is missing at random, the proportion of missing values, and the machine learning model we plan to use. It is important to handle missing data appropriately. If we want to use an algorithm that can work with missing data, perhaps we should leave it as it is. However, most algorithms cannot work with missing data and they need to be cleaned/edited.

In this article, each method was applied to the dataset, and the Random Forest Classifier model was trained with the new dataset. The accuracy of each method is shared and compared in the conclusion.

The most commonly used methods for dealing with missing data

• Using algorithms like XGBoost to ignore missing data
• Remove missing data by row or column
• Filling in missing data statistically
• Filling missing data with other methods
• Prediction of missing values

Before we move on to these methods, let’s load the libraries and create the functions you need to run the notebook.

import numpy as np # For linear algebra operations and numerical computations
import pandas as pd # For data analysis and manipulation using data frames
import os

# List Kaggle file paths
for dirname, _, filenames in os.walk('/kaggle/input'):
    for filename in filenames:
        print(os.path.join(dirname, filename))

import missingno as msno # For visualizing missing data patterns

from sklearn.preprocessing import LabelEncoder # For converting categorical data to numerical values
from sklearn.model_selection import train_test_split # For splitting data into training and testing sets
from sklearn.metrics import accuracy_score # For calculating the accuracy score of a classification model
from sklearn.impute import KNNImputer # For imputing missing values using K-Nearest Neighbors
from sklearn.neighbors import KNeighborsClassifier # K-Nearest Neighbors classification model
from sklearn.linear_model import LinearRegression # Linear regression model
from sklearn.ensemble import RandomForestRegressor # Random Forest regression model
from sklearn.ensemble import RandomForestClassifier # Random Forest classifier model
from sklearn.metrics import mean_squared_error # Performance metric for regression models
from sklearn.impute import SimpleImputer # For imputing missing values with a simple strategy

from xgboost import XGBClassifier # XGBoost classification model

def read_data():
    """
    Reads the 'Heart disease' dataset,
    performs some editing, and returns it.
    """
    df = pd.read_csv("/kaggle/input/heart-disease-data/heart_disease_uci.csv")
    df['num'] = df['num'].replace({2: 1, 3: 1, 4: 1})
    df = df.drop('id', axis=1)
    df[df.select_dtypes(['object']).columns] = df.select_dtypes(['object']).apply(lambda x: x.astype('category'))
    
    categorical_columns = df.select_dtypes(include=['category']).columns

    # Convert categorical to numerical
    label_encoder = LabelEncoder()
    
    for column in categorical_columns:
        df[column] = label_encoder.fit_transform(df[column])
    return df

def split_dataset(df):
    """
    Splits the dataset into training and testing sets.
    
    Parameters:
    - df (pd.DataFrame): The input dataset.
    
    Returns:
    - X_train, X_test, y_train, y_test: Training and testing sets for features and labels.
    """
    X = df.drop('num', axis=1)
    y = df['num']
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
    # print(f'Size of the Train: {X_train.shape[0]}')
    # print(f'Size of the Test: {X_test.shape[0]}')
    return X_train, X_test, y_train, y_test

def train_model_XGBoost(X_train, X_test, y_train, y_test):
    """
    Trains an XGBoost model on the given training set and evaluates it on the test set.
    
    Parameters:
    - X_train, X_test, y_train, y_test: Training and testing sets for features and labels.
    """
    # Create and train the XGBoost model
    xgb_model = XGBClassifier()
    xgb_model.fit(X_train, y_train)

    # Evaluate the model on the test set
    y_pred = xgb_model.predict(X_test)
    accuracy = accuracy_score(y_test, y_pred)
    print(f"Accuracy: {accuracy}\n")
    return accuracy
    
def train_model_random_forest(X_train, X_test, y_train, y_test):
    """
    Creates and trains a RandomForest model on the given training set 
    and evaluates its performance on the test set.
    
    Parameters:
    - X_train, X_test, y_train, y_test: Training and testing sets for features and labels.
    
    Returns:
    - accuracy (float): Accuracy score of the trained model on the test set.
    """
    # Create and train the RandomForest model
    rf_model = RandomForestClassifier()
    rf_model.fit(X_train, y_train)

    # Evaluate the model on the test set
    y_pred = rf_model.predict(X_test)
    accuracy = accuracy_score(y_test, y_pred)
    print(f"Accuracy: {accuracy}\n")
    return accuracy


# To compare the success of the methods
accuracies = {}

5.1. Ignoring Missing Data

Most popular models (SVM, NN…) cannot work with missing data. However, there are a few predictive models that can handle missing data internally. In this step, we will train a model using XGBoost without handling missing values in the raw dataset.

# Read and preprocess the dataset
df = read_data()

# Split the dataset into training and testing sets
X_train, X_test, y_train, y_test = split_dataset(df)

# Train an XGBoost model on the dataset without handling missing values
accuracy_no_handling = train_model_XGBoost(X_train, X_test, y_train, y_test)

# Store the accuracy of the model without handling missing values in a dictionary
accuracies['No Handling'] = accuracy_no_handling

# A specific data, after the procedure
print("\n------------------\n")
print("\nAfter Imputation: \n")
X_train[(X_train['age']==58.0) & (X_train['sex']==1.0) & (X_train['dataset']==3.0) & (X_train['chol']==385)]

Pros:

• Ignoring missing values simplifies the data preprocessing process. Instead of dealing with missing values, time is saved by feeding the dataset directly into the modeling algorithms.
• This method is preferable for creating a quick prototype at the beginning of a project. Modeling can be started immediately, rather than having to go through the detailed process of filling in or cleaning up missing values.
• Some machine learning algorithms can handle missing values directly and may not harm model performance. In particular, such algorithms, such as tree-based algorithms, can be robust to missing values.

Cons:

• It can lead to the loss of potentially valuable information from the dataset. Missing values can often be indicative of important patterns in the dataset and ignoring this information can negatively impact the performance of the model.
• It can reduce the predictive accuracy of the model. Missing values may prevent the model from generalizing correctly and lead to biased results.
• It can introduce bias into the patterns in the dataset. This can reduce the model’s ability to fit real-world data and reduce the reliability of predictions.
• Some algorithms can be robust to missing values, but this can lead to reduced precision of the model. Filling in or cleaning up missing values can help the model make more accurate and reliable predictions.

5.2. Delete Missing Data

If models that do not tolerate missing data are to be used, the missing values must be removed from the data set. The simplest approach is to delete all samples that contain missing values. Missing values can be eliminated by removing variables that contain at least one missing value. Similarly, removing all columns with missing values from the data set is another approach. Before using these approaches, however, some aspects of the data need to be carefully considered. The size of the data after deletion of missing data, the randomness of missing data, or the ratio of missing data to the entire data set are critical points to consider when applying these approaches.

This category consists of 3 stages. These stages are:

• Pairwise Deletions
• Listwise Deletions
• Dropping Entire Columns

a. Pairwise Deletions

If each data point has at least one missing value, that row of data is deleted from the entire list. This method can be used when the amount of missing data is small and the missing values are randomly distributed.

# Read and preprocess the dataset
df = read_data()

# 1. Pairwise Deletions
# Drop rows with any missing values (Pairwise Deletions)
df_pairwise = df.dropna()

# Split the dataset (after Pairwise Deletions) into training and testing sets
X_train, X_test, y_train, y_test = split_dataset(df_pairwise)

# Train a Random Forest model on the dataset after Pairwise Deletions
accuracy_pairwise = train_model_random_forest(X_train, X_test, y_train, y_test)

# Store the accuracy of the model after Pairwise Deletions in a dictionary
accuracies['Pairwise'] = accuracy_pairwise

Pros:

• It is very useful for simplicity and computational efficiency.

Cons:

• It leads to a loss of information and a reduction in the number of samples. This can lead to insufficient data for the model.

b. Listwise Deletions

All data instances with missing data from more than one variable are deleted. This method can be used when the amount of missing data is large or when the missing values are distributed according to a certain pattern.

# Read and preprocess the dataset
df = read_data()

# 2. Listwise Deletions
# Drop rows with missing values in specific columns
df_listwise = df.dropna(subset=['trestbps', 'chol', 'thalch', 'oldpeak', 'ca'])

# Split the dataset (after Listwise Deletions) into training and testing sets
X_train, X_test, y_train, y_test = split_dataset(df_listwise)

# Train a Random Forest model on the dataset after Listwise Deletions
accuracy_listwise = train_model_random_forest(X_train, X_test, y_train, y_test)

# Store the accuracy of the model after Listwise Deletions in a dictionary
accuracies['Listwise'] = accuracy_listwise

Pros:

• As with Pairwise Deletions, it is very simple and low-cost to implement.

Cons:

• It may reduce the number of samples. This can lead to a destabilization of the dataset and loss of correlation.

c. Dropping Entire Columns

All columns with too much missing data are deleted from the dataset. This method can be used when the amount of missing data is very large and the columns with missing data are not important for the analysis. However, this approach should only be used when there are many empty values in the column.

# Read and preprocess the dataset
df = read_data()

# 3. Dropping Entire Columns
# Drop entire columns with any missing values
df_dropping_entire_columns = df.dropna(axis=1)

# Split the dataset (after Dropping Entire Columns) into training and testing sets
X_train, X_test, y_train, y_test = split_dataset(df_dropping_entire_columns)

# Train a Random Forest model on the dataset after Dropping Entire Columns
accuracy_dropping_entire_columns = train_model_random_forest(X_train, X_test, y_train, y_test)

# Store the accuracy of the model after Dropping Entire Columns in a dictionary
accuracies['Dropping Entire Columns'] = accuracy_dropping_entire_columns

# A specific data, after the procedure
print("\n------------------\n")
print("\nAfter Imputation: \n")
X_train[(X_train['age']==58.0) & (X_train['sex']==1.0) & (X_train['dataset']==3.0) & (X_train['restecg']==0) & (X_train['exang']==2)]

Pros:

• Like other deletions, this method offers a simple and computationally cost-effective solution.

Cons:

• Deleting all columns with missing values may result in the loss of important information in the dataset. This can negatively affect the accuracy and reliability of the model.
• While the simplicity of this method may be attractive, deleting columns has serious consequences for model performance.

5.3. Statistically Filling Missing Data (Mean-Median-Constant)

Another approach to handling missing data is to statistically fill them in. The filling process uses relationships between non-missing data.

Some methods of this approach include filling in missing data with mean, median, or constant if the data are numeric and mode if the data are categorical.

a. Mean and Median

Mean: This is the most common method of filling in missing values in numeric columns. This method may not be appropriate if there are outliers in the dataset. In such cases, outliers need to be addressed first.

Median: This is the value that divides the data series in half when we sort the dataset from smallest to largest. It is better to use the median if there are outliers in the data set.

def impute_and_train(X_train, y_train, X_test, y_test, strategy):
    """
    Imputes missing values in the training and testing sets using the specified strategy,
    trains a Random Forest model, and evaluates its performance on the test set.
    
    Parameters:
    - X_train, y_train: Training features and labels.
    - X_test, y_test: Testing features and labels.
    - strategy (str): Imputation strategy to handle missing values ('mean' or 'median').
    
    Returns:
    - accuracy (float): Accuracy score of the model on the test set.
    """
    # Impute missing values
    imputer = SimpleImputer(strategy=strategy)
    X_train_imputed = pd.DataFrame(imputer.fit_transform(X_train), columns=X_train.columns)
    X_test_imputed = pd.DataFrame(imputer.transform(X_test), columns=X_test.columns)
    
    # Train a Random Forest model on the imputed training set
    rf_model = RandomForestClassifier()
    rf_model.fit(X_train_imputed, y_train)

    # Evaluate the model on the imputed test set
    y_pred = rf_model.predict(X_test_imputed)
    accuracy = accuracy_score(y_test, y_pred)
        
    print(f"\n\nImputation strategy: {strategy}")
    print(f"Accuracy: {accuracy}\n")
    return accuracy, X_train_imputed

# Read and preprocess the dataset
df = read_data()
X_train, X_test, y_train, y_test = split_dataset(df)

# Train the model using different imputation strategies
strategies = ['mean', 'median']

for strategy in strategies:
    accuracy, X_train_imputed = impute_and_train(X_train, y_train, X_test, y_test, strategy)
    accuracies[strategy] = accuracy
    
    # A specific data, after the procedure
    print("\n------------------\n")
    print("\nAfter Imputation: \n")
    print(X_train_imputed[(X_train_imputed['age']==58.0) & (X_train_imputed['sex']==1.0) & (X_train_imputed['dataset']==3.0) & (X_train_imputed['chol']==385)])
    print("\n----------------------------\n----------------------------\n----------------------------")

Pros:

• Easy to implement and fast.
• Minimizes information loss.
• Preserves the overall performance of the model.
• Conserves the size of the data set.
• More sensitive to outliers (Median Imputation).

Cons:

• May increase the impact of outliers (Mean Imputation).
• It can change the distribution between values.
• Distort the original structure of missing values.
• Reduces the natural variance of the data set.

b. Constant

Constant filling is the process of filling missing values with a constant value (0, 100, 999, etc.). Although it has its advantages, it also has many disadvantages.

def constant_imputer(X_train, y_train, X_test, y_test):
    """
    Imputes missing values with a constant value (999) in the training and testing sets,
    trains a Random Forest model, and evaluates its performance on the test set.
    
    Parameters:
    - X_train, y_train: Training features and labels.
    - X_test, y_test: Testing features and labels.
    
    Returns:
    - accuracy (float): Accuracy score of the model on the test set.
    """
    # Impute missing values with a constant value (999)
    imputer = SimpleImputer(strategy='constant', fill_value=999)
    X_train_imputed = pd.DataFrame(imputer.fit_transform(X_train), columns=X_train.columns)
    X_test_imputed = pd.DataFrame(imputer.transform(X_test), columns=X_test.columns)
    
    # Train a Random Forest model on the imputed training set
    rf_model = RandomForestClassifier()
    rf_model.fit(X_train_imputed, y_train)

    # Evaluate the model on the imputed test set
    y_pred = rf_model.predict(X_test_imputed)
    accuracy = accuracy_score(y_test, y_pred)
    print(f"\nAccuracy: {accuracy}\n")
    return accuracy, X_train_imputed

# Read and preprocess the dataset
df = read_data()
X_train, X_test, y_train, y_test = split_dataset(df)

# Impute missing values with a constant value and train the model
accuracy_constant, X_train_imputed = constant_imputer(X_train, y_train, X_test, y_test)

# Store the accuracy of the model with constant imputation in a dictionary
accuracies['Constant Impute'] = accuracy_constant

# A specific data, after the procedure
print("\n------------------\n")
print("\nAfter Imputation: \n")

X_train_imputed[(X_train_imputed['age']==58.0) & (X_train_imputed['sex']==1.0) & (X_train_imputed['dataset']==3.0) & (X_train_imputed['chol']==385)]

Pros:

• Like other filling methods, it is a simple and quick approach.

Cons:

• It may cause a loss of information in the dataset as it fills missing values with a random or meaningless value.
• If an appropriate constant value is not chosen for missing values, it may negatively affect the performance of the model.

5.4. Other Filling Methods (Forward Fill — Backward Fill — Linear (Interpolation))

Depending on the nature of the data or the type of data, some other filling methods may be more appropriate for filling missing values. For example, for a time series dataset, it may make sense to use the last valid observation to fill in the missing value.

Forward Fill: All missing values are filled according to the corresponding value in the previous row.

Backward Fill: The missing value is found using the next value.

Interpolation: Missing values are estimated using the linear relationship between other values in the dataset. Pandas’ interpolation method can be used to replace missing values with different interpolation methods such as ‘polynomial’, ‘linear’, and ‘quadratic’. The default method is ‘linear’.

In the dataset we considered, the method could not be applied to all variables due to missing values in the last 2 columns of the ‘ca’ variable. To overcome this problem, I used a little trick in the code and used the mean method for this variable.

def fill_missing_values(data, method='ffill'):
    """
    Fills missing values in the dataset using specified methods: 'ffill', 'bfill', or 'linear'.
    
    Parameters:
    - data (pd.DataFrame): Input dataset.
    - method (str): Method for filling missing values ('ffill', 'bfill', or 'linear').
    
    Returns:
    - filled_data (pd.DataFrame): Dataset with filled missing values.
    """
    if method == 'ffill':
        filled_data = data.fillna(method='ffill')
    elif method == 'bfill':
        data['ca'] = data['ca'].fillna(data['ca'].mean())
        filled_data = data.fillna(method='bfill')
    else:
        filled_data = data.interpolate(method='linear', limit_direction='forward')
    return filled_data

# Read and preprocess the dataset
data = read_data()

# Fill missing values using forward fill method
filled_data_ffill = fill_missing_values(data, method='ffill')
X_train_ffill, X_test_ffill, y_train_ffill, y_test_ffill = split_dataset(filled_data_ffill)

# Fill missing values using back fill method
filled_data_bfill = fill_missing_values(data, method='bfill')
X_train_bfill, X_test_bfill, y_train_bfill, y_test_bfill = split_dataset(filled_data_bfill)

# Fill missing values using linear interpolation method
filled_data_linear = fill_missing_values(data, method='linear')
X_train_linear, X_test_linear, y_train_linear, y_test_linear = split_dataset(filled_data_linear)

# A specific data, after the procedure
# Train Random Forest models on datasets with different filling methods
print("\n\n\nFfill method:")
accuracy_ffill = train_model_random_forest(X_train_ffill, X_test_ffill, y_train_ffill, y_test_ffill)
print("\n------------------\n")
print("\nAfter Imputation: \n")
print(X_train_ffill[(X_train_ffill['age']==58.0) & (X_train_ffill['sex']==1.0) & (X_train_ffill['dataset']==3.0) & (X_train_ffill['chol']==385)]
)
print("\n----------------------------\n----------------------------\n----------------------------")

print("\n\n\nBfill method:")
accuracy_bfill = train_model_random_forest(X_train_bfill, X_test_bfill, y_train_bfill, y_test_bfill)
print("\n------------------\n")
print("\nAfter Imputation: \n")
print(X_train_bfill[(X_train_bfill['age']==58.0) & (X_train_bfill['sex']==1.0) & (X_train_bfill['dataset']==3.0) & (X_train_bfill['chol']==385)]
)
print("\n----------------------------\n----------------------------\n----------------------------")

print("\n\n\nLinear method:")
accuracy_linear = train_model_random_forest(X_train_linear, X_test_linear, y_train_linear, y_test_linear)
print("\n------------------\n")
print("\nAfter Imputation: \n")
print(X_train_linear[(X_train_linear['age']==58.0) & (X_train_linear['sex']==1.0) & (X_train_linear['dataset']==3.0) & (X_train_linear['chol']==385)]
)
print("\n----------------------------\n----------------------------\n----------------------------")

# Store accuracies in a dictionary for comparison
accuracies['Ffill'] = accuracy_ffill
accuracies['Bfill'] = accuracy_bfill
accuracies['Linear'] = accuracy_linear

Pros:

• Suitable for time series data.
• Provides a quick and simple solution.
• Helps preserve variance in the dataset.

Cons:

• May give incorrect results if missing values are consecutive.
• Does not take trends and seasonality into account.
• May ignore relationships between variables.

Pros:

• Suitable for time series data.
• Provides a quick and simple solution.
• Helps preserve variance in the dataset.

Cons:

• May give incorrect results if missing values are consecutive.
• Does not take trends and seasonality into account.
• May ignore relationships between variables.

Pros:

• It considers the relationships between variables.
• Can provide more accurate forecasts.

Cons:

• May increase the impact of outliers.
• Cannot accurately model complex relationships.

5.5. Advanced Imputation Techniques (Prediction of Missing Values) (KNN — Linear Regression — Random Forest Regressor)

In previous methods for handling missing values, we did not take advantage of the correlation between the variable containing the missing value and other variables. Using other features that do not have missing values can be used to estimate missing values. Depending on the nature of the feature with missing values, regression or classification models can be used to estimate missing values.

a. K-Nearest Neighbors (KNN)

KNN is a method that uses the K nearest neighbor algorithm to predict missing values. The algorithm identifies k data points to make a prediction. These k data points are those closest to the data point with the missing value. If the data set is continuous, the Euclidean distance can be used as a distance measure, and if the data set is categorical, the Hamming distance can be used.

def knn_impute(X_train, X_test, y_train, y_test, k=5):
    """
    Imputes missing values using the K-Nearest Neighbors (KNN) algorithm.

    Parameters:
    - X_train: pandas DataFrame, training dataset
    - X_test: pandas DataFrame, testing dataset
    - y_train: pandas Series, training labels
    - y_test: pandas Series, testing labels
    - k: int, number of neighbors for KNN imputation

    Returns:
    - X_train_imputed, X_test_imputed, y_train, y_test: pandas DataFrames and Series,
      imputed training and testing datasets along with labels
    """
    knn_imputer = KNNImputer(n_neighbors=k)
    X_train_imputed = pd.DataFrame(knn_imputer.fit_transform(X_train), columns=X_train.columns)
    X_test_imputed = pd.DataFrame(knn_imputer.transform(X_test), columns=X_test.columns)
    return X_train_imputed, X_test_imputed, y_train, y_test

# Read and preprocess the dataset
df = read_data()
X_train, X_test, y_train, y_test = split_dataset(df)

# Impute missing values using KNN
X_train_imputed, X_test_imputed, y_train, y_test = knn_impute(X_train, X_test, y_train, y_test, k=10)

# Train a Random Forest model on the imputed dataset
accuracy_knn = train_model_random_forest(X_train_imputed, X_test_imputed, y_train, y_test)

# Store the accuracy of the model with KNN imputation in a dictionary
accuracies['KNN'] = accuracy_knn

# A specific data, after the procedure
print("\n------------------\n")
print("\nAfter Imputation: \n")
X_train_imputed[(X_train_imputed['age']==58.0) & (X_train_imputed['sex']==1.0) & (X_train_imputed['dataset']==3.0) & (X_train_imputed['chol']==385)]

Pros:

• Takes into account the relationship between variables.
• Effectively handles categorical and numerical data.
• Easily adaptable to new data points.

Cons:

• Computational costs can be high for large datasets.
• It may be difficult to determine the optimal K value.
• Performance may be degraded for high-dimensional datasets.
• Affected by outliers.

b. Linear Regression

Linear Regression is a regression technique that expresses the relationship between the dependent variable and the independent variables in a linear model. It can be used to estimate missing values because it builds a linear model on the dataset with missing values.

def linear_regression_impute(df, target_column, feature_columns):
    """
    Imputes missing values using linear regression.

    Parameters:
    - df: pandas DataFrame, input dataset
    - target_column: str, target column with missing values to be imputed
    - feature_columns: list, feature columns used to predict missing values

    Returns:
    - pd.DataFrame, dataset with imputed missing values
    """
    # Separate missing and non-missing values
    df_missing = df[df[target_column].isnull()]
    df_not_missing = df.dropna(subset=[target_column])

    # Create training and test sets for the model
    X_train = df_not_missing[feature_columns]
    y_train = df_not_missing[target_column]

    # Create a linear regression model
    model = LinearRegression()
    model.fit(X_train, y_train)

    # Predict missing values using the model
    X_missing = df_missing[feature_columns]
    predicted_values = model.predict(X_missing)

    # Create a dataset with imputed missing values
    df_filled = df.copy()
    df_filled.loc[df[target_column].isnull(), target_column] = predicted_values

    return df_filled


# Impute missing values using linear regression
target_columns_to_impute = ['trestbps', 'chol', 'thalch', 'oldpeak', 'ca']
feature_columns_for_imputation = ['age', 'sex', 'dataset', 'cp', 'fbs', 'restecg', 'exang', 'slope', 'thal']

linear_data = read_data()

for target_column in target_columns_to_impute:
    linear_data = linear_regression_impute(linear_data, target_column, feature_columns_for_imputation)

# Split the dataset after linear regression imputation
X_train, X_test, y_train, y_test = split_dataset(linear_data)

# Train a Random Forest model on the imputed dataset
accuracy_linear_reg = train_model_random_forest(X_train, X_test, y_train, y_test)

# Store the accuracy of the model with linear regression imputation in a dictionary
accuracies['Linear Regression'] = accuracy_linear_reg

# A specific data, after the procedure
print("\n------------------\n")
print("\nAfter Imputation: \n")
X_train[(X_train['age']==58.0) & (X_train['sex']==1.0) & (X_train['dataset']==3.0) & (X_train['chol']==385)]

Pros:

• It takes into account the relationship between the variable containing the missing values and other variables.
• It has a fast calculation time.

Cons:

• It works on the assumption of a linear relationship between variables.
• It cannot capture non-linear relationships in the dataset.
• May be sensitive to the impact of outliers.

c. Random Forest Regressor

Random Forest Regressor is an ensemble regression algorithm where many decision trees are built together and the predictions are aggregated. It can be used to predict missing values because it can work with both categorical and numerical data and it is possible to train the trees independently. In addition, these models usually have good accuracy and don't predict outliers.

def random_forest_impute(df, target_column, feature_columns):
    """
    Imputes missing values using Random Forest.

    Parameters:
    - df: pandas DataFrame, input dataset
    - target_column: str, target column with missing values to be imputed
    - feature_columns: list, feature columns used to predict missing values

    Returns:
    - pd.DataFrame, dataset with imputed missing values
    """
    # Separate missing and non-missing values
    df_missing = df[df[target_column].isnull()]
    df_not_missing = df.dropna(subset=[target_column])

    # Create training and test sets for the model
    X_train = df_not_missing[feature_columns]
    y_train = df_not_missing[target_column]

    # Create a Random Forest regression model
    model = RandomForestRegressor(random_state=42)
    model.fit(X_train, y_train)

    # Predict missing values using the model
    X_missing = df_missing[feature_columns]
    predicted_values = model.predict(X_missing)

    # Create a dataset with imputed missing values
    df_filled = df.copy()
    df_filled.loc[df[target_column].isnull(), target_column] = predicted_values

    return df_filled


# Impute missing values using Random Forest
target_columns_to_impute = ['trestbps', 'chol', 'thalch', 'oldpeak', 'ca']
feature_columns_for_imputation = ['age', 'sex', 'dataset', 'cp', 'fbs', 'restecg', 'exang', 'slope', 'thal']

random_data = read_data()

for target_column in target_columns_to_impute:
    random_data = random_forest_impute(random_data, target_column, feature_columns_for_imputation)

# Split the dataset after Random Forest imputation
X_train, X_test, y_train, y_test = split_dataset(random_data)

# Train a Random Forest model on the imputed dataset
accuracy_random_forest = train_model_random_forest(X_train, X_test, y_train, y_test)

# Store the accuracy of the model with Random Forest imputation in a dictionary
accuracies['Random Forest'] = accuracy_random_forest

# A specific data, after the procedure
print("\n------------------\n")
print("\nAfter Imputation: \n")
X_train[(X_train['age']==58.0) & (X_train['sex']==1.0) & (X_train['dataset']==3.0) & (X_train['chol']==385)]

Pros:

• Provides high predictive performance
• Resistant to the effect of outliers.
• Useful for identifying important features in a dataset.

Cons:

• Managing the complexity of the model can be difficult.
• Hyperparameters such as number of trees and depth may need to be adjusted.
• Training times can be long for large datasets.

6. Result

Addressing missing values is a critical step in the data analysis process. There is no perfect way to fill in missing values in a dataset. Understanding why data is missing is crucial to manage the remaining data appropriately. Each method has advantages and disadvantages and is suitable for different types of missing data values. Furthermore, improper handling of missing data can affect the results of machine learning models and reduce model accuracy. Therefore, the correct assignment of missing values is critical in data analysis.

The following table shows the accuracy rates of the methods discussed in this paper. As can be seen from the table, in some cases, leaving missing data untouched or choosing the simplest method shows better results than other complex methods. Nevertheless, it should be kept in mind that these methods and the algorithms used in model building can directly change the result.

# Translate Dictionary to DataFrame
df = pd.DataFrame(list(accuracies.items()), columns=['Method', 'Accuracy'])

# Formatting
df['Accuracy'] = df['Accuracy'].apply(lambda x: round(x, 3))
df

Thank you for reading and your questions and comments;

LinkedIn: https://www.linkedin.com/in/ramazanolmez/

Mail: ramazanolmeez@gmail.com

Sources:

• Galli, Soledad., Python Feature Engineering Cookbook
• Ozdemir, Sinan., Susarla, Divya., Feature Engineering Made Easy: Identify unique features from your dataset in order to build powerful machine learning systems
• Kuhn, Max., Johnson, Kjell., Feature Engineering and Selection: A Practical Approach for Predictive Models (Chapman & Hall/CRC Data Science Series)
• https://towardsdatascience.com/7-ways-to-handle-missing-values-in-machine-learning-1a6326adf79e
• https://www.analyticsvidhya.com/blog/2021/10/end-to-end-introduction-to-handling-missing-values/
• https://www.analyticsvidhya.com/blog/2021/10/handling-missing-value/

PDF’ler, bilgi depolamak için yaygın olarak kullanılan bir dosya formatıdır. Ancak, PDF’lerle etkileşim kurma şeklimiz hala oldukça sınırlıdır. Genellikle, PDF’leri okumak için bir PDF okuyucu kullanırız ve uzun metinlerden çıkarım yapmak oldukça zaman alır. Peki, PDF’lerle sohbet edebilsek nasıl olurdu? PDF’lere soru sorabilseydik ve sorularımıza doğru cevaplar alabilseydik?

Bu yazının amacı, kullanıcıların araştırma makalelerinden, yasal belgelerden ve eğitim materyallerinden istenilen bilginin çıkarımını kolaylaştırarak etkileşimli bir arayüz oluşturmaktır. Bu yazıda OpenAI, FAISS, Streamlit ve Langchain kullanarak PDF’lerle sohbet edebilmemize yarayan bir uygulama geliştiriyorum.

Bu Uygulama Ne İşe Yarayacak, ChatGPT veya Bard kullanamaz mıyız?

Büyük dil modelleri hayatımızın her alanına girmeye devam ediyor. Bu modeller, metin oluşturma, dilleri çevirme, farklı türde yaratıcı içerikler yazma ve sorularınızı bilgilendirici bir şekilde yanıtlama gibi birçok görevi de gerçekleştirebiliyor. Fakat bu modeller eğitimlerinde kullanılmadıkları verilere dayanan soruları cevaplamakta zorlanıyor ve yanlış bilgiler üretebiliyor. Veya kişisel belgelerinizi, dökümanlarınızı internet ortamına yüklemek istemeyebiliyoruz. Yine de bu belgelerden bilgi çıkarımı yapma niyetindesiniz. İşte tam bu noktada bu uygulamayı kendi sisteminizde çalıştırabilir ve zaman kazanabilirsiniz.

Aşağıdaki görsellerde, ChatGPT ve uygulamanın aynı sorulara verdikleri yanıtlar gözükmektedir:

Kullanılacak Teknolojiler

OpenAI Embeddings: Metinlerin semantik anlamını temsil eden vektörler oluşturmak için kullanılır. Bu projede ise PDF belgelerinden çıkarılan metin parçalarını gömme (embedding) vektörlerine dönüştürerek, belgeler arasında semantik benzerlikleri ölçmek ve kullanıcının sorularını anlamlı şekillerde yanıtlamak amacıyla kullanılmıştır. Bu gömme vektörleri, bilgi tabanını (Vector Store — Knowledge Base) oluşturmak ve metinler arasındaki ilişkileri anlamak için kullanılan bir temel sağlar.

FAISS (Facebook AI Similarity Search): FAISS, metin gömme vektörlerini hızlı, etkili bir şekilde indeksleme ve benzerlik araması yapma amacıyla kullanılır. PDF belgelerinden elde edilen embedding vektörler, FAISS kullanılarak bir vektör deposunda saklanır ve semantik benzerlik aramalarında hızlı erişim sağlanır. Kullanıcı sorularına uygun belge parçalarını bulma sürecini optimize etmede önemli bir rol oynar.

LangChain: Metin işleme, dil modeli yönetimi ve sohbet zinciri oluşturma süreçlerini sağlayabilmek adına kullanılır. Langchain, OpenAI Embeddings ve FAISS gibi araçları birleştirerek, PDF belgelerinden çıkarılan metinleri işleyip gömme vektörlerine dönüştürür, bu vektörleri hızlı bir şekilde indeksler ve kullanıcıların sorularına anlamlı yanıtlar üreten bir sohbet zinciri oluşturur. Bu, belgelerle etkileşimde bulunma yeteneğini güçlendiren ve kullanıcıların sorularına anlamlı şekillerde cevap veren bir temel sağlar.

Streamlit: İnteraktif bir kullanıcı arayüzü oluşturmak ve sohbeti görsel olarak gösterebilmek için kullanılır. Kullanıcılar, PDF belgelerini yükleyebilir, sorular sorabilir ve sistem tarafından sağlanan metin sonuçlarını anlık olarak görüntüleyebilir. Streamlit, projenin kullanıcı dostu bir şekilde etkileşimli olmasını sağlar.

Proje Adımları

1. Belgelerin Alınması

• Kullanıcıdan PDF'leri alıyoruz. Bu adım, kullanıcının istediği sayıda belgeyi yükleyebilmesini sağlar. Bu işlem PyPDF2 kütüphanesi altında gerçekleşecektir.
• PyPDF2, PDF dosyalarının sayfalarını bölme, birleştirme, kırpma ve dönüştürme yeteneğine sahip bir python kütüphanesidir. Ayrıca PyPDF2, PDF’lerden metin ve meta verileri de alabilir.

2. PDF’lerin Parçalara Ayrılması

• PDF’lerin işlenebilmesi için metinlerin veya dökümanın parçalara (chunk) ayrılması gerekiyor. Her bir parça, PDF’deki metni temsil eder. Metni daha küçük parçalara bölerek daha anlamlı bir vektör temsili (embedding) elde edebiliriz.

3. Metin Parçalarının Sayısal Vektörlere Dönüştürülmesi

• Metin parçalarını sayısal vektörlere (embeddings) dönüştürüyoruz. Embedding, metni sayısal bir temsile çevirir ve metnin anlamını korur. Bu adımı kelimelerin birbirleriyle olan ilişkisini koruyarak gerçekleştirir. Bu işlem metinler arasında benzerlikleri daha iyi bulabilmemizi ve metinleri sayısal bir şekilde temsil edebilmemizi sağlar.
• Bu adım için HuggingFace’te bulunan çeşitli modeller veya klasik teknikler kullanılabilir. Bu proje kapsamında OpenAIEmbeddings kullanılacaktır. (OpenAI ücretli bir ürün olmasına rağmen, ürünlerinin 5$ değerinde ücret ödemeden kullanılmasına izin vermektedir.)

4. Kelime Vektörlerinin Saklanması

• Elde ettiğimiz vektörleri bir veritabanında saklıyoruz. Bu işlem, daha sonra kullanıcının sorduğu sorulara benzer vektörleri anlamsal arama (semantic search) sayesinde bulmamızı sağlar.
• Bu adım için Pinecone veya Chroma gibi vektör veritabanları kullanılabilir. Bu proje kapsamında FAISS kullanılacaktır.

5. Kullanıcı Sorularının Alınması

• Kullanıcıdan PDF belgelerine sormak istediği sorular alınır. Bu adım, kullanıcının belgeleri hakkında bilgi edinmek istediği konuları belirtmesine olanak tanır.

6. Kullanıcı Sorularının Vektörlere Dönüştürülmesi

• Kullanıcının sorduğu soruları da vektörlere dönüştürmek zorundayız. Bu sayede soruları, yüklenen PDF’lerde bulunan metinlerle anlamsal yakınlık olarak karşılaştırabiliriz.

7. Semantik Arama ve Sonuçların Gösterilmesi

• Kelime vektörleri arasında semantik bir arama yaparak, kullanıcının sorusuyla ilgili benzer metinler bulunur. Bu benzer metinler, dil modeli kullanılıp sıralanarak kullanıcıya sunulur.

Bağımlılıkların Yüklenmesi

Proje kapsamında bazı bağımlılıkları kullanabilmek için önceden yüklemek gerekiyor. Bu bağımlılıklar ve amaçları şu şekildedir:

• streamlit: Grafiksel kullanıcı arayüzü oluşturabilmek
• PyPDF2: PDF dosyalarını okuyabilmek
• langchain: Dil modeliyle etkileşime girebilmek
• dotenv: OpenAI API anahtarını gizli bir şekilde kullanabilmek
• FAISS: Vektör deposu olarak kullanabilmek
• openai: OpenAI dil modeline erişim
• huggingface_hub: Dil modeli olarak OpenAI alternatifleri kullanabilmek

Bu bağımlılıkları pip kullanarak şu şekilde yükleyebilirsiniz;

pip install streamlit pypdf2 langchain python-dotenv faiss-cpu openai huggingface_hub

Proje

Projeye, gereken kütüphaneleri yüklemekle başlıyoruz.

import streamlit as st
from dotenv import load_dotenv
from PyPDF2 import PdfReader
from langchain.text_splitter import CharacterTextSplitter
from langchain.embeddings import OpenAIEmbeddings, HuggingFaceInstructEmbeddings
from langchain.vectorstores import FAISS
from langchain.chat_models import ChatOpenAI
from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationalRetrievalChain
from htmlTemplates import css, bot_template, user_template
from langchain.llms import HuggingFaceHub

get_pdf_textfonksiyonu, kullanıcının yüklediği PDF belgelerinden metinleri çıkarabilmek için kullanılır. Parametre olarak pdf_docs adında bir liste alır. Bu liste yüklenen PDF belgelerini içerir. Her bir PDF belgesini açar, her sayfadaki metni çıkarır ve bu metinleri birleştirerek tek bir metin haline getirir. Oluşturulan bu tek metni geri döndürür.

def get_pdf_text(pdf_docs):
    text = ""
    for pdf in pdf_docs:
        pdf_reader = PdfReader(pdf)
        for page in pdf_reader.pages:
            text += page.extract_text()
    return text

get_text_chunksfonksiyonu, bir metni daha küçük parçalara bölmek için kullanılır. Parametre olarak yukarıdaki fonksiyonda tek bir metin haline getirilen PDF metinlerini alır. Metni CharacterTextSplitter sınıfı sayesinde belirli bir boyutta küçük parçalara ayırır. Bu parçaların her birisine chunk denir.

def get_text_chunks(text):
    text_splitter = CharacterTextSplitter(
        separator="\n",
        chunk_size=1000,
        chunk_overlap=200,
        length_function=len
    )
    chunks = text_splitter.split_text(text)
    return chunks

get_vectorstorefonksiyonu, metin parçalarını embeddinglere dönüştürüp bir bilgi tabanı oluşturmak için kullanılır. Embedding işlemi için OpenAIEmbeddings kullanılır ve bu vektörleri içeren bir FAISS nesnesi oluşturulur. Embedding işlemi için HuggingFace üzerinden instructor-xl gibi ücretsiz modeller de kullanılabilir.

def get_vectorstore(text_chunks):
    embeddings = OpenAIEmbeddings()
    #for free embedding model;
    #embeddings = HuggingFaceInstructEmbeddings(model_name="hkunlp/instructor-xl")
    vectorstore = FAISS.from_texts(texts=text_chunks, embedding=embeddings)
    return vectorstore

get_conversation_chainfonksiyonu, sohbet zincirini oluşturmak için kullanılır. Parametre olarak vectorstore adında bir vektör kaynağı alır ve bu kaynak embedding vektörlerini içerir. Dil modeli olarak ChatOpenAI kullanılır ve bu dil modeli ile birlikte bir konuşma zinciri oluşturulur. Ayrıca, geçmiş sohbetleri saklamak için bir bellek (ConversationBufferMemory) oluşturulur.

Embedding için farklı alternatifler olduğu gibi, sohbet zinciri yaratırken de farklı dil modelleri alternatifleri vardır. OpenAI yerine, Google’ın flan-t5 modeli gibi modeller kullanılabilir.

def get_conversation_chain(vectorstore):
    llm = ChatOpenAI()
    # llm = HuggingFaceHub(repo_id="google/flan-t5-xxl", model_kwargs={"temperature":0.5, "max_length":512})

    memory = ConversationBufferMemory(memory_key='chat_history', return_messages=True)
    conversation_chain = ConversationalRetrievalChain.from_llm(
        llm=llm,
        retriever=vectorstore.as_retriever(),
        memory=memory
    )
    return conversation_chain

handle_userinputfonksiyonu, kullanıcının sorduğu soruya yanıt vermek için kullanılır. Parametre olarak user_question adında bir metin alır, bu metin kullanıcının sorduğu soruyu içerir. Konuşma zinciri nesnesi üzerinden kullanıcının sorusuna yanıt alınır. Alınan yanıtlar, kullanıcı ve bot mesajlarını içeren bir hafızaya eklenir. Sonuçlar, Streamlit tarafından oluşturulan arayüz üzerinde kullanıcıya gösterilir.

def handle_userinput(user_question):
    response = st.session_state.conversation({'question': user_question})
    st.session_state.chat_history = response['chat_history']

    for i, message in enumerate(st.session_state.chat_history):
        if i % 2 == 0:
            st.write(user_template.replace(
                "{{MSG}}", message.content), unsafe_allow_html=True)
        else:
            st.write(bot_template.replace(
                "{{MSG}}", message.content), unsafe_allow_html=True)

Fonksiyonlardan sonra arayüzü oluşturmaya, kontrolleri ve işlemleri gerçekleştirmeye başlayabiliriz.

Aşağıdaki adımlara geçmeden önce, OpenAI API anahtarını ana dosyada tutmak yerine .env isimli bir klasör açarak orada saklamanızı öneririm. Bu sayede anahtarı herkese açık bir şekilde paylaşmaktan kurtulabiliriz.
.env dosyası aşağıdaki gibi olacaktır:

OPENAI_API_KEY=<YOUR_OPENAI_API_KEY>
HUGGINGFACEHUB_API_TOKEN=<YOUR_HUGGINGFACE_API_TOKEN>

.env dosyasını oluşturup API anahtarlarınızı girdikten sonra ana dosyadan devam ediyoruz.

load_dotenv() ile API anahtarlarımıza erişiyoruz. Daha sonra sayfa başlığı ve simgesini ayarlayarak, oturumun durumunu kontrol ederek devam ediyoruz. Oturum durumu, Streamlit’in sayfayı yenileme isteğini kontrol etmemizi sağlar.

load_dotenv()
st.set_page_config(page_title="İçine atma")
st.write(css, unsafe_allow_html=True)

if "conversation" not in st.session_state:
    st.session_state.conversation = None
if "chat_history" not in st.session_state:
    st.session_state.chat_history = None

st.header("PDF'lerinizle Konuşun")

Kullanıcının sorularını girebileceği bir metin girişi alanı oluşturuyoruz. Kullanıcı bir soru girişinde bulunduğunda, bu soru handle_userinput fonksiyonuna iletiliyor.

user_question = st.text_input("Sorunuz: ")
if user_question:
    handle_userinput(user_question)

Bu bölümde, kullanıcının yüklediği PDF belgelerini işlemek ve sohbet zinciri oluşturmak için gerekli adımlar yer alıyor. Kullanıcı belgeleri yükledikten sonra “Isle” düğmesine tıklarsa, PDF’lerden metinler çıkarılır, metinler parçalara ayrılır, kelime vektörleri (embeddings) oluşturulur ve son olarak bir sohbet zinciri başlatılır.

with st.sidebar:
    st.subheader("Dökümanlarınız")
    pdf_docs = st.file_uploader(
        "PDF'lerinizi yükleyin ve 'İşle'ye basınız", accept_multiple_files=True)
    if st.button("İşle"):
        with st.spinner("İşleniyor"):
            raw_text = get_pdf_text(pdf_docs)
            text_chunks = get_text_chunks(raw_text)
            vectorstore = get_vectorstore(text_chunks)
            st.session_state.conversation = get_conversation_chain(
                vectorstore)

Dosyayı çalıştırmak için aşağıdaki kodun kullanılması yeterli olacaktır.

streamlit run app.py

PDF’ler ile bilgi çıkarımı Streamlit arayüzü ile birlikte hazır. Tüm projeyi Github reposunda bulabilirsiniz.

Okuduğunuz için teşekkür ediyorum. Soru ve görüşleriniz için aşağıdaki linklerden ulaşabilirsiniz:

LinkedIn: https://www.linkedin.com/in/ramazanolmez/
Mail: ramazanolmeez@gmail.com

· 1. Metin Sınıflandırma Nedir
· 2. Metin Ön İşleme Yöntemleri
· 3. Kelime Gösterim Teknikleri
· 4. Model Geliştirme Aşaması
∘ Gerekli Kütüphanelerin Yüklenmesi
∘ Veri Setinin Yüklenmesi
∘ Veri Setinin Hazırlanması
∘ FEED FORWARD NETWORK
∘ Convolutional Layer (Conv1D)
∘ LSTM
∘ BERT
· 5. Sonuç

1. Metin Sınıflandırma Nedir

Metin sınıflandırma, doğal dil işleme için klasik bir konudur. Metinleri kategorize etme veya etiketlerini içeriğine göre sınıflara ayırma işlemidir. Doğal dil işlemenin önemli alanlarından birisidir. Çünkü günün sonunda mailimize gelen bir e-postanın spam olup olmadığını incelemeden, filtrelenmiş bir şekilde görmek isteriz.

Bilgi çıkarımı, duygu analizi, tavsiye sistemleri, bilgi yönetimi, döküman özetleme, haber sınıflandırma, email sınıflandırma ve spam filtreleme gibi konularda birçok önemli uygulamaya sahiptir. Sağlık, sosyal bilimler, işletme, pazarlama ve hukuk gibi birçok sektörde sıklıkla kullanılır. Bu nedenle, birçok araştırmacı için bir cazibe kaynağı haline gelmiştir.

2. Metin Ön İşleme Yöntemleri

Metin sınıflandırma tekniklerine geçmeden önce metin verileri ile çalışmanın zorluklarının birkaçından bahsetmek istiyorum.

• Karmaşık ve anlamsal zorluk: Metin verileri, sayısal verilere göre karmaşık ve anlamsal olarak daha zengindir. Kelimelerin farklı bağlamlarda farklı anlamları olabilir, bu da modelin doğru bir şekilde anlam çıkarmasını zorlaştırabilir.
• Gürültü ve tutarsızlık: Veri setinde birçok yazım hatası (özellikle sosyal medya verilerinde), yanlış bilgiler ve argo ifadeler gibi gürültüler bulunabilir. Bunların temizlenmesi gerektiği durumlarda iş yükü artar.
• Dengesiz veri dağılımı: Eğitim verilerindeki sınıflar arasında dengesizlik olabilir. Bu da modelin yanlı davranmsına veya iyi öğrenememesine yol açar.

Bu zorlukların farkında olmak ve bunları azaltmak için önlemler almak, daha doğru ve güvenilir modeller geliştirmeye yardımcı olur. Metin verileri ile çalışmanın zorluklarını azaltan bazı teknikler:

• Tokenleştirme (Tokenization)
• Önemli bir anlam içermeyen kelimelerin kaldırılması (Remove Stop Words)
• Büyük harflerin dönüştürülmesi (Capitalization)
• Argo ve kısaltmaların veri setinden kaldırılması
• Noktalama işaretleri ve özel karakterler gibi gürültülerin kaldırılması
• Yazım hatalarını düzeltme (Spelling Correction)
• Kök çıkarma (Stemming)
• Kelimenin son ekinin çıkarılması (Lemmatization)

Bu tekniklerin hepsi uygulanmak zorunda değildir. Veri setinin durumuna ve ihtiyaca göre metin ön işleme adımı gerçekleştirilir.

3. Kelime Gösterim Teknikleri

Ön işleme adımından sonra çözülmesi gereken bir başka sorun metinlerin gösterimidir. Bilgisayarlar metin içindeki kelimeleri anlamak ve işlemek için sayısal bir temsil kullanırlar. Bu temsil, kelimelerin özelliklerini ve birbirleriyle ilişkilerini içeren bir matematiksel formül veya vektör olabilir. Bu temsile “Word Representation” denir. Bazı veri temsil yöntemleri:

• One-hot-encoding
• N-Gram
• Bag-of-Words (BoW)
• TF-IDF
• Word2Vec - GloVe - FastText
• Embedding Layer

Metin sınıflandırma için kullanılabilecek birçok farklı makine öğrenmesi temelli teknik vardır. Naive Bayes, SVM, KNN, Karar Ağaçları bu tekniklerden bazılarına örnektir. Yapılan araştırmalar bu algoritmaların çok iyi sonuçlar verdiğini göstermiş olsa da bu yazıda sinir ağları tabanlı yöntemler ile model geliştireceğim.

Sinir ağlarındaki en önemli özelliklerden biri, giriş verileri ne kadar kirli veya gürültülü olursa olsun, sinir ağının ağırlıkları doğru sınıf tahmin edilene kadar geri yayılım ile tekrar tekrar ayarlamasıdır.

4. Model Geliştirme Aşaması

Model eğitiminde, HuggingFace kütüphanesinde bulunan 10 farklı kategoriye sahip Türkçe “interpress_news_category_tr_lite” veri setini kullanacağım.

Gerekli Kütüphanelerin Yüklenmesi

import os
import sys
import csv
import warnings
import re
import string
import random
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

# Train Test Split and Metrics from sklearn
from sklearn.model_selection import train_test_split
from sklearn import metrics

# Tensorflow
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
from tensorflow.keras.layers.experimental.preprocessing import TextVectorization

# HuggingFace
from datasets import load_dataset
        
pd.set_option("max_colwidth", 400)

Veri setini yüklerken çalışma ortamınızda “field larger than field limit (131072)” hatasını alırsanız aşağıdaki bloğu da ekleyin.

csv.field_size_limit(sys.maxsize)
warnings.filterwarnings('ignore')

Veri Setinin Yüklenmesi

train_dataset = load_dataset("interpress_news_category_tr_lite", split="train")
test_dataset = load_dataset("interpress_news_category_tr_lite", split="test")

df_train = train_dataset.to_pandas()
df_test = test_dataset.to_pandas()
data = pd.concat([df_train, df_test], ignore_index=True)

data.drop_duplicates(subset='content', keep='first', inplace=True, ignore_index=True)

Veri kümesi HuggingFace ortamına train ve test olarak bölünüp 2 parça şekilde yüklenmiş. Ben bu bölme işlemini kendim yapmak istediğim için veri setini tek bir parça haline getiriyorum. Ayrıca birden fazla kez geçen metinlerin kaldırılma işlemini de bu aşamada gerçekleştiriyorum. Bir de veri setindeki her bir kategoride kaç örnek olduğuna bakalım.

unique_counts = data['category'].value_counts().reset_index()
unique_counts.columns = ['category', 'count']

plt.figure(figsize=(8, 8))
plt.pie(unique_counts['count'], labels=unique_counts['category'], autopct='%1.1f%%', startangle=90, colors=plt.cm.Set3.colors)

plt.title('Kategori Dağılımı')

plt.show()

Grafikte görüldüğü gibi veri setinin yaklaşık %50'si 2 kategoriden meydana geliyor. Veri setini bu şekilde kullanabilirdik. Ancak aşırı öğrenmeyi engellemek için kategorilerin birbirlerine yakın sayıda olmasını istedim. Bu sorunun data augmentation gibi çeşitli çözümleri olsa da, çok az sayıda olan kategorileri silmeyi tercih ettim.

delete_categories = [2, 3, 4, 5, 7, 9]
data = data[~data['category'].isin(delete_categories)]
data['category'].replace({0: 0, 1: 1, 6: 2, 8: 3}, inplace=True)

2, 3, 4, 5, 7, 9 numaraları kategorileri silerek model geliştirmeye 4 kategori ile devam ediyorum. Kafa karışıklığı yaratmaması için kalan kategorileri 0, 3 arasında numaralandırdım. Hazırlanan veri setinde kategoriler şu anlama geliyor:

• 0 -> Kültür-Sanat
• 1 -> Ekonomi
• 2 -> Teknoloji
• 3 -> Sağlık

Az sayıda örneğe sahip olan kategoriler silindikten sonra kalan 4 kategoriden birer örnek:

Küçük boyuttaki metin örnekleri genellikle daha az bilgi içerir ve bu da modelin genelleme yeteneğini sınırlayabilir. Bu tarz metinler cümlenin bağlamını anlamak için de yetersiz olabilir. Bu sebeplerden dolayı cümlelerdeki kelime sayısına göre bir filtreleme yaparak 50 den az kelimeden oluşan cümleleri veri setinden kaldırdım. Küçük boyuttaki metinler problem oluşturduğu gibi, çok büyük boyuttaki metinler de problem oluşturuyor. Bunları da veri setinden çıkartmaya karar verdim fakat bu işlemi şu aşamada değil, Embedding katmanında gerçekleştireceğim.

min_content_size = 50
data = data[data["words"] >= min_content_size]

Veri Setinin Hazırlanması

Modelde kullanacağımız sözlüğü oluşturma aşamasına geliyoruz. Fakat sözlüğü oluşturmadan önce data leakage’e uğramamak adına train-test bölme işlemini gerçekleştiriyorum. Veri setinin %80'lik kısmını eğitime, %20'lik kısmını teste ayırdım. Bu oranları kendi modelinize göre optimize edebilirsiniz.

features, targets = data["content"], data["category"]

train_features, test_features, \
train_targets, test_targets = train_test_split(
    features, 
    targets, 
    train_size=0.8, 
    test_size=0.2, 
    random_state=42, 
    shuffle=True, 
    stratify=targets
)

Büyük veri setlerini etkili bir şekilde işlemek ve eğitim sürecinde veriyi modele beslemek için uygun bir veri yapısı sağlanmalıdır. Bu gereksinimi TensorFlow veri seti oluşturarak çözüyorum. Verileri bu yapıya dönüştürmek;

• Çeşitli veri tiplerini kullanabilme esnekliği sağlar
• Bellek kullanımı ve eğitim süresini optimize etmeye yardımcı olur
• Batching, shuffling gibi işlemlerin kontrol edilmesini kolaylaştırır

train_text_ds_raw = tf.data.Dataset.from_tensor_slices(tf.cast(train_features.values, tf.string))
train_cat_ds_raw = tf.data.Dataset.from_tensor_slices(tf.cast(train_targets.values, tf.int64))

TensorFlow veri seti oluşturma işleminden sonra karar verilmesi gereken bir nokta, sözlüğün boyutudur. Sözlük boyutu, eğitimde kullanılacak kelime sınırıdır. Sözlük boyutunu en sık kullanılan 50000 kelime olarak belirledim. Sözlüğe eklenmeyen kelimeler <UNK> olarak gözükecektir. Bu sayı, veri setine ve donanım özelliklerine göre değişebilir. En uygun değer hiper parametre seçimi ile bulunabilir. Ayrıca, max_len parametresiyle belirlediğim maksimum kelime uzunluğu da önemlidir. Bu değer, her bir metin örneğinin kaç kelime içereceğini belirler. Örneğin, max_len’i 100 olarak belirlersek, her metin örneği en fazla 100 kelime içerecektir. Bu, modelin daha küçük veya daha büyük metin örnekleriyle çalışmasını sağlar. Ancak, bu değeri seçerken de veri setinin doğasını ve işlem süresini göz önünde bulundurmalıyız.

vocab_size = 50000
max_len = 500

Sözlük boyutu (vocab_size) ve maksimum uzunluğa (max_len) karar verdikten sonra sıra ön işleme aşamasına geldi. Bu adımda Keras TextVectorization kullanarak metni standart hale getireceğim. Keras TetxtVectorization, uçtan uca modeller oluşturabilmemizi ve bu modellere vereceğimiz giriş verilerini dönüştürebileceğimiz bir pipeline sağlar. Bunu yapabilmek için dekoratör yardımıyla aşağıdaki ön işlem adımlarını uyguluyorum.

@tf.keras.utils.register_keras_serializable()
def custom_standardization(input_string):
    uppercased = tf.strings.lower(input_string, encoding='utf-8')
    stars = tf.strings.regex_replace(uppercased, "\*", " ")
    html = tf.strings.regex_replace(stars, "<br />", "")
    digits = tf.strings.regex_replace(html, "\w*\d\w*","")
    punctuations = tf.strings.regex_replace(digits, f"([{string.punctuation}])", r" ")
    extra_space = tf.strings.regex_replace(punctuations, " +"," ")
    
    # Turkce karakterlere ozgu donusumler
    no_I = tf.strings.regex_replace(extra_space, "ı","i")
    no_O = tf.strings.regex_replace(no_I, "ö","o")
    no_C = tf.strings.regex_replace(no_O, "ç","c")
    no_S = tf.strings.regex_replace(no_C, "ş","s")
    no_G = tf.strings.regex_replace(no_S, "ğ","g")
    no_U = tf.strings.regex_replace(no_G, "ü","u")
    return no_U

custom_standardization() fonksiyonu, modeli veriler ile beslemeden önce önemli bir rol oynar. Tutarlılığı sağlamak ve gürültüyü azaltmak için bir dizi temizleme adımı uygular.

vectorize_layer = TextVectorization(
    standardize=custom_standardization,
    max_tokens=vocab_size - 1,
    output_mode="int",
    output_sequence_length=max_len,
)

vectorize_layer.adapt(train_text_ds_raw)

TextVectorization() katmanı ise, metni modelin anlayabileceği sayısal gösterimlere dönüştürmekten sorumludur. İki temel görevi yerine getirir:

• Metni düzenlemek için oluşturulmuş olan custom_standardization fonksiyonunu kullanarak metni standart hale getirir.
• Metni tokenlere böler ve her tokene eşsiz bir integer değer atar.

Kelime katmanı oluşturulduktan sonra adapt() fonksiyonu ile öğrenilmelidir. Burada TextVectorization uygularken sadece eğitim veri setine uyguladığımı belirtmek istiyorum. Veri sızıntılarından (data leakage) kaçınmak için hem eğitim hem test verisine uygulamamalıyız.

vocab = vectorize_layer.get_vocabulary()
vocab

En sık geçen 50000 kelimeden oluşan vocabulary’nin bir kısmı bu şekildedir.

Oluşturulan TextVectorization katmanı bir keras modeline aşağıdaki şekilde entegre edilir.

vectorizer_model = tf.keras.models.Sequential()
vectorizer_model.add(tf.keras.Input(shape=(1,), dtype=tf.string))
vectorizer_model.add(vectorize_layer)

Eğitim veri seti, hazırlanan metin verileri ve ilgili sınıf etiketleri ile birleştirilir.

def prepare_lm_inputs_labels(text):
    text = tf.expand_dims(text, -1)
    return tf.squeeze(vectorize_layer(text))

train_text_ds = train_text_ds_raw.map(
    prepare_lm_inputs_labels,
    num_parallel_calls=tf.data.experimental.AUTOTUNE
)

train_ds = tf.data.Dataset.zip((
    train_text_ds,
    train_cat_ds_raw
))

train_size = train_ds.cardinality().numpy()

Aynı işlemler test veri seti için de yapılmalıdır.

test_text_ds_raw = tf.data.Dataset.from_tensor_slices(
    tf.cast(test_features.values, tf.string)
)

test_cat_ds_raw = tf.data.Dataset.from_tensor_slices(
    tf.cast(test_targets.values, tf.int64)
)


test_text_ds = test_text_ds_raw.map(
    prepare_lm_inputs_labels,
    num_parallel_calls=tf.data.experimental.AUTOTUNE
)

test_ds = tf.data.Dataset.zip((
    test_text_ds,
    test_cat_ds_raw
))

test_size = test_ds.cardinality().numpy()

Artık eğitim ve test veri kümelerini yapılandırabilir ve optimize edebiliriz. Eğitim veri seti karıştırılarak, belirli bir boyuta batch’lenir, önbelleğe alınır ve performans artırımı için önceden yüklenir.

batch_size = 64
AUTOTUNE = tf.data.experimental.AUTOTUNE

train_ds = train_ds.shuffle(buffer_size=train_size)
train_ds = train_ds.batch(batch_size=batch_size,drop_remainder=True)
train_ds = train_ds.cache()
train_ds = train_ds.prefetch(AUTOTUNE)

test_ds = test_ds.shuffle(buffer_size=train_size)
test_ds = test_ds.batch(batch_size=batch_size,drop_remainder=True)
test_ds = test_ds.cache()
test_ds = test_ds.prefetch(AUTOTUNE)

desired_time_steps = 64
desired_feature_dim = 500

def reshape_data(x, y):
    x_reshaped = tf.reshape(x, (desired_time_steps, desired_feature_dim))
    return x_reshaped, y

train_ds = train_ds.map(reshape_data)
test_ds = test_ds.map(reshape_data)

Veri setinin giriş boyutları, reshape_data fonksiyonu ile belirli bir zaman adımı ve özellik boyutu için yeniden şekillendirilir.

FEED FORWARD NETWORK

İleri beslemeli ağ eğitimine başlamadan önce Keras Embedding katmanından biraz bahsetmek istiyorum. Bu katman, metin temsilini gerçekleştirmek için kullanılır. Embedding katmanı rastgele ağırlıklarla başlatılır. Farklı amaçlarla kullanımları mümkündür.

• Kaydedilip daha sonra başka bir modelde kullanılabilecek bir kelime yerleştirmeyi öğrenmek için tek başına kullanılabilir.
• Gömmenin modelin kendisi ile birlikte öğrenildiği derin öğrenme modelinin bir parçası olarak kullanılabilir.
• Bir tür transfer öğrenimi olan, önceden eğitilmiş bir kelime yerleştirme modelini yüklemek için kullanılabilir.

Embedding Layer kullanabilmek için 3 argüman belirmeliyiz:

• input_dim: Bu, metin verilerindeki kelime dağarcığının boyutudur. Örneğin, verileriniz 0–10 arasındaki değerlere kodlanmış tamsayı ise kelime dağarcığının boyutu 11 kelime olacaktır.
• output_dim: Bu, kelimelerin yerleştirileceği vektör uzayının boyutudur. Her kelime için bu katmandan çıkan çıktı vektörlerinin boyutunu tanımlar. Örneğin 50, 100 ya da daha büyük olabilir.
• input_length: Giriş dizilerinin uzunluğudur. Örneğin, giriş belgelerinizin tümü 1000 kelimeden oluşuyorsa bu 1000 olacaktır.

Ayrıca Embedding Layer 2 boyutlu bir vektör üreteceği için, doğrudan Dense katmanına bağlamak istiyorsak Flatten katmanını kullanarak çıktıyı tek boyutlu vektöre dönüştürmemiz gerekiyor.

Modeli donanım ve veri seti göz önüne alarak inşa etmeliyiz. Ben parametreleri küçük tutmaya özen gösterdim. Veri seti 4 kategoriye sahip olduğu için SparseCategorical kullandım. Aktivasyon ve optimizer gibi hiper parametreleri sık kullanılanlardan seçtim. Donanım ve veri setinize göre hiper parametreleri deneyerek en iyi sonuca erişebilirsiniz.

embed_dim = 4  # Embedding size
feed_forward_dim = 8  # Hidden layer size in FFN

def create_model_FFN():
    inputs_tokens = layers.Input(shape=(max_len,), dtype=tf.int32)
    
    embedding_layer = layers.Embedding(
        input_dim=vocab_size,
        output_dim=embed_dim,
        input_length=max_len
    )
    
    x = embedding_layer(inputs_tokens)
    x = layers.Flatten()(x)
    
    dense_layer = layers.Dense(feed_forward_dim, activation='relu')
    x = dense_layer(x)
    x = layers.Dropout(0.5)(x)
    
    outputs = layers.Dense(4)(x)

    model = keras.Model(inputs=inputs_tokens, outputs=outputs, name='model_FFN')
    loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
    metric_fn = tf.keras.metrics.SparseCategoricalAccuracy()
    
    model.compile(optimizer="adam", loss=loss_fn, metrics=metric_fn)
    return model

model_FFN = create_model_FFN()
model_FFN.summary()

1 Dropout ve 2 Dense layer kullanarak oluşturulan model aşağıdaki gibidir:

history = model_FFN.fit(train_ds, verbose=2, epochs=25)

25 epochtan sonra eğitim veri seti üzerinde 0.8921 başarı ortaya çıktı.

plt.plot(history.history['sparse_categorical_accuracy'])
plt.title('Feed Forward Network Accuracy')
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.legend(['train'], loc='upper left')
plt.show()

Model, test veri setinde ise 0.8883'lük bir başarı yakaladı.

loss, accuracy = model_FFN.evaluate(test_ds)
print("Test Dataset Accuracy: ", accuracy)

Fakat modelin başarısını bu değerlerle ölçmek bir hata olur. Modelin başarısını daha iyi yorumlayabilmek için sklearn metricleri altında bulunan classification report’u kullanmak daha faydalıdır.

preds = model_FFN.predict(test_ds)
preds = preds.argmax(axis=1)
actuals = test_ds.unbatch().map(lambda x,y: y)
actuals = list(actuals.as_numpy_iterator())

print(metrics.classification_report(actuals, preds, digits=4))

Convolutional Layer (Conv1D)

Evrişimsel sinir ağı (CNN), hiyerarşik belge sınıflandırması için yaygın olarak kullanılan bir derin öğrenme mimarisidir. Başlangıçta görüntü işlemek için oluşturulmuş olmasına rağmen, CNN’ler aynı zamanda metin sınıflandırması için de etkili bir şekilde kullanılmaktadır.

Evrişimsel ağları kullanırken bilinmesi gereken bazı parametreler şunlardır:

• filters: Çıktı uzayının boyutudur. Her bir filtre, öğrenilecek özellikleri belirler. Daha fazla filtre genellikle daha fazla özellik veya deseni öğrenme kapasitesi sağlar.
• kernel_size: Filtrenin bir adımda (stride) ne kadar veriyi kapsayacağını belirler. Örneğin, 3 verildiğinde her seferinde üç veriden bir grup alınır.
• strides: Filtrelerin giriş verisi üzerinde kaydırıldığı mesafe miktarını belirtir. Her adımda bir filtre belirli bir adım mesafesinde kayar ve öğreneceği özellikleri çıkarır.
• padding: Giriş verisi etrafına eklenen ek öğelerdir. Evrişim işlemi sırasında girişin boyutunu korumak veya çıkış boyutunu kontrol etmek için kullanılır. “valid” paddingde kenar dolgusu eklenmez ve giriş boyutu küçülür. “same” paddingde ise kenar dolgusu eklenerek çıkış boyutunun giriş boyutuna eşit olması sağlanır.
• activation: Her bir sinir hücresinin çıkışını belirler.

embed_dim = 4
feed_forward_dim = 8

def create_model_Conv1D():
    inputs_tokens = layers.Input(shape=(max_len,), dtype=tf.int32)
    
    embedding_layer = layers.Embedding(
        input_dim=vocab_size,
        output_dim=embed_dim,
        input_length=max_len
    )
    
    x = embedding_layer(inputs_tokens)
    x = layers.Conv1D(
        filters=32, kernel_size=7, 
        padding='same', activation='relu')(x)
    x = layers.Conv1D(
        filters=16, kernel_size=5, 
        padding='same', activation='relu')(x)    
    x = layers.MaxPooling1D(pool_size=2)(x)
    x = layers.Dropout(0.5)(x)
    x = layers.Flatten()(x)
    x = layers.Dense(feed_forward_dim, activation='sigmoid')(x)
    x = layers.Dropout(0.5)(x)

    outputs = layers.Dense(4)(x)
    
    model = keras.Model(inputs=inputs_tokens, outputs=outputs, name='model_Conv1D')
    loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
    metric_fn = tf.keras.metrics.SparseCategoricalAccuracy()
    
    model.compile(optimizer="adam", loss=loss_fn, metrics=metric_fn)
    return model

model_Conv1D = create_model_Conv1D()
model_Conv1D.summary()

Tek boyutlu 2 tane evrişimsel sinir ağı kullanılarak oluşturulan model aşağıdaki gibidir:

history = model_Conv1D.fit(train_ds, verbose=1, epochs=15)

15 epochtan sonra eğitim veri seti üzerinde %91.2'lik bir başarı ortaya çıktı. Model katman sayısı arttırılıp, daha fazla epoch boyunca eğitilseydi muhtemelen daha yüksek bir başarı sağlanırdı.

plt.plot(history.history['sparse_categorical_accuracy'])
plt.title('Conv1D Accuracy')
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.legend(['train'], loc='upper left')
plt.show()

Model, test veri setinde ise %90.6'lık bir başarı yakaladı.

loss, accuracy = model_Conv1D.evaluate(test_ds)
print("Test Accuracy: ", accuracy)

preds = model_Conv1D.predict(test_ds)
preds = preds.argmax(axis=1)
actuals = test_ds.unbatch().map(lambda x, y:y)
actuals = list(actuals.as_numpy_iterator())

print(metrics.classification_report(actuals, preds, digits=4))

LSTM

Temel RNN’ye kıyasla daha etkili bir şekilde uzun vadeli bağımlılığı koruyarak gradyan patlaması gibi sorunları gideren özel bir RNN türüdür. Model kuruluma geçmeden önce LSTM hakkında ufak bir bilgi vermek istiyorum.

• units: LSTM hücrelerinin sayısını belirten bir parametredir. Daha fazla hücre genellikle modelin daha karmaşık örüntüleri öğrenmesine yardımcı olabilir, ancak aynı zamanda daha fazla hesaplama gücü gerektirir.
• return_sequences: Eğer return_sequences=True olarak ayarlanırsa, her zaman adımındaki çıkışlar bir dizi olarak döner. Bu dizi, bir sonraki LSTM veya dense katmana giriş olarak kullanılabilir. Eğer return_sequences=False olarak ayarlanırsa, sadece en son zaman adımının çıkışını alırız.
• return_state: Eğer return_state=True olarak ayarlanırsa, fonksiyonun çıkışı, normal çıkış tensörünün yanı sıra LSTM hücrelerinin son durumlarını da içerir. Bu durumlar genellikle bir sonraki zaman adımına başlamak için başlangıç durumu olarak kullanılabilir.

embed_dim = 4
feed_forward_dim = 8

def create_model_LSTM():
    inputs_tokens = layers.Input(shape=(max_len,), dtype=tf.int32)
    
    embedding_layer = layers.Embedding(
        input_dim=vocab_size,
        output_dim=embed_dim,
        input_length=max_len
    )
    
    x = embedding_layer(inputs_tokens)
    x = layers.LSTM(64, return_sequences=True)(x)
    x = layers.Dropout(0.2)(x)
    x = layers.Dense(feed_forward_dim, activation='relu')(x)
    x = layers.GlobalMaxPool1D()(x)

    outputs = layers.Dense(4)(x)
    
    model = keras.Model(inputs=inputs_tokens, outputs=outputs, name='model_LSTM')
    loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
    metric_fn = tf.keras.metrics.SparseCategoricalAccuracy()
    
    model.compile(optimizer="adam", loss=loss_fn, metrics=metric_fn)
    return model

model_LSTM = create_model_LSTM()
model_LSTM.summary()

1 tane 64 unitli LSTM katmanı kullanarak oluşturulan mimari aşağıdaki gibidir:

history = model_LSTM.fit(train_ds, verbose=1, epochs=5)

Modeli 5 epoch ile eğitmemize rağmen eğitim setinde Conv1D’den daha iyi başarı gösterdiği gözükmektedir. %96.96'lık bir başarı gösterdi.

plt.plot(history.history['sparse_categorical_accuracy'])
plt.title('model_LSTM Accuracy')
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.legend(['train'], loc='upper left')
plt.show()

Model, test veri setinde ise %90.2'lik başarı gösterdi.

loss, accuracy = model_LSTM.evaluate(test_ds)
print("Test Accuracy: ", accuracy)

preds = model_LSTM.predict(test_ds)
preds = preds.argmax(axis=1)
actuals = test_ds.unbatch().map(lambda x,y: y)
actuals = list(actuals.as_numpy_iterator())

print(metrics.classification_report(actuals, preds, digits=4))

Modelin eğitim veri setinde gösterdiği başarıyı test veri setinde gösteremediğini görüyoruz. Bunun çeşitli sebepleri olabilir. Model mimarisi yanlış olabilir, daha hafif kurulabilirdi. Veri seti dengesiz veya az olabilir. Bu sorunların önüne veri setini düzenleyerek, model mimarisini tekrar gözden geçirerek, regularization ve çapraz doğrulama gibi teknikler kullanarak geçilebilir. Ayrıca LSTM yerine Bidirectional LSTM kullanılması model performansını yükseltecektir.

BERT

BERT (Bidirectional Encoder Representations from Transformers), Google tarafından geliştirilen ve doğal dil işleme çalışmalarında çığır açan bir dil modelidir. Bu model, önceki dil modellerinden farklı olarak, metin içindeki bağlamı anlamak için metni iki yönde (ileri ve geri) işleyen bir biçimde eğitilmiştir.

Model eğitim aşamasında simpletransformers kütüphanesini ve bert-base-turkish-uncased modelini kullanacağım.

Model eğitimine başlamadan önce gereken kütüphaneleri yüklüyoruz. Model eğitimi sırasında hata vermemesi için TensorFlow sürümünün 2.14 ve üzeri olmasına dikkat etmemiz gerekiyor, daha düşük sürümlerde hata veriyor (Siz bu yazıyı okurken güncellemeler gelmiş, sürümler değişmiş olabilir). Yükleme işlemlerinden sonra simpletransformers kütüphanesinden ClassificationModel ve ClassificationArgs sınıflarını çağırıyoruz.

!pip install simpletransformers
!pip install tensorflow==2.14

import tensorflow as tf
from simpletransformers.classification import ClassificationModel, ClassificationArgs

ClassificationArgs sınıfından bir örnek oluşturup, model eğiitminde kullanılacak çeşitli parametreleri ayarlıyoruz.

model_args = ClassificationArgs()

model_args.num_train_epochs = 5
model_args.max_seq_length=500
model_args.reprocess_input_data= True
model_args.overwrite_output_dir= True
model_args.train_batch_size= 64
model_args.fp16=False
model_args.output_dir= "bert_model"
model_args.learning_rate = 1e-4
model_args.no_save= True
model_args.save_eval_checkpoints=False
model_args.save_model_every_epoch=False
model_args.save_optimizer_and_scheduler=False

Türkçe BERT modeli
num_labels parametresi veri setindeki kategori sayısı yani çıkış sınıflarının sayısına eşit olmalı.

model_bert = ClassificationModel('bert', 
                                 'dbmdz/bert-base-turkish-uncased', 
                                 num_labels=4,
                                 args=model_args)

Diğer modellerde TextVectorization katmanında gerçekleştirdiğimiz veri ön işleme adımıını BERT’te modele veremiyoruz. Bu yüzden veri ön işleme adıımını bu aşamada ayrı bir şekilde yapmamız gerekiyor.

def custom_standardization(input_string):
    uppercased = tf.strings.lower(input_string, encoding='utf-8')
    stars = tf.strings.regex_replace(uppercased, "\*", " ")
    repeats = tf.strings.regex_replace(stars, "devamını oku", "")
    html = tf.strings.regex_replace(repeats, "<br />", "")
    digits = tf.strings.regex_replace(html, "\w*\d\w*","")
    punctuations = tf.strings.regex_replace(digits, f"([{string.punctuation}])", r" ")
    extra_space = tf.strings.regex_replace(punctuations, " +"," ")

    no_I = tf.strings.regex_replace(no_extra_space, "ı","i")
    no_O = tf.strings.regex_replace(no_I, "ö","o")
    no_C = tf.strings.regex_replace(no_O, "ç","c")
    no_S = tf.strings.regex_replace(no_C, "ş","s")
    no_G = tf.strings.regex_replace(no_S, "ğ","g")
    no_U = tf.strings.regex_replace(no_G, "ü","u")
    return no_U.numpy().decode("utf-8")

train_txt = train_features.apply(custom_standardization)
test_txt = test_features.apply(custom_standardization)

train = pd.concat([train_txt, train_targets], axis=1)
test = pd.concat([test_txt, test_targets], axis=1)

Veriler ön işleme adımından geçtikten sonra eğitim için hazır hale geldiler.

model_bert.train_model(train)

Tamamlanan eğitimin ardından modelin başarısını ölçmek için metriklere bakma vakti geldi.

result, model_outputs, wrong_predictions = model_bert.eval_model(test)
result

mcc (Matthews Correlation Coefficient), sınıflandırma problemlerinde performansı değerlendirmek için kullanılan bir istatistiksel ölçüdür. Doğruluk (accuracy), hassasiyet (precision) ve duyarlılık (recall) gibi metriklerin bir kombinasyonunu temsil eder.

eval_loss ise validation setinin hatasını temsil eder. Ancak bu modelde de olduğu gibi validation set kullanılmamışsa, hesaplamasını eğitim seti üzerinden gerçekleştirir.

from sklearn.metrics import  classification_report, accuracy_score

accuracy_score(actuals, predictions)
predictions = model_outputs.argmax(axis=1)
actuals = test_targets.values
accuracy_score(actuals, predictions)

print(classification_report(actuals, predictions, digits=3))

5. Sonuç

Feed Forward Neural, Conv1D, LSTM ve BERT modelleriyle gerçekleştirilen metin sınıflandırma çalışmamı anlatmaya çalıştım. Her bir modelin farklı hiper parametrelerle eğitildiği durumlar incelendiğinde, dikkat çekici sonuçların elde edildiğini düşünüyorum. Feed Forward Network modeli, basit ve hızlı eğitim süresiyle öne çıkarken, Conv1D modelinin text verileriyle de iyi çalışabileceğini deneyimledim. LSTM modeli, özellikle metinler arasındaki uzun vadeli bağlantıları yakalama konusunda başarılı olurken, BERT modeli genel olarak metin anlamını daha iyi kavradı.

Her modelin kendine özgü avantajları ve dezavantajları olduğunu göz önüne alarak, doğru model seçimi probleme bağlı olarak değişebilir. Eğitim süresi, model karmaşıklığı ve kullanılabilir veri miktarı gibi faktörler, hangi modelin en uygun olduğunu belirlemekte etkili olabilir. Ayrıca, hiper parametre ayarlamalarının her modelin performansını önemli ölçüde etkilediğini gözlemledim. Bu nedenle, spesifik bir görevde en iyi performansı elde etmek için detaylı bir hiper parametre optimizasyonu gereklidir. Son olarak geliştirilen modellerin sınıflandırma raporlarını paylaşmak istiyorum:

BERT’te, eğitim süresinin ve Colab RAM kullanımının uygun olması için toplam veri setinin %10'luk kısmı kullanılmıştır.

Ayrıntılı notebooka buradan ulaşabilirsiniz.

Okuduğunuz için teşekkür ediyorum. Soru ve görüşleriniz için;
Linkedin: https://www.linkedin.com/in/ramazanolmez/
Mail: ramazanolmeez@gmail.com
Github: https://github.com/rolmez

Kaynaklar:

1. https://www.youtube.com/c/muratkarakayaakademi
2. https://colab.research.google.com/drive/1eQydhzxK03z4_20_A9dunOq04trRYuZG?usp=sharing
3. Aggarwal, Charu C. Zhai, C. A SURVEY OF TEXT CLASSIFICATION ALGORITHMS
4. Amajd, M. Kaimuldenov, Z. Voronkov, I. Text Classification with Deep Neural Networks
5. https://machinelearningmastery.com/use-word-embedding-layers-deep-learning-keras/
6. Kowsari, K., Meimand, K., Heidarysafa, M., Mendu, S. Text Classification Algorithms: A Survey
7. Kamruzzaman, S. M. Text Classification using Artificial Intelligence
8. Gasparetto, A., Marcuzzo, M., Zangari, A., & Albarelli, A. (2022). A Survey on Text Classification Algorithms: From Text to Predictions
9. Ağduk, S., Aydemir, Emrah., Polat, Ayfer. Classification of News Texts from Different Languages with Machine Learning Algorithms

İçerik Tablosu

1. Giriş
2. Büyük Dil Modellerinde Halüsinasyon Nedir
3. Halüsinasyon Çeşitleri
4. Halüsinasyonların Nedenleri
5. Halüsinasyon Örnekleri
6. Halüsinasyonlar Nasıl Azaltılır / Yapılan Çalışmalar
7. Sonuç

1. Giriş

Son zamanlarda hızla gelişen bir teknoloji olan yapay zekanın son gelişmelerinden biri de Büyük Dil Modelleri’dir (LLMs). Bu modeller, doğal dilleri çevirebilen, çeşitli türde yaratıcı içerikler oluşturabilen, sorulara bilgilendirici bir şekilde cevap verebilen yapay zeka ürünleridir. Dil modellerinin büyük bir potansiyeli vardır. Bununla birlikte, halüsinasyon üretebilme gibi bir ihtimale de sahiptirler.

Bu yazıda, büyük dil modellerinde halüsinasyonun ne olduğunu, türlerini, nedenlerini, kaçınma yollarını ve son araştırmalar hakkında örnekleri ele alacağım.

2. Büyük Dil Modellerinde Halüsinasyon Nedir

PaLM, GPT ve LLaMA gibi büyük dil modelleri, çeşitli uygulamalar için akıcı ve tutarlı metinler üretebilen güçlü doğal dil işleme araçlarıdır. Büyük dil modellerinin önemli kusurlarından birisi, güvenilirliklerini etkileyen halüsinasyon üretme eğilimleridir.

LLM’lerdeki halüsinasyonlar, promptlarla alakasız, uydurma veya tutarsız içerik üretilmesi anlamına gelir. Geniş ve çeşitli veri kümelerine maruz kalmalarına rağmen, bu modeller çıktıları doğrularla ilişkilendirmek için tasarlanmamıştır. Örneğin, büyük bir dil modeli olarak bilinen ChatGPT’nin ana amacı, soruya anlamlı yanıtlar sağlamak için olasılıksal dağılım uygulamaktır. Model, maruz kaldığı bilgileri tutarlı bir şekilde birleştirmeye çalışır. Amacına ulaşabilmek için zaman zaman doğru bilginin ötesine geçebilir. Örneğin, bir dil modeline “Türkiye’nin başkenti” sorulduğunda, eğitildiği veri setinde bulunan hatalı bilgiden dolayı “İstanbul” yanıtını verebilir. Öngörülemezliği nedeniyle, LLM halüsinasyonları çeşitli sektörlerde yapay zeka uygulamalarını sekteye uğratabilir. Bu durum özellikle hukuk, sağlık ve finans gibi gerçeklere dayalı sektörlerde olumsuz sonuçlara yol açabilir.

LLM’leri etkili bir şekilde kullanmak için bu halüsinasyonları anlamak önemlidir. Sınırların farkına varmamızı sağlar ve yapay zeka teknolojilerinin hem potansiyelini hem de zorluklarını anlamamızda önemli rol oynar.

Vectara tarafından yapılan bir çalışmada dil modellerinde halüsinasyon oranları şu şekilde bulunmuştur:

3. Halüsinasyon Çeşitleri

LLM halüsinasyonları, her biri kendine özgü özelliklere ve sonuçlara sahip belirli türlere ayrılabilir. Bu ayrım, kullanıcıların farklı halüsinasyon senaryoları tanımlamasına ve ele almasına yardımcı olur.

3.1. Factuality Hallucinations:

Bu durum, modelin yanlış içerik üretmesidir. Örneğin, bir model yüzölçümü en büyük ülkenin Çin olduğunu (Doğru cevap Rusya’dır) iddia edebilir ki bu olgusal bir hatadır.

Gerçeklik halüsinasyonunu da (Factuality Hallucination) kendi içerisinde 2'ye ayırabiliriz.

• Factual Inconsistency: Bu halüsinasyon çeşidi, modelin eğitim aldığı veri setinde bulunan çelişkili veya tutarsız bilgileri nedeniyle gerçeklikle uyuşmayan metinler üretmesidir. LLM, Yuri Gagarin’in Ay’a inen ilk kişi olduğunu söyleyebilir (doğru cevap Neil Armstrong’dur).

• Factual Fabrication: Modelin eğitim aldığı veri setinde bulunmayan tamamen uydurma bilgiler üretmesi de bir başka halüsinasyon çeşididir. Örneğin, bir büyük dil modeline “Shakespeare’in son oyununun adı neydi?” diye sorulduğunda, model, aslında var olmayan bir oyun için uydurma bir isim veya özet verebilir.

3.2. Faithfulness Hallucinations:

Bunlar, modelin sadakatsiz içerik ürettiği veya sağlanan kaynağın içerikle tutarsız olduğu durumlardır. Örneğin, bir makalede BioNTech’in Covid-19 aşısını onayladığı belirtiliyorsa, bir sadakat halüsinasyonu, FDA’nın bunu reddettiğini (intrinsic hallucination) veya Çin’in bir COVID-19 aşısını test etmeye başladığını (extrinsic hallucination) iddia eden bir metin içerecektir.

Bu halüsinasyonlar üç türe ayrılabilir:

• Instruction Inconsistency: Model, kullanıcı tarafından verilen özel talimatları göz ardı eder. Modelden bir metni Türkçe’ye çevirmesini istediğimizde, cevabı İngilizce olarak vermesi buna bir örnektir.
• Context Inconsistency: Model çıktısı, sağlanan promptta mevcut olmayan veya onunla çelişen bilgiler içerir. Kullanıcının Türkiye ile ilgili bir sorusunda, modelin bunu Almanya olarak iddia etmesi bu duruma bir örnektir.
• Logical Inconsistency: Modelin çıktısı doğru başlamasına rağmen mantıksal bir hata içerir. Örneğin, adım adım matematik çözümünde bir aritmetik işlemi yanlış gerçekleştirir.

4. Halüsinasyonların Nedenleri

Dil modellerinin halüsinasyon görmesinin nedenleri, karmaşık ve çeşitlidir. Bu nedenler arasında eğitim veri setindeki hatalar veya tutarsızlıklar, modelin yapısı, kullanılan algoritmalar gibi unsurlar yer alabilir. LLM’lerin halüsinasyon görmesi bir sorundur ve nedenleri anlaşılmalıdır. Bu sorunun anlaşılması, modellerin güvenilirliğini ve kullanılabilirliğini artırmaya yardımcı olacaktır. Başlıca halüsinasyon nedenleri:

• Eğitim Verisi: Büyük dil modelleri, geniş ve çeşitli eğitim verileri ile eğitilen kapsamlı bir öğrenme sürecinden geçer. Bu veriler, çeşitli kaynaklardan toplanmıştır, bu da doğrulamayı son derece zorlaştırır. Çünkü verilerin adil, tarafsız ve gerçeklere dayalı olup olmadığını belirlemek oldukça uzun bir süreçtir. Dil modeli, gerçeği kurgudan ayırt edemez ve bazı eğitim verileri yanlı veya öznel görüşler içerir. Bu da modelin gerçeğe ulaşma ihtimalini zorlaştırır. Model sadece eğitim sırasında öğrenilen kalıpları kullanarak olası çıktıları bir araya getirir.
• Amaca uygun olmayan model kullanımı: LLM’ler, belirli görevler için açıkça eğitilmediklerinde rastgele halüsinasyonlara eğilimlidirler. GPT gibi büyük dil modelleri, genel doğal dil işleme görevleri için eğitilmiştir. Ancak, özel alanlardaki (örneğin tıp, hukuk ve finans gibi) konulara odaklanmadıkları için bu modellerin doğru çıkarımlar yapma konusunda yardıma ihtiyaçları olabilir. Bu modeller, belirli promptlara dayalı olarak görünüşte tutarlı bir anlatı oluşturabilir, ancak halüsinasyonlara eğilim gösterebilirler. Aşağıdaki resimde belirli görevler için eğitilmiş bazı dil modelleri görülmektedir.

• Prompt Mühendisliği: Promtlar, modellere belirli görevleri yerine getirmesi için talimat verme araçlarıdır. Dil modellerini kullanmak için kullanıcılar promt olarak metin girerler. Bu işlem kodlamaya benzer, ancak programlama dillerinin aksine, basit yazım dili kullanılır. Modellerden istenilen çıktılar konusunda net olmak önemlidir. Model daha sonra promtlara uygun bir yanıt oluşturur. Ancak, promptlar yeterli olmadığında modeller tutarlı davranmayabilir. Prompt, istenilen konu akışından yoksunsa, LLM yanlış bir yanıt veya kullanıcının aramadığı tamamen farklı bir yanıt üretebilir.

• Model mimarisi: Halüsinasyonlar model mimarisindeki kusurlardan veya optimal olmayan eğitim hedeflerinden de kaynaklanabilir. Örneğin, bir model yanlış mimariyle kurgulanmış olabilir veya hatalı kod çözme (decoding) stratejileri yürütülmüş olabilir. Veya bazı durumlarda, LLM'ler daha uzun çıktılar gibi belirli sonuçlar için optimize edilir, bu da ayrıntılı ve alakasız yanıtlara yol açabilir.
• Stokastik yöntemler: LLM'ler metin üretirken, çıktıya rastgelelik katabilecek stokastik stratejileri kullanır. Örneğin, model kurgulanırken yüksek bir “sıcaklık” (temperature) değeriyle eğitilmiş olabilir. Bunun modelde yaratıcılık gibi pozitif tarafları olsa da, halüsinasyon üretebilme riskini artırabilir. Bu stokastik yöntemler yüzünden model çıktıları bazen beklenmedik veya anlamsız yanıtlar oluşturur.

5. Halüsinasyon Örnekleri

Halüsinasyon konusunda son zamanlarda bazı feci sonuçlar görüldü. Bu tür olaylar yapay zeka teknolojilerine olan güveni önemli ölçüde azaltabileceği gibi ciddi mesleki ve yasal sonuçlara da yol açabilir. Halüsinasyonlardan kaynaklanan yanlış bilgiler, karar alma süreçlerini etkileyebilir.
Halüsinasyonlardandan doğan bazı kötü örnekler:

1. New York Times yaptığı bir çalışmada, ChatGPT’nin kendileri hakkında yanlış bilgiler verdiğini keşfetti. Dil modeli, var olmayan bir makaleye atıfta bulunmuştu. Gazeteciler başka halüsinasyon örneklerine de rastladılar. Yapay zeka tarafından oluşturulan sohbet robotlarına güvenmenin riskli olabileceğini vurguladılar. (Source)
2. İki avukat, davalarında ChatGPT sonuçlarını araştırmadan kullanarak büyük bir hata yaptılar. Bu avukatlar, davalarına benzer emsaller bulmak için ChatGPT’yi kullandılar. Fakat GPT’nin sadece dil modeli olduğunu, doğru bilgi verme zorunluluğu bulunmadığını atlayıp buldukları sonuçları araştırmadan mahkemeye sundular. Alıntıladıkları davalardan altısı sahte çıktı. Bu, durum mahkemenin yaptırımlarına yol açtı. (Source)
3. Yakın zamanlı bir raporda ChatGPT, ABD’li bir hukuk profesörünün cinsel suçlu olarak suçlandığını iddia etti. Bu iddiada var olmayan bir Washington News raporunu kaynak olarak gösterdi. Böyle suçlamaların bıraktığı iz düşünülünce, olayın ciddiyeti daha net anlaşılıyor. (Source)

6. Halüsinasyonlar Nasıl Azaltılır / Yapılan Çalışmalar

LLM’lerde halüsinasyonları azaltmak için geri bildirim mekanizmalarından, yapılandırılmış girdi/çıktı mekanizmalarına kadar önerilen birçok teknik vardır. “A Comprehensive Survey of Hallucination Mitigation Techniques in Large Language Models” makalesinde yazarlar, 2 ana grupta 32 yeni halüsinasyon azaltma tekniğini değerlendirdiler. Bunlardan kısaca bahsetmek istiyorum:

6.1. Prompt Engineer:

Dil modellerinde en iyi çıktıyı elde etmek için çeşitli promptları deneme/yanılma sürecidir. Bu süreç beklenen çıktıyı iyileştirebilir ve halüsinasyonu önemli derecede azaltabilir. Araştırmacılar bu süreci 3 farklı gruba ayırıyor.

6.1.1. Retrieval Augmented Generation (RAG):

Retrieval Augmented Generation (RAG) yöntemi, modelin eğitildiği veri seti haricinde güvenilir bir bilgi tabanına başvurur. Bu sayede modeli güncel bilgiler ile besleyebilir, model üzerinde daha fazla denetime sahip olunabilir. Dil modellerinin güçlü taraflarını, yeniden eğitmeye gerek duymadan belirli alanlarda genişletir. Yeniden eğitime gerek duymamasından dolayı uygun maliyetli bir yaklaşımdır. Araştırmacılar bu yaklaşımı da kendi içerisinde 4 gruba ayırarak (çıktı üretiminden önce, çıktı ürecim sırasında, çıktı üretimi sonrasında, uçtan uca), detaylı bir şekilde incelemişler.

• Before Generation: Bu yaklaşımdaki yöntemler, yapay zeka metninin oluşturulmasından önce gerçekleşir. “LLM-Augmenter” ve “FreshPrompt” bu yaklaşıma örnek iki çalışmadır.
• During Generation: Bu yaklaşımdaki yöntemler, model her cümleyi oluştururken denetim mekanizmasında gerçekleşir. Bu denetim mekanizması, cümle-cümle şeklinde meydana gelir. Bu yönteme örnek olarak “Knowledge Retrieval”, “Decompose-and Query framework (D&Q)” ve “EVER” adlı yöntemler gösterilebilir.
• After Generation: Bu kategori altındaki yöntemler, çıktının tamamı oluştuktan sonra RAG sistemini kullanır. “RARR” ve “High Entropy Word Spotting and Replacement” çalışmaları bu kategori altında incelenmiştir.
• End-to-end: Uçtan uca RAG, önceden eğitilmiş bir diziden diziye (seq2seq) transformerın, Dense Passage Retriever (DPR) aracılığıyla elde edilen Wikipedia’nın yoğun bir vektör dizini ile entegre edilmesini içerir. Bu kombinasyon, modelin çıktı üretimini hem girdi sorgusu hem de DPR tarafından sağlanan gizli belgeler üzerinde koşullandırmasına olanak tanır. Bu yöntem, modellerin performansını önemli ölçüde artıran bir yaklaşımdır. Bu yaklaşım, çeşitli bilgi yoğun görevlerde gelişmiş performans sağlar ve üretim modellerinde parametrik ve parametrik olmayan belleği birleştirmenin etkinliğini gösterir.

6.1.2. Self-Refinement through Feedback and Reasoning:

Bir LLM belirli bir prompt için bir çıktı sağladıktan sonra, çıktının uygunluğu ölçülerek veya insanlar tarafından sağlanan geri bildirim sayesinde, sonraki yanıtlarında daha iyi ve daha doğru çıktılar üretilmesi sağlanabilir. Önceki çalışmaların aksine, denetimli veri veya takviyeli öğrenme gerektirmez. Bu yaklaşımda, “Prompting GPT-3 To Be Reliable”, “ChatProtect”, “Self-Reflection Methodology”, “Mind’s Mirror”, “DRESS”, “MixAlign”, “CoVe” ve “ConLI” gibi araştırmalar bulunmaktadır.

Örneğin CoVe bir kullanıcı sorgusu verildiğinde, gerçek halüsinasyonlar gibi yanlışlıklar içerebilecek bir temel yanıt üretir. Önce sorulacak doğrulama soruları oluşturur, ardından kontrol etmek için bunları yanıtlar. Aşağıdaki 4 adımı takip eder:
- Bir ilk yanıt taslağı hazırlar
- Taslağın doğruluğunu kontrol etmek için doğrulama soruları planlar
- Cevapların doğru olması için bu soruları bağımsız olarak yanıtlar
- Doğrulanmış bir yanıt oluşturur

6.1.3. Prompt Tuning:

Modeli belirli görevlerde daha etkili hale getirmek için fine-tune (ince ayar) aşamasında önceden eğitilmiş bir dil modeline sağlanan talimatların ayarlanmasını içeren teknik olarak tanımlanır. Burada model sabit yönergeler kullanmaz, bunun yerine ince ayar sırasında ağırlıkları ayarlayarak bunları modelin kendisi öğrenir. “UPRISE” ve “SynTra” önerilen teknikler arasındadır.

6.2. Developing Models:

İkinci ana yöntem kategorisi, model geliştirilmedir. Bu yöntemin amacı, model çıktılarını ayarlamak veya mevcut modellere ince ayar yapmak yerine, halüsinasyonlarla doğal olarak başa çıkmak için özel olarak tasarlanmış yeni model mimarileri uygulamak olan aktif bir araştırma alanıdır. Bu yöntem kendi içerisinde 4 gruba ayrılabilir:

6.2.1. Introducing New Decoding Strategy:

Kod çözme stratejileri, özellikle bir modelin üretim aşamasını hedefleyen tekniklerin geliştirilmesini içerir. Bu teknikler dil modeline uygulandığında, cevap üretim aşamasını gerçek veya bağlama özgü üretime yönlendirerek üretilen çıktılardaki halüsinasyonları önleyebilir. “CAD”, “DoLa” ve “Inference-Time Intervention (ITI)” bu yaklaşıma örnek yöntemlerdir.

6.2.2. Utilization of Knowledge Graph:

Wikidata gibi bilgi grafikleri, gerçek dünya varlıkları (örneğin insanlar, kuruluşlar veya ürünler) hakkında bilgilerin yanı sıra bunların özelliklerini ve grafikteki diğer varlıklarla bağlantılarını içeren organize veri koleksiyonlarıdır. Büyük Dil Modelleri için akıl yürütme, veri analizi ve bilgi erişimi gibi konularda güvenilir bir bilgi kaynağı oluştururlar. “RHO” ve FLEEK araştırmaları bu yöntemi kullanan projelere örnek olarak verilebilir.

6.2.3. Introducing Faithfulness based Loss Function:

Bu yöntemlerin amacı, modelleri eğitim sırasında temel gerçek verilerle eşleşmeye daha fazla zorlayabilen yeni ölçütler tasarlamaktır. Bu bağlamda, sadakat; modelin hatalar, eksiklikler veya çarpıtmalar eklemeden prompttan gelen verileri sadık ve düzgün bir şekilde yansıtma kapasitesi olarak tanımlanmaktadır. “THAM Framework” ve “Loss Weighting Method” bu kategoride değerlendirilebilir.

6.2.4. Supervised Finetuning:

SFT, etiketli verileri kullanarak LLM’leri hizalamak için iyi bilinen bir tekniktir, bu nedenle modelin belirli görevler için insan komutlarını izlemesini ve sonunda sadakatini artırmasını sağlar. Popüler yaklaşımlar arasında “Knowledge Injection and Teacher-Student Approach”, “HAR”, “Fine-tuning Language Models for Factuality”, “BEINFO”, “R-Tuning” ve “TWEAK” yer alır.

7. Sonuç

Halisünasyonlar, büyük dil modellerinin karşılaştığı önemli bir sorundur. Bu yazıda bu olguların anlaşılması ve azaltılması üzerine yapılan çalışmalara odaklandım. Halüsinasyonları azaltmak adına atılan her bir yaklaşım farklı noktalara dokunuyor olsa da, hepsi tek bir hedefe sahiptir; büyük dil modellerinde çıktı kalitesini iyileştirmek. Ayrıca halüsinasyon olgusunun değerlendirilmesi ve ölçülmesi zordur ve halüsinasyonların etik ve sosyal etkileri hala araştırılmaktadır.

Okuduğunuz için teşekkür ediyorum.

Görüşleriniz için:
LinkedIn: https://www.linkedin.com/in/ramazanolmez/
Mail: ramazanolmeez@gmail.com

Kaynakça:

1. Tonmoy, S.M Towhidul Islam., vd. (2024). A Comprehensive Survey of Hallucination Mitigation Techniques in Large Language Models
2. Dahl, Matthew., vd. (2024). Large Legal Fictions: Profiling Legal Hallucinations in Large Language Models
3. Lei, Huang., vd. (2023). A Survey on Hallucination in Large Language Models: Principles, Taxonomy, Challenges, and Open Questions
4. Gallegos, Isabel O., vd. (2023). Bias and Fairness in Large Language Models: A Survey
5. Dhuliawala, Shehzaad., vd. (2023). Chain-of-Verification Reduces Hallucination in Large Language Models
6. https://www.lakera.ai/blog/guide-to-hallucinations-in-large-language-models
7. https://kili-technology.com/large-language-models-llms/understanding-llm-hallucinations-and-how-to-mitigate-them
8. https://generativeai.pub/how-to-mitigate-hallucinations-in-large-language-models-llms-0b8559b00d04
9. https://machinelearning.apple.com/research/gender-bias-llm
10. https://machinelearningmastery.com/a-gentle-introduction-to-hallucinations-in-large-language-models/
11. https://medium.com/mlearning-ai/3-llm-architectures-f527ed781ba9
12. https://github.com/vectara/hallucination-leaderboard

Bu yazının bir kısmı metin özetlemenin geçmişten günümüze tarihini anlatmakta ve bazı mimarileri (seq-to-seq, transformers, vb.) kısaca tanıtmaktadır. Buraları atlamak istiyorsanız, içindekiler bölümünden direkt model kurulum aşamasına erişebilirsiniz.

Table of Contents

1. Giriş
2. Metin Özetlemenin Kısa Tarihçesi
3. Metin Özetleme Metotları
4. Extractive Method vs Abstractive Method
5. Seq2seq, Attention, Transformers ve T5
6. Google T5 Dil Modeli ile Metin Özetleme

A. Giriş

Doğal dil işleme (NLP), bilgisayar bilimi, dil bilim ve yapay zekayı birleştiren bir alandır. Bu alandaki önemli uygulamalardan biri de metin özetlemedir.

Metin özetleme, bir metnin veya dokümanın ana fikrini koruyarak, daha kısa bir biçimde ifade etme işlemidir. Bu karmaşık süreç, asıl metni anlamayı, önemli bilgileri seçmeyi, korumayı ve özetlemeyi içerir.

Metin özetleme, günümüzde birçok endüstri tarafından kullanılmaktadır. Sigorta, hukuk, habercilik, eğitim ve araştırma gibi sektörlerde yaygın olarak uygulanmaktadır. Özellikle büyük belgelerle uğraşırken, bu belgelerin tamamını taramak zaman alıcı ve verimsiz bir süreç olabilir. Metin özetleme, belgelerin kısaltılmasına yardımcı olarak arama işlemlerini hızlandırabilir.

Metin özetleme, doğal dil işleme alanındaki gelişmelerden önemli ölçüde yararlanmıştır. Yapay zeka ve makine öğrenimi gibi teknolojilerin gelişimi, uygulamaların daha doğru ve etkili hale gelmesini sağlamıştır. Fakat bu günlere gelene kadar bir sürü yenilikler geçmiş, farklı yaklaşımlar üzerine çalışılmıştır. Bu nedenle, T5 ile metin özetleme modeli geliştirmeden önce, bu alandaki gelişimlere kısa bir göz atmak faydalı olabilir.

B. Metin Özetlemenin Kısa Tarihçesi

1950 ve 1960'lı Yıllar / Deneysel Yaklaşımlar:

İlk metin özetleme çalışmaları, 1950'li yıllarda başlamıştır. Bu yıllardaki çalışmalar, cümlelerin çeşitli özelliklerini hesaplayarak ve bu özellikleri kullanarak cümlelerin önemini belirlemeye odaklanmıştır. Kelime sıklığının yeterli olmadığı anlaşılınca, cümlenin belge içindeki konumunu hesaba katan yöntemler geliştirilmeye çalışılmıştır. Ancak bu dönemdeki sınırlı donanım nedeniyle istenilen sonuçlara ulaşılamamış, bu durum metin özetleme çalışmalarını bir süre için duraklatmıştır.

1970 ve 1980’li Yıllar / Rasyonalist Yaklaşımlar:

1960'lı yıllarda araştırmacılar, metnin anlamını anlayarak özetlemeye odaklanmaya başlamıştır. Metindeki önemli bilgileri belirlemek için komut dosyaları, FRUMP ve SUSY gibi yaklaşımları kullandılar. Ancak, bu yaklaşımların da elle kodlanmış bilgilere ve alana özgü bilgiye ihtiyaç duyduğu görülmüştür. Yani, bu metodolojilerin kullanımıyla elde edilen sonuçlar, spesifik bilgiye dayandığı için genellikle belirli bir alanda etkili olabiliyordu. Bu durum, metin özetleme süreçlerini daha geniş kapsamlı ve genel kullanıma uygun hale getirmek adına yeni yöntem ve stratejilerin geliştirilmesini teşvik etmiştir.

1990’lı Yıllar / Deneysel Yaklaşıma Geri Dönüş:

1990'ların ortalarında, 50'li ve 60'lı yıllardaki deneysel yaklaşıma dönüş yaşanmış, ancak bu sefer daha gelişmiş bir seviyede gerçekleşmiştir. Araştırmacılar, verilerden otomatik olarak elde edilen buluşsal yöntemlere değil, kendi kodladıkları prosedürlerle bilginin önemini belirlemeye yönelmişlerdir. Temel cümle analizi, konsept analizi gibi yaklaşımları benimsemişler ve çalışmaları daha öncekilerden farklı bir perspektife taşımışlardır.

2000'li Yıllar / Makine Öğrenimi Tabanlı Yaklaşımlar:

2000'li yıllarda, metin özetleme çalışmaları, yapay zeka alanındaki gelişmelerden önemli ölçüde yararlanmıştır. Bu dönemde, makine öğrenimi algoritmaları kullanılarak, daha iyi özetler oluşturulmuştur. Veri depolama ve işleme teknolojilerindeki gelişmeler, makine öğrenimli metin özetleme yöntemlerinin daha yaygın bir şekilde kullanılmasını sağlamıştır. Bu dönemde özetleme çalışmalarını iyileştirebilmek için Bayes Sınıflandırıcı, Karar Ağaçları, Saklı Markov Modelleri gibi çeşitli istatistiki modellerin hemen hemen hepsi denenmiştir.

2015’li yıllar ve günümüz / Derin Sinir Ağları Tabanlı Yaklaşımlar:

Geleneksel makine öğrenimi yaklaşımlarının 2000'li yıllarda getirdiği iyileştirmelere rağmen, 2015 yılında derin öğrenme temelli sinirsel yaklaşımlar metin özetleme alanında önemli bir dönüm noktası oldu. Derin öğrenme tabanlı sinir ağları, karmaşık ilişkileri çıkararak verilerdeki kalıpları bulabilen doğrusal olmayan istatistiksel veri modelleme araçlarıdır. Özellikle bu dönemde, seq2seq kullanılarak yapılan metin özetlemelerinde, RNN, LSTM gibi modellerin katkısıyla büyük ilerlemeler kaydedildi. Bu modeller, metnin giriş ve çıkışını bir dizi sayısal değer olarak temsil ederek, metnin özetini oluşturmaktadır. Ayrıca, Transformer yapısının ortaya çıkmasıyla birlikte NLP görevlerinde geniş kapsamlı bir ilerleme yaşandı. Bu evrimle birlikte, BERT, GPT, PEGASUS, T5 gibi güçlü ve çok yönlü modeller geliştirildi, metin özetleme alanında yeni standartlar belirlendi.

C. Metin Özetleme Metotları

Metin özetlemenin geçmişten günümüze gelişimine genel bir bakış attık. Geçmişten günümüze gelen çalışmalar sırasında metnin özetini oluşturmak için kullanılan farklı yaklaşımlar vardır. Bu yaklaşımlar, metnin özetlenme amacına, hedef kitleye ve özetin uzunluğuna göre değişiklik gösterebilir. Başlıca yaklaşımlar şu şekildedir:

1. Single document vs multi-document
2. Generic vs User-Focused
3. Indicative vs Informative
4. Language of Summarizer
5. Extracts vs Abstracts

Bu yaklaşımların arasında özellikle extracts vs abstracts yaklaşımı, metin özetleme pratiğinde belirgin bir ayrım sağlar.

D. Extractive Method vs Abstractive Method

Extractive summarization (Çıkarımsal özetleme); metin içerisinden önemli cümleleri ve paragrafları çıkararak özet oluşturma işlemidir. Bir belgedeki her cümleye, belgedeki diğer tüm cümlelerle olan ilişkisine göre bir puan atanır. Puanlama, kullandığınız modele/kütüphaneye bağlı olarak farklı olabilir. En yüksek puanları alan cümleler birlikte belgenin özetini oluşturur.

Abstractive summarization (Özetleyici özetleme); orijinal metnin anlamını anlayarak yeni ve özgün bir özet oluşturma yöntemidir. Bu yöntem, metnin ana fikrini ve önemli ayrıntılarını yakalamak için metni yeniden yazar. Extractive özetlemenin aksine, daha yaratıcı bir yaklaşım benimser ve özgün bir dil kullanarak metni daha kısa bir şekilde ifade etmeye çalışır.

Her iki yöntemin de avantajları ve dezavantajları vardır. Extractive, orijinal metinde bulunan önemli bilgileri koruma eğilimindeyken, abstractive daha özgün ve esnek bir özetleme sağlar. Bu yazı bağlamında, özetleyici özetlemeye (abstractive summarization) bir örnek olarak T5 modeli ile çalışacağız.

E. Seq2seq, Attention, Transformers ve T5

Metin özetleme konusunda daha derin bir anlayış oluşturabilmek için sequence-to-sequence, attention, transformers ve T5 gibi büyük dil modelinden de kısaca bahsetmek istiyorum.

Sequence-to-sequence:

• Seq2seq, sinir ağı öğreniminde sıralı girdiyi kabul eden bir sinir ağıdır. Bu bir RNN olabileceği gibi bir CNN ya da başka bir mimari de olabilir.
• Özellikle çeviri, özetleme, üretken soru yanıtlama ve sınıflandırma gibi doğal dil işleme görevlerinde kullanılır
• Encoder-Decoder yapısını temel alır, giriş verisini anlamak için bir “encoder” ve çıkış verisini üretmek için bir “decoder” içerir.

Attention:

• Attention, derin öğrenme modellerinde kullanılan ve girdinin farklı kısımlarına farklı ağırlıklar atayarak modelin çeviri veya özetleme gibi görevleri yerine getirirken en önemli bilgilere öncelik vermesini ve bunları vurgulamasını sağlayan bir mekanizmadır.
• Özellikle uzun metinlerle çalışırken bilgi aktarımını kolaylaştırır.
• Metin özetleme için oldukça etkili bir yöntemdir. Bu nedenle, Transformers gibi birçok mimaride kullanılır.

Transformers:

• Transformer mimarisi, özellikle doğal dil işleme görevlerinde büyük başarı elde etmiş bir model yapısıdır.
• Self-attention mekanizması kullanır, bu da her kelimenin diğer kelimelerle etkileşimini daha iyi modellenebilmesini sağlar.
• Paralel hesaplamaları teşvik eder, bu da eğitim sürelerini kısaltır.

NLP problemlerinde büyük sorunların bir tanesi modeli eğitecek veriyi elde etmektir. Neyse ki büyük dil modelleri bu iş yükünü almışlardır. Önceden eğitilmiş T5, PEGASUS gibi modeller sayesinde, gerçek veriler üzerinde modelde ince ayar (Fine-tuning) yapabiliriz. Metin özetlemede sıklıkla kullanılan önceden eğitilmiş T5 modeline de kısaca göz atalım ve model oluşturmaya başlayalım.

T5 (Text-To-Text Transfer Transformer):

T5 modeli, bir encoder ve bir decoder olmak üzere iki ana bileşenden oluşan çok amaçlı bir modeldir. Encoder, girdi dizisini kodlar ve decoder, kodlanmış veriyi kullanarak çıktı dizisini oluşturur. T5 modeli, encoder ve decoder için Transformer mimarisini kullanır. Transformer mimarisi, bir girdi dizisini bir çıktı dizisine dönüştürmek için dikkat mekanizmasını kullanır. T5 modeli, seq-to-seq yapısı ve Transformer mimarisi sayesinde, farklı türde yaratıcı metin formatları üretebilir. Bu formatlar arasında şiirler, kodlar, senaryolar, müzik parçaları, e-posta, mektuplar vb. yer alır.

F. Google T5 Dil Modeli ile Metin Özetleme

Geçmişten günümüze metin özetlemede kullanılan yaklaşımlar ve tekniklere baktığımıza göre, sıra model geliştirme aşamasına geldi. Model geliştirme işlemi yüksek donanım ve zaman gerektirdiği için, Google Colab veya Kaggle gibi platformlar kullanmanızı tavsiye ederim.

Adım 1: Gerekli yükleme işlemlerinin yapılması
Modeli oluşturmak için gereken kütüphaneleri yüklüyoruz. Ayrıca Hugging Face kütüphanesinden dil modellerini indirmek ve kullanabilmek için gereken kullanıcı girişini sağlamamız gerekiyor. Hugging Face’e henüz kaydolmadıysanız; buradan kaydolun. HuggingFace Token’ininz yoksa, üye olduktan sonra buradan kendi token’ınızı oluşturabilir ve kullanabilirsiniz:

import nltk
import numpy as np

from datasets import load_dataset
from evaluate import load

import transformers

from transformers import AutoTokenizer
from transformers import AutoModelForSeq2SeqLM, DataCollatorForSeq2Seq, Seq2SeqTrainingArguments, Seq2SeqTrainer

from transformers import AutoModelForSeq2SeqLM

from huggingface_hub import notebook_login
notebook_login()

!pip install datasets evaluate transformers rouge-score nltk
!apt install git-lfs

print(transformers.__version__)

Birbirlerinden farklı parametre sayılarına sahip çeşitli T5 modelleri bulunmaktadır (t5-small, t5-base, t5-large, t5-xl, t5-xxl). Bu çalışmada, fine-tune yapmak için t5-small modelini ve XSum veri setini kullanacağız. Değerlendirme metriği olarak ise ROGUE (Recall-Oriented Understudy for Gisting Evaluation) kullanacağız.

model_checkpoint = "t5-small"
raw_datasets = load_dataset("xsum")
metric = load("rouge")

Fine-tune işleminde kullanacağımız veri setine genel bir göz gezdirmek için ufak bir fonksiyon yazabiliriz. Aşağıdaki fonksiyon ile birlikte “train, validation ve test” olarak ayrılmış veri setinden train setine ufak bir göz atalım.

import datasets
import random
import pandas as pd
from IPython.display import display, HTML

def show_random_elements(dataset, num_examples=5):
    assert num_examples <= len(dataset), "Can't pick more elements than there are in the dataset."
    picks = []
    for _ in range(num_examples):
        pick = random.randint(0, len(dataset)-1)
        while pick in picks:
            pick = random.randint(0, len(dataset)-1)
        picks.append(pick)
    
    df = pd.DataFrame(dataset[picks])
    for column, typ in dataset.features.items():
        if isinstance(typ, datasets.ClassLabel):
            df[column] = df[column].transform(lambda i: typ.names[i])
    display(HTML(df.to_html()))

show_random_elements(raw_datasets["train"])

Train veri setinden bazı örnekler:

Adım 2: Verileri Ön İşleme
Modeli verilerle eğitmeden önce, verileri bir ön işleme adımından geçirmemiz gerekiyor. Bu adımda verileri modelin kabul ettiği şekle dönüştürmek gerekiyor. Bu işlemi transformers altında bulunan AutoTokenizer kullanarak gerçekleştirebiliriz.

tokenizer = AutoTokenizer.from_pretrained(model_checkpoint)

Seçtiğimiz modele göre, Tokenizer’ın farklı sayılar döndürdüğünü göreceksiniz. Modelin eğitilebilmesi için bu dönüşüm gereklidir. Tokenizer’a bir cümle veya cümle listesi ileterek dönen değerlere bir bakalım:

tokenizer(["Merhaba, bu birinci cümledir.", "Bu ise başka bir cümledir."])

Yukarıda T5 modelinin çoklu görevler yapabildiğinden bahsetmiştim. Modelin geliştiricileri, hangi görev için kullanılacağı problemini ön ek kullanarak etkili bir şekilde çözmüşlerdir. Kullanıcılar olarak, hangi görevde kullanmak istiyorsak onu belirtmemiz gerekir. Özetleme işlemi için “summarize” ön ekini kullanmamız gerekiyor.

if model_checkpoint in ["t5-small", "t5-base", "t5-larg", "t5-3b", "t5-11b"]:
    prefix = "summarize: "
else:
    prefix = ""

Örnekleri ön işleme tabi tutacak fonksiyonu yazabiliriz. Bunları sadece truncation=True argümanıyla tokenizer’a veriyoruz. Bu, seçilen modelin işleyebileceğinden daha uzun bir girdinin model tarafından kabul edilen maksimum uzunluğa kadar kesilmesini sağlayacaktır.

max_input_length = 1024
max_target_length = 128

def preprocess_function(examples):
    inputs = [prefix + doc for doc in examples["document"]]
    model_inputs = tokenizer(inputs, max_length=max_input_length, truncation=True)

    labels = tokenizer(text_target=examples["summary"], max_length=max_target_length, truncation=True)

    model_inputs["labels"] = labels["input_ids"]
    return model_inputs

Ham veri kümesini modele uygun şekilde tokenleştiriyoruz. İşlemi verimli şekilde gerçekleştirmek için batch işlemi kullanılır.

tokenized_datasets = raw_datasets.map(preprocess_function, batched=True)

Adım 3: Model Fine-Tuning

Artık verilerimiz hazır olduğuna göre önceden eğitilmiş modeli indirebilir ve ince ayarını yapabiliriz. Görevimiz sequence-to-sequence olduğu için AutoModelForSeq2SeqLM sınıfını kullanıyoruz.

model = AutoModelForSeq2SeqLM.from_pretrained(model_checkpoint)

Bir Seq2SeqTrainer’ı başlatmak için üç şey daha yapmamız gerekecek. Bunlardan en önemlisi, eğitimi özelleştirmeye yönelik tüm nitelikleri içeren bir sınıf olan Seq2SeqTrainingArguments’tir. Modelin kontrol noktalarını kaydetmek için kullanılacak bir klasör adı gerektirir ve diğer tüm argümanlar isteğe bağlıdır. (Diğer argümanların en iyi parametrelerini bulmak için birden fazla deneme yapılabilir.)

batch_size = 16
model_name = model_checkpoint.split("/")[-1]
args = Seq2SeqTrainingArguments(
    f"{model_name}-finetuned-xsum",
    evaluation_strategy = "epoch",
    learning_rate=2e-5,
    per_device_train_batch_size=batch_size,
    per_device_eval_batch_size=batch_size,
    weight_decay=0.01,
    save_total_limit=3,
    num_train_epochs=1,
    predict_with_generate=True,
    fp16=True,
    push_to_hub=True,
)

Burada değerlendirmeyi her epochun sonunda yapılacak şekilde ayarlıyoruz, öğrenme oranını değiştiriyoruz, hücrenin üst kısmında tanımlanan batch_size değerini kullanıyoruz ve ağırlık azalmasını özelleştiriyoruz. Seq2SeqTrainer modeli düzenli olarak kaydedeceğinden ve veri setimiz oldukça büyük olduğundan, ona en fazla üç kayıt yapmasını söylüyoruz. Son olarak, özetleri düzgün bir şekilde oluşturmak için predict_with_generate seçeneğini kullanıyoruz.

Son argüman her şeyi ayarlamak içindir, böylece modeli eğitim sırasında düzenli olarak Hub’a gönderebiliriz.

data_collator = DataCollatorForSeq2Seq(tokenizer, model=model)

Seq2SeqTrainer’ımız için tanımlamamız gereken son şey, tahminlerden metriklerin nasıl hesaplanacağıdır. Bunun için daha önce yüklediğimiz metriği kullanacak bir fonksiyon tanımlamamız ve tahminleri metinlere dönüştürmek için biraz ön işleme yapmamız gerekiyor.

def compute_metrics(eval_pred):
    predictions, labels = eval_pred
    decoded_preds = tokenizer.batch_decode(predictions, skip_special_tokens=True)
    
    labels = np.where(labels != -100, labels, tokenizer.pad_token_id)
    decoded_labels = tokenizer.batch_decode(labels, skip_special_tokens=True)
    
    decoded_preds = ["\n".join(nltk.sent_tokenize(pred.strip())) for pred in decoded_preds]
    decoded_labels = ["\n".join(nltk.sent_tokenize(label.strip())) for label in decoded_labels]
    
    result = metric.compute(predictions=decoded_preds, references=decoded_labels, use_stemmer=True, use_aggregator=True)
    result = {key: value * 100 for key, value in result.items()}
    
    prediction_lens = [np.count_nonzero(pred != tokenizer.pad_token_id) for pred in predictions]
    result["gen_len"] = np.mean(prediction_lens)
    
    return {k: round(v, 4) for k, v in result.items()}

Daha sonra tüm bunları veri kümelerimizle birlikte Seq2SeqTrainer’a aktarmamız gerekiyor.

trainer = Seq2SeqTrainer(
    model,
    args,
    train_dataset=tokenized_datasets["train"],
    eval_dataset=tokenized_datasets["validation"],
    data_collator=data_collator,
    tokenizer=tokenizer,
    compute_metrics=compute_metrics
)

Artık sadece train yöntemini çağırarak modelimizi fine-tune edebiliriz.

trainer.train()

Uzuuuuuuun süren bir eğitim nihayet tamamlandı. Modelin ROGUE değerleri aşağıdaki gibidir:

Modelimizi kullanarak bir de örnek yapalım. İngilizce Wikipedia’dan Mustafa Kemal Atatürk ile ilgili bir pasaj aldım ve bunu özetlemesini istedim:

Mustafa Kemal Atatürk, also known as Mustafa Kemal Pasha until 1921, 
and Ghazi Mustafa Kemal from 1921 until the Surname Law of 1934 
(c. 1881 – 10 November 1938), was a Turkish field marshal, 
revolutionary statesman, author, and 
the founding father of the Republic of Turkey, 
serving as its first president from 1923 until his death in 1938. 
He undertook sweeping progressive reforms, 
which modernized Turkey into a secular, industrializing nation. 
Ideologically a secularist and nationalist, his policies 
and socio-political theories became known as Kemalism. 
Due to his military and political accomplishments, 
Atatürk is regarded as one of the most important 
political leaders of the 20th century.

Son olarak fine-tune edilen modeli HuggingFace Hub’a yüklemek isterseniz:

trainer.push_to_hub()

model = AutoModelForSeq2SeqLM.from_pretrained("huggingface_kullanici_ismi/model_ismi")

Belki daha uzun bir metin, başka parametreler, daha büyük bir model kullanmalıydık ya da T5 modelinin yapısını değiştirmeliydik. Ancak karmaşık bir metni NLP modeliyle özetlemeye ne kadar çabalarsanız çabalayın, her zaman modelin özetlemeyi başaramadığı belgelerle karşılaşabiliriz. Hala ilerleme kaydedilecek çok araştırma alanı olduğunu düşünüyorum. Ayrıca, sistem donanımlarınız yeterliyse FLAN-T5 veya PEGASUS gibi daha güçlü dil modellerini de incelemenizi öneririm. Okuduğunuz için teşekkür ediyorum.

Ayrıntılı notebooka bu linkten ulaşabilirsiniz.

Soru veya güncellemeleriniz için bana aşağıdaki bağlantılardan ulaşabilirsiniz:
LinkedIn: https://www.linkedin.com/in/ramazanolmez/
Mail: ramazanolmeez@gmail.com

Kaynakça:

Rothman, D., Transformers for Natural Language Processing Second Edition / Build, train, and fine-tune deep neural architectures for NLP with Python, PyTorch, TensorFlow, BERT, and GPT-3

Signh, J., NATURAL LANGUAGE PROCESSING IN THE REAL WORLD / Text Processing, Analytics, and Classification

Zechner, K., (1997) A literature survey on information extraction and text summarization. Computational Linguistics Program, Carnegie Mellon University, [online] Fall 1996. Available at: http://www.cs.cmu.edu/afs/cs.cmu.edu/Web/People/zechner/infoextr.pdf.

Zhang, H., Cai, J., Xu, J. and Wang, J., (2019a) Pretraining-Based Natural Language Generation for Text Summarization. In: Proceedings of the 23rd Conference on Computational Natural Language Learning (CoNLL). [online] Stroudsburg, PA, USA: Association for Computational Linguistics, pp.789–797. Available at: https://www.aclweb.org/anthology/K19-1074.

Saggion, Horacio., Poibeau, Thierry., Automatic Text Summarization: Past, Present, and Future

Orasan, C., Automatic Summarisation: 25 Years On