{ "cells": [ { "cell_type": "markdown", "source": [ "# CSC 3105 Project" ], "metadata": { "collapsed": false }, "id": "cda961ffb493d00c" }, { "cell_type": "markdown", "source": [ "# Load and Clean the Data\n", "\n", "This code block performs the following operations:\n", "\n", "1. Imports necessary libraries for data handling and cleaning.\n", "2. Defines a function `load_data` to load the data from a given directory into a pandas dataframe.\n", "3. Defines a function `clean_data` to clean the loaded data. The cleaning process includes:\n", " - Handling missing values by dropping them.\n", " - Removing duplicate rows.\n", " - Converting the 'NLOS' column to integer data type.\n", " - Normalizing the 'Measured range (time of flight)' column.\n", " - Creating new features 'FP_SUM' and 'SNR'.\n", " - One-hot encoding categorical features.\n", " - Performing feature extraction on 'CIR' columns.\n", " - Dropping the original 'CIR' columns.\n", " - Checking for columns with only one unique value and dropping them.\n", "4. Checks if a pickle file with the cleaned data exists. If it does, it loads the data from the file. If it doesn't, it loads and cleans the data using the defined functions.\n", "5. Prints the first few rows of the cleaned data and its column headers." ], "metadata": { "collapsed": false }, "id": "73fe8802e95a784f" }, { "cell_type": "code", "outputs": [], "source": [ "import os\n", "\n", "import pandas as pd\n", "\n", "DATASET_DIR = './UWB-LOS-NLOS-Data-Set/dataset'\n", "\n", "\n", "def load_data(dataset_dir):\n", " # Load the data\n", " # file_paths = [os.path.join(dirpath, file) for dirpath, _, filenames in os.walk(dataset_dir) for file in filenames if 'uwb_dataset_part7.csv' not in file]\n", " file_paths = [os.path.join(dirpath, file) for dirpath, _, filenames in os.walk(dataset_dir) for file in filenames]\n", " data = pd.concat((pd.read_csv(file_path) for file_path in file_paths))\n", " print(f\"Original data shape: {data.shape}\")\n", " return data\n" ], "metadata": { "collapsed": false }, "id": "7bcd7cfc8dd11cbb" }, { "cell_type": "code", "outputs": [], "source": [ "from sklearn.preprocessing import LabelEncoder\n", "from sklearn.preprocessing import StandardScaler\n", "from sklearn.decomposition import PCA\n", "import matplotlib.pyplot as plt\n", "\n", "\n", "def clean_data(data):\n", " print(\"Starting data cleaning process...\")\n", "\n", " # Calculate total number of missing values in the data\n", " total_missing = data.isnull().sum().sum()\n", " print(f\"Total number of missing values: {total_missing}\")\n", "\n", " # Statistical Analysis\n", " print(\"Statistical Analysis:\")\n", " print(data.describe())\n", "\n", " # Plot Boxplot to check for outliers for the first 15 columns\n", " print(\"Boxplot of the first 15 columns:\")\n", " fig, axs = plt.subplots(15,1,dpi=95, figsize=(7,17))\n", " for i, col in enumerate(data.columns[:15]):\n", " axs[i].boxplot(data[col], vert=False)\n", " axs[i].set_ylabel(col)\n", " plt.show()\n", "\n", " # Data has no missing values\n", " data = data.dropna()\n", " print(\"Missing values dropped.\")\n", "\n", " # Data has no duplicate rows\n", " data = data.drop_duplicates()\n", " print(\"Duplicate rows dropped.\")\n", "\n", " # Convert 'NLOS' column to integer data type (0 for LOS, 1 for NLOS)\n", " data['NLOS'] = data['NLOS'].astype(int)\n", " print(\"'NLOS' column converted to integer data type.\")\n", "\n", " # Create new feature 'FP_SUM' by adding 'FP_AMP1', 'FP_AMP2', and 'FP_AMP3'\n", " # data['FP_SUM'] = data['FP_AMP1'] + data['FP_AMP2'] + data['FP_AMP3']\n", " # print(\"New feature 'FP_SUM' created.\")\n", " # data.drop(['FP_AMP1', 'FP_AMP2', 'FP_AMP3'], axis=1, inplace=True)\n", "\n", " # Calculate new feature 'First_Path_Power_Level'\n", " data['First_Path_Power_Level'] = (10 * np.log10(\n", " (data['FP_AMP1'] ** 2 + data['FP_AMP2'] ** 2 + data['FP_AMP3'] ** 2) / (data['RXPACC'] ** 2))) - 64\n", " print(\"New feature 'First_Path_Power_Level' calculated.\")\n", " data.drop(['FP_AMP1', 'FP_AMP2', 'FP_AMP3', 'RXPACC', 'PRFR'], axis=1, inplace=True)\n", "\n", " # Calculate SNR as the ratio of 'CIR_PWR' to 'STDEV_NOISE' for each data point\n", " data['SNR'] = data['CIR_PWR'] / data['STDEV_NOISE']\n", " print(\"New feature 'SNR' created.\")\n", " data.drop(['CIR_PWR', 'STDEV_NOISE'], axis=1, inplace=True)\n", "\n", " # One-hot encode categorical features\n", " categorical_features = ['CH', 'FRAME_LEN', 'PREAM_LEN', 'BITRATE']\n", " encoder = LabelEncoder()\n", " for feature in categorical_features:\n", " data[feature] = encoder.fit_transform(data[feature])\n", " print(\"Categorical features one-hot encoded.\")\n", "\n", " # Extract the 'CIR' columns\n", " cir_columns = [f\"CIR{i}\" for i in range(1015)]\n", " # cir_columns = [f\"CIR{i}\" for i in range(1016)]\n", " cir_data = data[cir_columns]\n", " print(\"'CIR' columns extracted.\")\n", "\n", " # Perform PCA on the 'CIR' columns\n", " pca = PCA(n_components=0.95)\n", " cir_pca = pca.fit_transform(cir_data)\n", " print(\"PCA performed on 'CIR' columns.\")\n", "\n", " # Create a DataFrame with the principal components\n", " cir_pca_df = pd.DataFrame(cir_pca, columns=[f\"PC{i}\" for i in range(1, pca.n_components_ + 1)])\n", " print(\"DataFrame with principal components created.\")\n", "\n", " # Drop the original 'CIR' columns from the data\n", " data = data.drop(columns=cir_columns)\n", " print(\"Original 'CIR' columns dropped.\")\n", "\n", " # Add the principal components to the original data\n", " # Reset the index of both dataframes\n", " data = data.reset_index(drop=True)\n", " cir_pca_df = cir_pca_df.reset_index(drop=True)\n", " print(\"Indexes of both dataframes reset.\")\n", "\n", " # Concatenate the dataframes\n", " data = pd.concat([data, cir_pca_df], axis=1)\n", " print(\"Dataframes concatenated.\")\n", "\n", " # List of columns to check for unique values\n", " columns_to_check = ['CH', 'PREAM_LEN', 'BITRATE']\n", "\n", " # Iterate over the columns\n", " for column in columns_to_check:\n", " # If the column has only one unique value, drop it\n", " if data[column].nunique() == 1:\n", " data = data.drop(column, axis=1)\n", " print(f\"Column '{column}' dropped due to having only one unique value.\")\n", "\n", " # Standardize the numerical columns (excluding 'NLOS')\n", " numerical_cols = data.select_dtypes(include=[np.number]).columns\n", " numerical_cols = numerical_cols.drop('NLOS')\n", " scaler = StandardScaler()\n", " data[numerical_cols] = scaler.fit_transform(data[numerical_cols])\n", " print(\"Numerical columns standardized.\")\n", "\n", " # Print the shape of the cleaned data\n", " print(f\"Cleaned data shape: {data.shape}\")\n", "\n", " print(\"Data cleaning process completed.\")\n", " # Return the cleaned data\n", " return data" ], "metadata": { "collapsed": false }, "id": "685463c2d6065b08" }, { "cell_type": "code", "outputs": [], "source": [ "import pickle\n", "\n", "# File='data_original.pkl'\n", "File = 'data.pkl'\n", "\n", "# Check if the file exists\n", "if os.path.exists(File):\n", " # If the file exists, load it\n", " print(\"Loading data from pickle file...\")\n", " with open(File, 'rb') as f:\n", " data = pickle.load(f)\n", " print(\"Data loaded successfully.\")\n", "else:\n", " # If the file doesn't exist, load and clean the data\n", " print(\"Pickle file not found. Loading and cleaning data...\")\n", " data = load_data(DATASET_DIR)\n", " data = clean_data(data)\n", " print(\"Data loaded and cleaned successfully.\")\n", " print(\"Saving cleaned data to pickle file...\")\n", " with open(File, 'wb') as f:\n", " pickle.dump(data, f)\n", " print(\"Cleaned data saved to pickle file successfully.\")\n", "\n", "print(\"First few rows of the data:\")\n", "print(data.head())\n", "\n", "# Print Headers\n", "print(\"Column headers:\")\n", "print(data.columns)" ], "metadata": { "collapsed": false }, "id": "79c2c23691b26753" }, { "cell_type": "code", "outputs": [], "source": [ "MODEL_DIR = './models'\n", "\n", "\n", "def train_and_save_model(classifier, X_train, y_train, file_name):\n", " if not os.path.exists(MODEL_DIR):\n", " os.makedirs(MODEL_DIR)\n", "\n", " file_path = os.path.join(MODEL_DIR, file_name)\n", "\n", " # Check if the file exists\n", " if not os.path.exists(file_path):\n", " print(f\"Training the model and saving it to {file_path}\")\n", " # Train the classifier\n", " classifier.fit(X_train, y_train)\n", "\n", " # Save the trained model as a pickle string.\n", " saved_model = pickle.dumps(classifier)\n", "\n", " # Save the pickled model to a file\n", " with open(file_path, 'wb') as file:\n", " file.write(saved_model)\n", "\n", " # Load the pickled model from the file\n", " with open(file_path, 'rb') as file:\n", " loaded_model = pickle.load(file)\n", "\n", " return loaded_model" ], "metadata": { "collapsed": false }, "id": "12e16974341e6266" }, { "cell_type": "markdown", "source": [ "The selected code is performing data standardization, which is a common preprocessing step in many machine learning workflows. \n", "\n", "The purpose of standardization is to transform the data such that it has a mean of 0 and a standard deviation of 1. This is done to ensure that all features have the same scale, which is a requirement for many machine learning algorithms.\n", "\n", "The mathematical formulas used in this process are as follows:\n", "\n", "1. Calculate the mean (μ) of the data:\n", "\n", "$$\n", "\\mu = \\frac{1}{n} \\sum_{i=1}^{n} x_i\n", "$$\n", "Where:\n", "- $n$ is the number of observations in the data\n", "- $x_i$ is the value of the $i$-th observation\n", "- $\\sum$ denotes the summation over all observations\n", "\n", "2. Standardize the data by subtracting the mean from each observation and dividing by the standard deviation:\n", "\n", "$$\n", "\\text{Data}_i = \\frac{x_i - \\mu}{\\sigma}\n", "$$\n", "Where:\n", "- $\\text{Data}_i$ is the standardized value of the $i$-th observation\n", "- $\\sigma$ is the standard deviation of the data\n", "- $x_i$ is the value of the $i$-th observation\n", "- $\\mu$ is the mean of the data\n", "\n", "The `StandardScaler` class from the `sklearn.preprocessing` module is used to perform this standardization. The `fit_transform` method is used to calculate the mean and standard deviation of the data and then perform the standardization.\n", "\n", "**Note:** By setting the explained variance to 0.95, we are saying that we want to choose the smallest number of principal components such that 95% of the variance in the original data is retained. This means that the transformed data will retain 95% of the information of the original data, while potentially having fewer dimensions.\n" ], "metadata": { "collapsed": false }, "id": "b36814c942066d6" }, { "cell_type": "markdown", "source": [ "## Data Mining / Machine Learning\n", "\n", "### I. Supervised Learning\n", "- **Decision**: Supervised learning is used due to the labeled dataset.\n", "- **Algorithm**: Random Forest Classifier is preferred for its performance in classification tasks.\n", "\n", "### II. Training/Test Split Ratio\n", "- **Decision**: 70:30 split is chosen for training/test dataset.\n", "- **Reasoning**: This split ensures sufficient data for training and testing.\n", "\n", "### III. Performance Metrics\n", "- **Classification Accuracy**: Measures the proportion of correctly classified instances.\n", "- **Confusion Matrix**: Provides a summary of predicted and actual classes.\n", "- **Classification Report**: Provides detailed metrics such as precision, recall, F1-score, and support for each class.\n", "\n", "The Random Forest Classifier is trained on the training set and evaluated on the test set using accuracy and classification report metrics.\n" ], "metadata": { "collapsed": false }, "id": "8fefd253728ea2f0" }, { "cell_type": "markdown", "source": [ "# Split the data into training and testing sets\n", "\n", "The next step is to split the data into training and testing sets. This is a common practice in machine learning, where the training set is used to train the model, and the testing set is used to evaluate its performance.\n", "\n", "We will use the `train_test_split` function from the `sklearn.model_selection` module to split the data into training and testing sets. We will use 70% of the data for training and 30% for testing, which is a common split ratio." ], "metadata": { "collapsed": false }, "id": "7d64d6490fa1c2c2" }, { "cell_type": "code", "outputs": [], "source": [ "from sklearn.model_selection import train_test_split\n", "\n", "# Split the data into training and test sets\n", "X_train, X_test, y_train, y_test = train_test_split(data, data['NLOS'], test_size=0.2)\n", "\n", "# Load uwb_dataset_part7.csv\n", "# uwb_dataset_part7 = pd.read_csv('./UWB-LOS-NLOS-Data-Set/dataset/uwb_dataset_part7.csv')\n", "\n", "# Clean the data\n", "# uwb_dataset_part7 = clean_data(uwb_dataset_part7)\n", "\n", "# Split the data into features and labels\n", "# X_test = uwb_dataset_part7\n", "# y_test = uwb_dataset_part7['NLOS']\n", "\n", "# print(f\"{y_train}\")\n", "# print(\"Y Test\")\n", "# print(f\"{y_test}\")\n" ], "metadata": { "collapsed": false }, "id": "54d2a6506b584a03" }, { "cell_type": "markdown", "source": [ "# Train a Random Forest Classifier\n", "\n", "The next step is to train a machine learning model on the training data. We will use the `RandomForestClassifier` class from the `sklearn.ensemble` module to train a random forest classifier.\n", "\n", "The random forest classifier is an ensemble learning method that operates by constructing a multitude of decision trees at training time and outputting the class that is the mode of the classes (classification) or mean prediction (regression) of the individual trees.\n", "\n", "We will use the `fit` method of the `RandomForestClassifier` object to train the model on the training data." ], "metadata": { "collapsed": false }, "id": "ab55160e30fd6f99" }, { "cell_type": "code", "outputs": [], "source": [ "from sklearn.ensemble import RandomForestClassifier\n", "\n", "# Initialize the classifier with parameters to prevent overfitting\n", "classifier = RandomForestClassifier(n_estimators=200, max_depth=10, min_samples_split=10, min_samples_leaf=5, max_features='sqrt')\n", "\n", "loaded_model = train_and_save_model(classifier, X_train, y_train, 'random_forest_classifier.pkl')\n" ], "metadata": { "collapsed": false }, "id": "dc485f3de9f8936f" }, { "cell_type": "markdown", "source": [ "# Evaluate the Model\n", "\n", "To evaluate the performance of the trained model on the testing data, we will use the `predict` method of the `RandomForestClassifier` object to make predictions on the testing data. We will then use the `accuracy_score` and `classification_report` functions from the `sklearn.metrics` module to calculate the accuracy and generate a classification report.\n", "\n", "- **Accuracy:** The accuracy score function calculates the proportion of correctly classified instances.\n", "\n", "- **Precision:** The ratio of correctly predicted positive observations to the total predicted positive observations. It is calculated as:\n", "\n", " $$\n", " \\text{Precision} = \\frac{\\text{True Positives}}{\\text{True Positives} + \\text{False Positives}}\n", " $$\n", "\n", "- **Recall:** The ratio of correctly predicted positive observations to all observations in the actual class. It is calculated as:\n", "\n", " $$\n", " \\text{Recall} = \\frac{\\text{True Positives}}{\\text{True Positives} + \\text{False Negatives}}\n", " $$\n", "\n", "- **F1 Score:** The weighted average of precision and recall. It is calculated as:\n", "\n", " $$\n", " \\text{F1 Score} = 2 \\times \\frac{\\text{Precision} \\times \\text{Recall}}{\\text{Precision} + \\text{Recall}}\n", " $$\n", "\n", "- **Support:** The number of actual occurrences of the class in the dataset.\n", "\n", "The classification report provides a summary of the precision, recall, F1-score, and support for each class in the testing data, giving insight into how well the model is performing for each class.\n" ], "metadata": { "collapsed": false }, "id": "424cc5954c9e81cc" }, { "cell_type": "code", "outputs": [], "source": [ "from sklearn.metrics import accuracy_score, classification_report\n", "from sklearn.model_selection import cross_val_score\n", "\n", "# Make predictions on the test set using the loaded model\n", "y_pred = loaded_model.predict(X_test)\n", "\n", "# Evaluate the loaded model\n", "accuracy = accuracy_score(y_test, y_pred)\n", "classification_rep = classification_report(y_test, y_pred)\n", "cross_val_score = cross_val_score(loaded_model, X_test, y_test, cv=5)\n", "\n", "print(f\"Accuracy: {accuracy}\")\n", "print(f\"Classification Report:\\n{classification_rep}\")\n", "print(f\"Cross Validation Score: {cross_val_score}\")\n" ], "metadata": { "collapsed": false }, "id": "702b4f40dda16736" }, { "cell_type": "markdown", "source": [ "# Visualize a Decision Tree from the Random Forest\n" ], "metadata": { "collapsed": false }, "id": "41957f9babb74a3" }, { "cell_type": "code", "outputs": [], "source": [ "from sklearn.tree import plot_tree\n", "import matplotlib.pyplot as plt\n", "\n", "# Select one tree from the forest\n", "estimator = loaded_model.estimators_[0]\n", "\n", "plt.figure(figsize=(100, 100))\n", "plot_tree(estimator,\n", " filled=True,\n", " rounded=True,\n", " class_names=['NLOS', 'LOS'],\n", " feature_names=data.columns,\n", " max_depth=5) # Limit the depth of the tree\n", "plt.show()" ], "metadata": { "collapsed": false }, "id": "1f6f826d6234591c" }, { "cell_type": "markdown", "source": [ "# Support Vector Machine (SVM)" ], "metadata": { "collapsed": false }, "id": "eef3be2c3026a909" }, { "cell_type": "code", "outputs": [], "source": [ "# import os\n", "# from sklearn.svm import SVC\n", "# import pickle\n", "# \n", "# svm = SVC(kernel='linear', random_state=42)\n", "# loaded_model = train_and_save_model(svm, X_train, y_train, 'svm_classifier.pkl')\n", "# \n", "# # Predict the labels for the test set with each model\n", "# y_pred_svm = loaded_model.predict(X_test)\n", "# \n", "# # Calculate the accuracy of each model\n", "# accuracy_svm = accuracy_score(y_test, y_pred_svm)\n", "# \n", "# # Print the accuracy of each model\n", "# print(f\"Accuracy of SVM: {accuracy_svm}\")" ], "metadata": { "collapsed": false }, "id": "c970b0c1593d955c" }, { "cell_type": "markdown", "source": [ "# Logistic Regression" ], "metadata": { "collapsed": false }, "id": "cccaf1db0d5060a8" }, { "cell_type": "code", "outputs": [], "source": [ "from sklearn.linear_model import LogisticRegression\n", "from sklearn.model_selection import cross_val_score\n", "\n", "# Logistic Regression with L2 regularization\n", "log_reg = LogisticRegression(penalty='l2', C=0.1)\n", "\n", "# Use the train_and_save_model function to train and save the model\n", "loaded_model = train_and_save_model(log_reg, X_train, y_train, 'logistic_regression_model.pkl')" ], "metadata": { "collapsed": false }, "id": "ee7506f4aa805faf" }, { "cell_type": "code", "outputs": [], "source": [ "\n", "# Predict on the test set\n", "y_pred_log_reg = loaded_model.predict(X_test)\n", "\n", "# Calculate accuracy\n", "accuracy_log_reg = accuracy_score(y_test, y_pred_log_reg)\n", "print(f\"Accuracy of Logistic Regression: {accuracy_log_reg}\")\n", "\n", "# Perform 5-fold cross validation\n", "scores = cross_val_score(log_reg, X_train, y_train, cv=5)\n", "print(f\"Cross-validated scores: {scores}\")" ], "metadata": { "collapsed": false }, "id": "a44d38efa4b86d93" }, { "cell_type": "code", "outputs": [], "source": [ "from sklearn.metrics import roc_curve, auc\n", "import matplotlib.pyplot as plt\n", "\n", "# Compute ROC curve and ROC area for each class\n", "fpr, tpr, _ = roc_curve(y_test, y_pred_log_reg)\n", "roc_auc = auc(fpr, tpr)\n", "\n", "plt.figure()\n", "lw = 2\n", "plt.plot(fpr, tpr, color='darkorange',\n", " lw=lw, label='ROC curve (area = %0.2f)' % roc_auc)\n", "plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')\n", "plt.xlim([0.0, 1.0])\n", "plt.ylim([0.0, 1.05])\n", "plt.xlabel('False Positive Rate')\n", "plt.ylabel('True Positive Rate')\n", "plt.title('Receiver Operating Characteristic')\n", "plt.legend(loc=\"lower right\")\n", "plt.show()" ], "metadata": { "collapsed": false }, "id": "a3646a4965b0707c" }, { "cell_type": "markdown", "source": [ "# Gradient Boosting Classifier" ], "metadata": { "collapsed": false }, "id": "aeaf5eeffa7ec104" }, { "cell_type": "code", "outputs": [], "source": [ "from sklearn.ensemble import GradientBoostingClassifier\n", "\n", "# Gradient Boosting Classifier\n", "gbc = GradientBoostingClassifier()\n", "\n", "# Use the train_and_save_model function to train and save the model\n", "loaded_model = train_and_save_model(gbc, X_train, y_train, 'gradient_boosting_classifier.pkl')\n" ], "metadata": { "collapsed": false }, "id": "c7ecae5d021ad44f" }, { "cell_type": "code", "outputs": [], "source": [ "y_pred_gbc = loaded_model.predict(X_test)\n", "accuracy_gbc = accuracy_score(y_test, y_pred_gbc)\n", "print(f\"Accuracy of Gradient Boosting Classifier: {accuracy_gbc}\")\n" ], "metadata": { "collapsed": false }, "id": "4a8a1c3a7289ef7a" }, { "cell_type": "markdown", "source": [ "# K-Nearest Neighbors (KNN, K=15)\n", "\n", "This code block is implementing the K-Nearest Neighbors (KNN) algorithm for classification. The KNN algorithm is a type of instance-based learning, or lazy learning, where the function is only approximated locally and all computation is deferred until function evaluation. \n", "\n", "The KNN algorithm works by finding the distances between a query and all the examples in the data, selecting the specified number examples (K) closest to the query, then votes for the most frequent label (in the case of classification) or averages the labels (in the case of regression). \n", "\n", "The number of neighbors, K, is set to 15 in this case. This means that the algorithm looks at the 15 nearest neighbors to decide the class of the test instance. \n", "\n", "The mathematical concept behind KNN is the Euclidean distance. Given two points P1(x1, y1) and P2(x2, y2) in a 2D space, the Euclidean distance between P1 and P2 is calculated as:\n", "\n", "$$\n", "\\text{Distance} = \\sqrt{(x2 - x1)^2 + (y2 - y1)^2}\n", "$$\n", "In higher dimensional space, the formula is generalized as:\n", "$$\n", "\\text{Distance} = \\sqrt{\\sum_{i=1}^{n} (x_i - y_i)^2}\n", "$$\n", "Where:\n", "- $n$ is the number of dimensions\n", "- $x_i$ and $y_i$ are the $i$-th dimensions of the two points\n" ], "metadata": { "collapsed": false }, "id": "25102568a6e5c457" }, { "cell_type": "code", "outputs": [], "source": [ "from sklearn.neighbors import KNeighborsClassifier\n", "\n", "# K-Nearest Neighbors\n", "knn = KNeighborsClassifier(n_neighbors=11)\n", "loaded_model = train_and_save_model(knn, X_train, y_train, 'knn_classifier.pkl')\n" ], "metadata": { "collapsed": false }, "id": "705c62e64bf6d614" }, { "cell_type": "code", "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Accuracy of K-Nearest Neighbors: 0.8823809523809524\n" ] } ], "source": [ "y_pred_knn = loaded_model.predict(X_test)\n", "accuracy_knn = accuracy_score(y_test, y_pred_knn)\n", "print(f\"Accuracy of K-Nearest Neighbors: {accuracy_knn}\")" ], "metadata": { "collapsed": false, "ExecuteTime": { "end_time": "2024-03-11T09:35:15.226753Z", "start_time": "2024-03-11T09:35:14.516824Z" } }, "id": "cf4df4ef7bbfd74", "execution_count": 30 }, { "cell_type": "code", "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.8775595238095238\n", "{'n_neighbors': 11}\n" ] } ], "source": [ "from sklearn.model_selection import GridSearchCV\n", "\n", "# Define the parameter values that should be searched\n", "k_range = list(range(1, 31))\n", "\n", "# Create a parameter grid: map the parameter names to the values that should be searched\n", "param_grid = dict(n_neighbors=k_range)\n", "\n", "# Instantiate the grid\n", "grid = GridSearchCV(knn, param_grid, cv=10, scoring='accuracy')\n", "\n", "# Fit the grid with data\n", "grid.fit(X_train, y_train)\n", "\n", "# View the complete results\n", "grid.cv_results_\n", "\n", "# Examine the best model\n", "print(grid.best_score_)\n", "print(grid.best_params_)" ], "metadata": { "collapsed": false, "ExecuteTime": { "end_time": "2024-03-11T09:36:32.996298Z", "start_time": "2024-03-11T09:35:15.228121Z" } }, "id": "faabcf63e34005a9", "execution_count": 31 }, { "cell_type": "code", "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Original number of features: 48, reduced number of features: 2\n" ] }, { "data": { "text/plain": "
", "image/png": "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" }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "import numpy as np\n", "\n", "# Apply PCA to reduce dimensionality to 2D\n", "pca = PCA(n_components=2)\n", "X_test_2d = pca.fit_transform(X_test)\n", "\n", "# Print the number of features\n", "print(f\"Original number of features: {X_test.shape[1]}, reduced number of features: {X_test_2d.shape[1]}\")\n", "\n", "# Create a scatter plot\n", "plt.figure(figsize=(10, 7))\n", "\n", "# Create a color map\n", "cmap = plt.cm.viridis\n", "\n", "# Plot NLOS points\n", "nlos = plt.scatter(X_test_2d[y_pred_knn == 1, 0], X_test_2d[y_pred_knn == 1, 1], c='blue', label='NLOS')\n", "\n", "# Plot LOS points\n", "los = plt.scatter(X_test_2d[y_pred_knn == 0, 0], X_test_2d[y_pred_knn == 0, 1], c='red', label='LOS')\n", "\n", "# Add labels\n", "plt.xlabel('Principal Component 1')\n", "plt.ylabel('Principal Component 2')\n", "plt.title('2D Scatter Plot for LOS and NLOS')\n", "\n", "# Add a legend\n", "plt.legend(handles=[nlos, los])\n", "\n", "plt.show()" ], "metadata": { "collapsed": false, "ExecuteTime": { "end_time": "2024-03-11T09:36:33.464205Z", "start_time": "2024-03-11T09:36:32.997412Z" } }, "id": "2ed22b3fc59f74e6", "execution_count": 32 }, { "cell_type": "markdown", "source": [ "# Naive Bayes" ], "metadata": { "collapsed": false }, "id": "5b9b66f92968957c" }, { "cell_type": "code", "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Training the model and saving it to ./models/naive_bayes_classifier.pkl\n" ] } ], "source": [ "from sklearn.naive_bayes import GaussianNB\n", "\n", "# Naive Bayes\n", "nb = GaussianNB()\n", "loaded_model = train_and_save_model(nb, X_train, y_train, 'naive_bayes_classifier.pkl')" ], "metadata": { "collapsed": false, "ExecuteTime": { "end_time": "2024-03-11T09:36:33.504010Z", "start_time": "2024-03-11T09:36:33.465404Z" } }, "id": "3d984228fb1d3026", "execution_count": 33 }, { "cell_type": "code", "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Accuracy of Naive Bayes: 1.0\n" ] } ], "source": [ "y_pred_nb = loaded_model.predict(X_test)\n", "accuracy_nb = accuracy_score(y_test, y_pred_nb)\n", "print(f\"Accuracy of Naive Bayes: {accuracy_nb}\")" ], "metadata": { "collapsed": false, "ExecuteTime": { "end_time": "2024-03-11T09:36:33.517348Z", "start_time": "2024-03-11T09:36:33.505627Z" } }, "id": "98cd350871bc3201", "execution_count": 34 }, { "cell_type": "markdown", "source": [ "# K-Means Clustering" ], "metadata": { "collapsed": false }, "id": "92c8498137a5e32e" }, { "cell_type": "code", "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Training the model and saving it to ./models/kmeans_clustering.pkl\n" ] } ], "source": [ "from sklearn.cluster import KMeans\n", "\n", "# K-Means Clustering\n", "kmeans = KMeans(n_clusters=2, max_iter=600)\n", "loaded_model = train_and_save_model(kmeans, X_train, y_train, 'kmeans_clustering.pkl')" ], "metadata": { "collapsed": false, "ExecuteTime": { "end_time": "2024-03-11T09:36:33.715869Z", "start_time": "2024-03-11T09:36:33.518445Z" } }, "id": "305a796294814705", "execution_count": 35 }, { "cell_type": "code", "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Accuracy of K-Means Clustering: 0.7902380952380952\n" ] } ], "source": [ "y_pred_kmeans = loaded_model.predict(X_test)\n", "accuracy_kmeans = accuracy_score(y_test, y_pred_kmeans)\n", "print(f\"Accuracy of K-Means Clustering: {accuracy_kmeans}\")\n" ], "metadata": { "collapsed": false, "ExecuteTime": { "end_time": "2024-03-11T09:36:33.726224Z", "start_time": "2024-03-11T09:36:33.717138Z" } }, "id": "494bb537046bf5a7", "execution_count": 36 }, { "cell_type": "code", "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Data table with cluster labels:\n", " NLOS RANGE FP_IDX MAX_NOISE FRAME_LEN PREAM_LEN CIR1015 \\\n", "20604 1.0 -1.091501 -0.145210 0.221321 0.874210 -0.196211 1.136854 \n", "3563 1.0 -1.146681 0.298744 0.916686 -1.143918 -0.196211 -0.618518 \n", "5721 0.0 0.135182 0.742698 -0.889546 0.874210 -0.196211 1.136854 \n", "4229 0.0 -0.696755 0.076767 1.242906 0.874210 -0.196211 1.136854 \n", "12800 1.0 -0.908984 0.964675 -0.731587 -1.143918 -0.196211 -0.618518 \n", "... ... ... ... ... ... ... ... \n", "33593 NaN NaN NaN NaN NaN NaN NaN \n", "33594 NaN NaN NaN NaN NaN NaN NaN \n", "33596 NaN NaN NaN NaN NaN NaN NaN \n", "33598 NaN NaN NaN NaN NaN NaN NaN \n", "33599 NaN NaN NaN NaN NaN NaN NaN \n", "\n", " First_Path_Power_Level SNR PC1 ... PC31 PC32 \\\n", "20604 0.834381 -0.598329 -1.844408 ... 0.293678 -0.661449 \n", "3563 1.017452 0.104326 -0.529890 ... -0.025231 0.132386 \n", "5721 0.764416 0.496930 0.549152 ... -0.725225 -0.125061 \n", "4229 1.133312 0.140279 -0.624938 ... -0.378297 -0.497954 \n", "12800 0.108009 0.404357 0.589113 ... -0.237710 -0.273787 \n", "... ... ... ... ... ... ... \n", "33593 NaN NaN NaN ... NaN NaN \n", "33594 NaN NaN NaN ... NaN NaN \n", "33596 NaN NaN NaN ... NaN NaN \n", "33598 NaN NaN NaN ... NaN NaN \n", "33599 NaN NaN NaN ... NaN NaN \n", "\n", " PC33 PC34 PC35 PC36 PC37 PC38 PC39 \\\n", "20604 0.406192 0.268709 0.329607 -0.169345 0.432609 0.242939 -0.501317 \n", "3563 -0.587800 -0.257166 -0.431297 -0.725000 -0.485302 -0.010506 0.128235 \n", "5721 -0.187973 -1.005691 0.543882 0.963563 -0.028384 -0.270283 0.746807 \n", "4229 -0.473187 -0.578283 -0.260293 0.001544 0.735248 0.056007 -0.402481 \n", "12800 -0.028760 0.268048 -0.099191 -1.102713 0.678101 -0.348046 0.819805 \n", "... ... ... ... ... ... ... ... \n", "33593 NaN NaN NaN NaN NaN NaN NaN \n", "33594 NaN NaN NaN NaN NaN NaN NaN \n", "33596 NaN NaN NaN NaN NaN NaN NaN \n", "33598 NaN NaN NaN NaN NaN NaN NaN \n", "33599 NaN NaN NaN NaN NaN NaN NaN \n", "\n", " Cluster \n", "20604 0.0 \n", "3563 0.0 \n", "5721 0.0 \n", "4229 0.0 \n", "12800 1.0 \n", "... ... \n", "33593 1.0 \n", "33594 0.0 \n", "33596 1.0 \n", "33598 0.0 \n", "33599 1.0 \n", "\n", "[35278 rows x 49 columns]\n" ] } ], "source": [ "labels = loaded_model.labels_\n", "# Print the data table with the cluster labels\n", "print(f\"Data table with cluster labels:\\n{pd.concat([X_test, pd.DataFrame({'Cluster': labels})], axis=1)}\")\n", "\n" ], "metadata": { "collapsed": false, "ExecuteTime": { "end_time": "2024-03-11T09:36:33.751015Z", "start_time": "2024-03-11T09:36:33.727429Z" } }, "id": "62401c8d1a4d61cc", "execution_count": 37 }, { "cell_type": "markdown", "source": [ "# Neural Network" ], "metadata": { "collapsed": false }, "id": "862a9b7ee430a667" }, { "cell_type": "code", "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "2024-03-11 17:36:34.132308: I tensorflow/core/util/port.cc:113] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", "2024-03-11 17:36:34.191657: I external/local_tsl/tsl/cuda/cudart_stub.cc:31] Could not find cuda drivers on your machine, GPU will not be used.\n", "2024-03-11 17:36:34.356171: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", "2024-03-11 17:36:34.356217: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", "2024-03-11 17:36:34.367283: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", "2024-03-11 17:36:34.394553: I external/local_tsl/tsl/cuda/cudart_stub.cc:31] Could not find cuda drivers on your machine, GPU will not be used.\n", "2024-03-11 17:36:34.395227: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", "To enable the following instructions: AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", "2024-03-11 17:36:35.762774: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Epoch 1/100\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-03-11 17:36:37.442250: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:901] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", "2024-03-11 17:36:37.442821: W tensorflow/core/common_runtime/gpu/gpu_device.cc:2256] Cannot dlopen some GPU libraries. Please make sure the missing libraries mentioned above are installed properly if you would like to use GPU. Follow the guide at https://www.tensorflow.org/install/gpu for how to download and setup the required libraries for your platform.\n", "Skipping registering GPU devices...\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "1050/1050 [==============================] - 3s 2ms/step - loss: 0.3589 - accuracy: 0.8329 - val_loss: 0.0501 - val_accuracy: 0.9894\n", "Epoch 2/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 0.0506 - accuracy: 0.9843 - val_loss: 0.0018 - val_accuracy: 0.9995\n", "Epoch 3/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 0.0113 - accuracy: 0.9970 - val_loss: 1.6444e-04 - val_accuracy: 1.0000\n", "Epoch 4/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 0.0056 - accuracy: 0.9990 - val_loss: 1.6097e-05 - val_accuracy: 1.0000\n", "Epoch 5/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 0.0044 - accuracy: 0.9989 - val_loss: 4.0286e-06 - val_accuracy: 1.0000\n", "Epoch 6/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 0.0016 - accuracy: 0.9997 - val_loss: 7.1377e-07 - val_accuracy: 1.0000\n", "Epoch 7/100\n", "1050/1050 [==============================] - 2s 2ms/step - loss: 0.0015 - accuracy: 0.9997 - val_loss: 9.0846e-07 - val_accuracy: 1.0000\n", "Epoch 8/100\n", "1050/1050 [==============================] - 3s 3ms/step - loss: 9.9385e-04 - accuracy: 0.9998 - val_loss: 1.8082e-07 - val_accuracy: 1.0000\n", "Epoch 9/100\n", "1050/1050 [==============================] - 3s 3ms/step - loss: 0.0019 - accuracy: 0.9998 - val_loss: 3.0069e-08 - val_accuracy: 1.0000\n", "Epoch 10/100\n", "1050/1050 [==============================] - 3s 3ms/step - loss: 0.0011 - accuracy: 0.9998 - val_loss: 2.4598e-04 - val_accuracy: 0.9999\n", "Epoch 11/100\n", "1050/1050 [==============================] - 3s 3ms/step - loss: 0.0021 - accuracy: 0.9995 - val_loss: 2.6330e-08 - val_accuracy: 1.0000\n", "Epoch 12/100\n", "1050/1050 [==============================] - 4s 3ms/step - loss: 0.0018 - accuracy: 0.9999 - val_loss: 2.6572e-08 - val_accuracy: 1.0000\n", "Epoch 13/100\n", "1050/1050 [==============================] - 3s 3ms/step - loss: 6.9760e-04 - accuracy: 0.9998 - val_loss: 5.6330e-09 - val_accuracy: 1.0000\n", "Epoch 14/100\n", "1050/1050 [==============================] - 3s 3ms/step - loss: 7.4783e-04 - accuracy: 0.9998 - val_loss: 7.5862e-09 - val_accuracy: 1.0000\n", "Epoch 15/100\n", "1050/1050 [==============================] - 4s 3ms/step - loss: 7.9774e-04 - accuracy: 0.9998 - val_loss: 1.3675e-08 - val_accuracy: 1.0000\n", "Epoch 16/100\n", "1050/1050 [==============================] - 4s 4ms/step - loss: 5.4841e-04 - accuracy: 0.9998 - val_loss: 1.2942e-09 - val_accuracy: 1.0000\n", "Epoch 17/100\n", "1050/1050 [==============================] - 3s 3ms/step - loss: 0.0014 - accuracy: 0.9997 - val_loss: 6.1260e-10 - val_accuracy: 1.0000\n", "Epoch 18/100\n", "1050/1050 [==============================] - 4s 4ms/step - loss: 0.0018 - accuracy: 0.9999 - val_loss: 2.6419e-09 - val_accuracy: 1.0000\n", "Epoch 19/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 8.0635e-04 - accuracy: 0.9999 - val_loss: 1.2913e-09 - val_accuracy: 1.0000\n", "Epoch 20/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 2.6192e-04 - accuracy: 1.0000 - val_loss: 8.3605e-10 - val_accuracy: 1.0000\n", "Epoch 21/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 5.2448e-04 - accuracy: 0.9998 - val_loss: 1.1165e-09 - val_accuracy: 1.0000\n", "Epoch 22/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 9.2879e-04 - accuracy: 0.9999 - val_loss: 3.9623e-10 - val_accuracy: 1.0000\n", "Epoch 23/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 3.7082e-04 - accuracy: 0.9999 - val_loss: 2.9649e-10 - val_accuracy: 1.0000\n", "Epoch 24/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 2.6710e-04 - accuracy: 0.9999 - val_loss: 3.5300e-09 - val_accuracy: 1.0000\n", "Epoch 25/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 5.3370e-04 - accuracy: 0.9999 - val_loss: 2.5315e-10 - val_accuracy: 1.0000\n", "Epoch 26/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 7.1824e-04 - accuracy: 0.9999 - val_loss: 4.3657e-10 - val_accuracy: 1.0000\n", "Epoch 27/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 1.8679e-04 - accuracy: 0.9999 - val_loss: 1.7553e-10 - val_accuracy: 1.0000\n", "Epoch 28/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 5.2067e-04 - accuracy: 0.9999 - val_loss: 1.3316e-09 - val_accuracy: 1.0000\n", "Epoch 29/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 2.6381e-04 - accuracy: 0.9999 - val_loss: 5.6867e-10 - val_accuracy: 1.0000\n", "Epoch 30/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 4.4551e-04 - accuracy: 0.9999 - val_loss: 9.0114e-10 - val_accuracy: 1.0000\n", "Epoch 31/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 6.7519e-04 - accuracy: 0.9999 - val_loss: 1.7674e-09 - val_accuracy: 1.0000\n", "Epoch 32/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 8.1789e-04 - accuracy: 0.9999 - val_loss: 4.1441e-10 - val_accuracy: 1.0000\n", "Epoch 33/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 4.6309e-04 - accuracy: 0.9999 - val_loss: 4.5561e-10 - val_accuracy: 1.0000\n", "Epoch 34/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 2.9113e-04 - accuracy: 0.9999 - val_loss: 1.0894e-10 - val_accuracy: 1.0000\n", "Epoch 35/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 4.8002e-04 - accuracy: 0.9999 - val_loss: 9.3475e-11 - val_accuracy: 1.0000\n", "Epoch 36/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 4.2280e-04 - accuracy: 0.9999 - val_loss: 4.3340e-10 - val_accuracy: 1.0000\n", "Epoch 37/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 9.3696e-04 - accuracy: 0.9998 - val_loss: 2.6858e-10 - val_accuracy: 1.0000\n", "Epoch 38/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 2.6842e-04 - accuracy: 1.0000 - val_loss: 1.8001e-10 - val_accuracy: 1.0000\n", "Epoch 39/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 3.5864e-04 - accuracy: 0.9999 - val_loss: 1.1462e-10 - val_accuracy: 1.0000\n", "Epoch 40/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 3.7118e-04 - accuracy: 0.9999 - val_loss: 4.5263e-11 - val_accuracy: 1.0000\n", "Epoch 41/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 4.3556e-04 - accuracy: 0.9999 - val_loss: 4.1749e-12 - val_accuracy: 1.0000\n", "Epoch 42/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 3.2305e-04 - accuracy: 0.9999 - val_loss: 5.6594e-12 - val_accuracy: 1.0000\n", "Epoch 43/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 2.9655e-04 - accuracy: 0.9999 - val_loss: 8.7916e-11 - val_accuracy: 1.0000\n", "Epoch 44/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 3.4267e-04 - accuracy: 0.9999 - val_loss: 3.0908e-10 - val_accuracy: 1.0000\n", "Epoch 45/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 5.3887e-05 - accuracy: 1.0000 - val_loss: 4.7371e-11 - val_accuracy: 1.0000\n", "Epoch 46/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 1.2410e-04 - accuracy: 1.0000 - val_loss: 8.3557e-11 - val_accuracy: 1.0000\n", "Epoch 47/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 3.3613e-04 - accuracy: 1.0000 - val_loss: 4.1424e-11 - val_accuracy: 1.0000\n", "Epoch 48/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 1.0253e-04 - accuracy: 1.0000 - val_loss: 2.1587e-11 - val_accuracy: 1.0000\n", "Epoch 49/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 1.7809e-04 - accuracy: 0.9999 - val_loss: 3.7521e-11 - val_accuracy: 1.0000\n", "Epoch 50/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 2.6325e-04 - accuracy: 0.9999 - val_loss: 1.2730e-11 - val_accuracy: 1.0000\n", "Epoch 51/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 8.8403e-05 - accuracy: 1.0000 - val_loss: 1.6883e-11 - val_accuracy: 1.0000\n", "Epoch 52/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 1.2979e-04 - accuracy: 1.0000 - val_loss: 2.6181e-12 - val_accuracy: 1.0000\n", "Epoch 53/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 2.7255e-04 - accuracy: 0.9999 - val_loss: 3.3547e-14 - val_accuracy: 1.0000\n", "Epoch 54/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 4.0768e-04 - accuracy: 0.9999 - val_loss: 1.9424e-14 - val_accuracy: 1.0000\n", "Epoch 55/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 2.9720e-04 - accuracy: 0.9999 - val_loss: 5.9644e-14 - val_accuracy: 1.0000\n", "Epoch 56/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 3.8690e-05 - accuracy: 1.0000 - val_loss: 5.4575e-13 - val_accuracy: 1.0000\n", "Epoch 57/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 5.1015e-05 - accuracy: 1.0000 - val_loss: 2.7099e-13 - val_accuracy: 1.0000\n", "Epoch 58/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 7.5753e-05 - accuracy: 1.0000 - val_loss: 1.1129e-14 - val_accuracy: 1.0000\n", "Epoch 59/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 4.9979e-04 - accuracy: 1.0000 - val_loss: 1.0860e-14 - val_accuracy: 1.0000\n", "Epoch 60/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 7.2751e-04 - accuracy: 0.9999 - val_loss: 1.0344e-10 - val_accuracy: 1.0000\n", "Epoch 61/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 2.4999e-04 - accuracy: 0.9999 - val_loss: 3.8716e-13 - val_accuracy: 1.0000\n", "Epoch 62/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 2.1617e-04 - accuracy: 0.9999 - val_loss: 9.1705e-14 - val_accuracy: 1.0000\n", "Epoch 63/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 5.4722e-04 - accuracy: 0.9999 - val_loss: 1.8718e-13 - val_accuracy: 1.0000\n", "Epoch 64/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 0.0013 - accuracy: 0.9999 - val_loss: 3.2839e-12 - val_accuracy: 1.0000\n", "Epoch 65/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 3.5692e-04 - accuracy: 0.9999 - val_loss: 3.2787e-12 - val_accuracy: 1.0000\n", "Epoch 66/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 2.1968e-04 - accuracy: 1.0000 - val_loss: 1.0670e-11 - val_accuracy: 1.0000\n", "Epoch 67/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 2.5617e-04 - accuracy: 0.9999 - val_loss: 3.8569e-12 - val_accuracy: 1.0000\n", "Epoch 68/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 1.8893e-04 - accuracy: 1.0000 - val_loss: 6.3491e-12 - val_accuracy: 1.0000\n", "Epoch 69/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 8.1594e-05 - accuracy: 1.0000 - val_loss: 2.9203e-12 - val_accuracy: 1.0000\n", "Epoch 70/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 7.6071e-04 - accuracy: 0.9999 - val_loss: 1.9254e-13 - val_accuracy: 1.0000\n", "Epoch 71/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 1.2615e-04 - accuracy: 1.0000 - val_loss: 4.7641e-13 - val_accuracy: 1.0000\n", "Epoch 72/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 2.1528e-04 - accuracy: 1.0000 - val_loss: 5.8274e-13 - val_accuracy: 1.0000\n", "Epoch 73/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 1.6981e-04 - accuracy: 1.0000 - val_loss: 2.4507e-13 - val_accuracy: 1.0000\n", "Epoch 74/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 6.5145e-04 - accuracy: 0.9999 - val_loss: 1.1665e-12 - val_accuracy: 1.0000\n", "Epoch 75/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 3.1496e-05 - accuracy: 1.0000 - val_loss: 4.0618e-11 - val_accuracy: 1.0000\n", "Epoch 76/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 2.2472e-04 - accuracy: 0.9999 - val_loss: 2.1636e-11 - val_accuracy: 1.0000\n", "Epoch 77/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 4.5909e-04 - accuracy: 0.9999 - val_loss: 8.5723e-13 - val_accuracy: 1.0000\n", "Epoch 78/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 4.1828e-04 - accuracy: 0.9999 - val_loss: 1.0288e-13 - val_accuracy: 1.0000\n", "Epoch 79/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 2.5019e-04 - accuracy: 0.9999 - val_loss: 1.9727e-13 - val_accuracy: 1.0000\n", "Epoch 80/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 0.0014 - accuracy: 0.9999 - val_loss: 2.4567e-13 - val_accuracy: 1.0000\n", "Epoch 81/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 2.6808e-04 - accuracy: 0.9999 - val_loss: 1.4976e-13 - val_accuracy: 1.0000\n", "Epoch 82/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 4.3370e-05 - accuracy: 1.0000 - val_loss: 1.2957e-13 - val_accuracy: 1.0000\n", "Epoch 83/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 1.3340e-04 - accuracy: 1.0000 - val_loss: 1.7993e-13 - val_accuracy: 1.0000\n", "Epoch 84/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 0.0012 - accuracy: 0.9999 - val_loss: 6.4421e-13 - val_accuracy: 1.0000\n", "Epoch 85/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 8.9951e-05 - accuracy: 1.0000 - val_loss: 1.0772e-13 - val_accuracy: 1.0000\n", "Epoch 86/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 2.1728e-05 - accuracy: 1.0000 - val_loss: 6.3775e-14 - val_accuracy: 1.0000\n", "Epoch 87/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 1.8351e-04 - accuracy: 0.9999 - val_loss: 2.3062e-13 - val_accuracy: 1.0000\n", "Epoch 88/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 2.5166e-05 - accuracy: 1.0000 - val_loss: 1.6359e-13 - val_accuracy: 1.0000\n", "Epoch 89/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 4.7680e-05 - accuracy: 1.0000 - val_loss: 8.0235e-14 - val_accuracy: 1.0000\n", "Epoch 90/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 8.1901e-05 - accuracy: 1.0000 - val_loss: 1.0808e-14 - val_accuracy: 1.0000\n", "Epoch 91/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 1.4072e-04 - accuracy: 1.0000 - val_loss: 2.9378e-14 - val_accuracy: 1.0000\n", "Epoch 92/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 4.4237e-04 - accuracy: 0.9999 - val_loss: 2.1903e-13 - val_accuracy: 1.0000\n", "Epoch 93/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 4.1000e-04 - accuracy: 1.0000 - val_loss: 7.1069e-13 - val_accuracy: 1.0000\n", "Epoch 94/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 1.4392e-04 - accuracy: 0.9999 - val_loss: 6.6802e-13 - val_accuracy: 1.0000\n", "Epoch 95/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 9.6308e-04 - accuracy: 0.9999 - val_loss: 2.2745e-13 - val_accuracy: 1.0000\n", "Epoch 96/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 3.4975e-05 - accuracy: 1.0000 - val_loss: 3.1772e-14 - val_accuracy: 1.0000\n", "Epoch 97/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 1.2595e-04 - accuracy: 1.0000 - val_loss: 1.1878e-13 - val_accuracy: 1.0000\n", "Epoch 98/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 1.8944e-04 - accuracy: 0.9999 - val_loss: 1.3093e-13 - val_accuracy: 1.0000\n", "Epoch 99/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 2.1216e-05 - accuracy: 1.0000 - val_loss: 5.9066e-14 - val_accuracy: 1.0000\n", "Epoch 100/100\n", "1050/1050 [==============================] - 1s 1ms/step - loss: 3.3804e-05 - accuracy: 1.0000 - val_loss: 4.5820e-14 - val_accuracy: 1.0000\n", "263/263 [==============================] - 0s 853us/step\n", "Accuracy: 1.0\n" ] } ], "source": [ "# Neural Network\n", "from tensorflow.keras.models import Sequential\n", "from tensorflow.keras.layers import Dense\n", "from sklearn.metrics import accuracy_score\n", "from tensorflow.keras.layers import Dropout\n", "\n", "# Define the model\n", "model = Sequential()\n", "model.add(Dense(32, input_dim=X_train.shape[1], activation='relu')) # Input layer\n", "model.add(Dropout(0.5)) # Dropout layer\n", "model.add(Dense(32, activation='relu')) # Hidden layer\n", "model.add(Dropout(0.5)) # Dropout layer\n", "model.add(Dense(1, activation='sigmoid')) # Output layer\n", "\n", "# Compile the model\n", "model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])\n", "\n", "# Train the model\n", "model.fit(X_train, y_train, epochs=100, batch_size=32, validation_data=(X_test, y_test))\n", "\n", "# Make predictions on the test set\n", "y_pred_prob = model.predict(X_test)\n", "y_pred = (y_pred_prob > 0.5).astype(\"int32\")\n", "\n", "# Calculate the accuracy of the model\n", "accuracy = accuracy_score(y_test, y_pred)\n", "\n", "print(f\"Accuracy: {accuracy}\")" ], "metadata": { "collapsed": false, "ExecuteTime": { "end_time": "2024-03-11T09:39:19.675444Z", "start_time": "2024-03-11T09:36:33.752081Z" } }, "id": "7b2464a3243d2114", "execution_count": 38 } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 2 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython2", "version": "2.7.6" } }, "nbformat": 4, "nbformat_minor": 5 }