Predicting Early Stage Lung Cancer Using Advanced Machine Learning Methods

Abstract

Lung cancer is one of the most prevalent and serious diseases globally, affecting individuals of all age
groups, from children to the elderly. Annually, substantial financial resources are required for the
diagnosis and treatment of lung cancer. Existing clinical techniques, such as X-rays and other imaging
procedures, necessitate complex hardware and incur significant costs. Consequently, the need arises
for accurate and reliable prediction methods. Machine learning models offer a comparatively more
effective and cost-efficient solution for medical diagnosis using medical datasets. Long-term tobacco
smoking accounts for 85 percent of lung cancer cases, while 10–15 percent of cases occur in
individuals who have never smoked. Numerous methods and tools are currently available for data
analysis and computation. These technological advancements will be leveraged to develop prediction
models aimed at detecting lung cancer at an early stage. This study involves comparing various
classification and ensemble models, including Support Vector Machine (SVM), K-Nearest Neighbour
(KNN), Random Forest (RF), Artificial Neural Networks (ANN), and a hybrid model, the Voting
classifier. The performance of these models will be evaluated and compared in terms of their
accuracy, facilitating the early identification of lung cancer in patients using the sophisticated
technologies available today.

Keywords : Machine Learning, Support Vector Machine, Voting, Random Forest, Cancer, K-Nearest
Neighbour, Neural Networks
Introduction

Lung cancer stands as one of the most formidable health challenges worldwide, with its prevalence
cutting across all age groups, from children to the elderly. The financial burden associated with lung
cancer is significant, encompassing both the costs of diagnosis and treatment. Traditional clinical
techniques for diagnosing lung cancer, such as X-rays and other imaging procedures, require
sophisticated hardware and are often expensive. This underscores the urgent need for more efficient,
cost-effective methods to accurately predict lung cancer, particularly in its early stages. In this
context, machine learning models have emerged as a promising alternative, offering the potential for
more effective and affordable diagnostic solutions.

The etiology of lung cancer is closely linked to tobacco smoking, which is responsible for
approximately 85 percent of cases. However, it is noteworthy that 10–15 percent of lung cancer
cases occur in individuals who have never smoked, highlighting the complexity of the disease and the
necessity for robust diagnostic tools. The advent of advanced data analysis and computational
methods has paved the way for the development of sophisticated machine learning models capable
of predicting lung cancer with high accuracy. These models leverage large medical datasets to
identify patterns and correlations that might be imperceptible to traditional diagnostic approaches.

This study focuses on the application and comparison of various machine learning classification and
ensemble models for the early detection of lung cancer. The models under consideration include
Support Vector Machine (SVM), K-Nearest Neighbour (KNN), Random Forest (RF), Artificial Neural
Networks (ANN), and a hybrid model known as the Voting classifier. Each of these models brings
unique strengths to the table, and their comparative analysis aims to identify the most accurate and
reliable model for lung cancer prediction.

Machine Learning in Medical Diagnosis

Machine learning, a subset of artificial intelligence, involves the use of algorithms and statistical
models to analyze and interpret complex data sets. In medical diagnosis, machine learning models
can process vast amounts of data, identify patterns, and make predictions with a high degree of
accuracy. These models are particularly valuable in the context of lung cancer, where early detection
is crucial for improving patient outcomes. By analyzing medical data sets, machine learning models
can predict the likelihood of lung cancer in patients, potentially before clinical symptoms become
apparent.

Support Vector Machine (SVM) is a powerful classification method that finds the optimal hyperplane
for separating data into distinct classes. It is particularly effective in high-dimensional spaces and is
known for its robustness in handling both linear and non-linear data. K-Nearest Neighbour (KNN) is a
simple, yet effective, algorithm that classifies data based on the majority class among the k-nearest
neighbors. Random Forest (RF) is an ensemble method that builds multiple decision trees and
merges their predictions to improve accuracy and prevent overfitting. Artificial Neural Networks
(ANN) are inspired by the human brain's neural networks and are capable of learning complex
patterns through multiple layers of interconnected nodes.

The Voting classifier is a hybrid model that combines the predictions of multiple machine learning
algorithms to improve overall accuracy. By leveraging the strengths of various models, the Voting
classifier can provide more reliable predictions, making it a valuable tool in medical diagnosis.
Importance of Early Detection

Early detection of lung cancer significantly enhances the chances of successful treatment and
survival. Traditional diagnostic methods often detect lung cancer at advanced stages, where
treatment options are limited and less effective. Machine learning models can facilitate earlier
detection by identifying subtle patterns in medical data that may indicate the presence of lung
cancer. This early intervention can lead to better patient outcomes, reduced treatment costs, and
improved quality of life for patients.

Evaluation and Comparison of Models

In this study, the performance of various machine learning models will be evaluated and compared
based on their accuracy in predicting lung cancer. Accuracy is a critical metric in medical diagnosis, as
it directly impacts the reliability of the predictions and, consequently, the clinical decisions made
based on those predictions. By comparing the performance of different models, this study aims to
identify the most effective machine learning techniques for early stage lung cancer prediction. The
application of machine learning models in lung cancer prediction represents a significant
advancement in medical diagnostics. By leveraging advanced computational methods and large
medical data sets, these models can provide accurate and cost-effective diagnostic solutions. The
comparative analysis of various models, including SVM, KNN, RF, ANN, and the Voting classifier, will
offer valuable insights into the most effective techniques for early detection of lung cancer,
ultimately contributing to better patient outcomes and reduced healthcare costs.
import numpy as np

import pandas as pd

import seaborn as sns

import matplotlib.pyplot as plt

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import StandardScaler

from sklearn.metrics import accuracy_score, classification_report

from sklearn.svm import SVC

from sklearn.ensemble import RandomForestClassifier

from sklearn.neighbors import KNeighborsClassifier

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense

from tensorflow.keras.utils import to_categorical

# Load dataset from CSV file

# Replace 'path_to_your_file.csv' with the actual path to your dataset

data_path = 'D:/cancer/'

data = pd.read_csv(data_path)

# Check the first few rows of the dataset

print(data.head())

# Assuming the last column is the target variable and the rest are features

X = data.iloc[:, :-1].values
y = data.iloc[:, -1].values

# Plot the correlation matrix

plt.figure(figsize=(12, 10))

correlation_matrix = data.corr()

sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', linewidths=0.5)

plt.title('Correlation Matrix')

plt.show()

# Split the dataset into training and testing sets

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Standardize the data

scaler = StandardScaler()

X_train = scaler.fit_transform(X_train)

X_test = scaler.transform(X_test)

# Train and evaluate SVM

svm_model = SVC(kernel='linear')

svm_model.fit(X_train, y_train)

y_pred_svm = svm_model.predict(X_test)

print("SVM Accuracy:", accuracy_score(y_test, y_pred_svm))

print(classification_report(y_test, y_pred_svm))

# Train and evaluate Random Forest

rf_model = RandomForestClassifier(n_estimators=100, random_state=42)

rf_model.fit(X_train, y_train)

y_pred_rf = rf_model.predict(X_test)

print("Random Forest Accuracy:", accuracy_score(y_test, y_pred_rf))

print(classification_report(y_test, y_pred_rf))
# Train and evaluate K-Nearest Neighbour

knn_model = KNeighborsClassifier(n_neighbors=5)

knn_model.fit(X_train, y_train)

y_pred_knn = knn_model.predict(X_test)

print("K-Nearest Neighbour Accuracy:", accuracy_score(y_test, y_pred_knn))

print(classification_report(y_test, y_pred_knn))

# Prepare data for CNN

# Assuming we need to reshape the data to a suitable format for CNN

# Adjust the shape as per your actual dataset's requirements

num_features = X_train.shape[1]

X_train_cnn = X_train.reshape(X_train.shape[0], int(np.sqrt(num_features)),

int(np.sqrt(num_features)), 1)

X_test_cnn = X_test.reshape(X_test.shape[0], int(np.sqrt(num_features)),

int(np.sqrt(num_features)), 1)

y_train_cnn = to_categorical(y_train, 2)

y_test_cnn = to_categorical(y_test, 2)

# Define the CNN model

cnn_model = Sequential([

Conv2D(32, (3, 3), activation='relu', input_shape=(int(np.sqrt(num_features)),

int(np.sqrt(num_features)), 1)),

MaxPooling2D((2, 2)),

Flatten(),

Dense(64, activation='relu'),

Dense(2, activation='softmax')

])

cnn_model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

# Train and evaluate CNN

cnn_model.fit(X_train_cnn, y_train_cnn, epochs=10, batch_size=32, validation_split=0.2)

cnn_loss, cnn_accuracy = cnn_model.evaluate(X_test_cnn, y_test_cnn)

print("CNN Accuracy:", cnn_accuracy)

# Summarize results

print(f"SVM Accuracy: {accuracy_score(y_test, y_pred_svm)}")

print(f"Random Forest Accuracy: {accuracy_score(y_test, y_pred_rf)}")

print(f"K-Nearest Neighbour Accuracy: {accuracy_score(y_test, y_pred_knn)}")

print(f"CNN Accuracy: {cnn_accuracy}")